*** src/backend/storage/ipc/wamalloc.c c21a430ced2cdc65a8d7e6e9243153b837e44ff6 --- src/backend/storage/ipc/wamalloc.c c21a430ced2cdc65a8d7e6e9243153b837e44ff6 *************** *** 1,0 **** --- 1,670 ---- + /*------------------------------------------------------------------------- + * + * wamalloc.c + * simple, lock-based dynamic memory allocator for shared memory. + * + * Portions Copyright (c) 1996-2010, PostgreSQL Global Development Group + * + *------------------------------------------------------------------------- + */ + + #include "postgres.h" + + #include "miscadmin.h" + #include "storage/pg_shmem.h" + #include "storage/shmem.h" + #include "storage/spin.h" + + + /* + * The number of sizeclasses and heaps (per sizeclass) to partition the + * shared memory area into. + */ + #define NUMBER_OF_SIZECLASSES 16 + #define NUMBER_OF_HEAPS 1 + + /* + * The number of bits of a pointer, which always remain zero due to the + * machine or implementation specific alignment. Higher numbers allow more + * bits to be used for credits, but waste more space. + */ + #define POINTER_ALIGNMENT 6 + + /* + * The number of bits to use for the count field. Again, plus the maximum + * value. It must be able to store the maximum number of blocks fitting in + * a superblock. + */ + #define BLOCK_COUNT_BITS 15 + #define MAX_BLOCK_COUNT 32768 + + /* + * Size of the superblocks to allocate, not including the superblock header + * of struct t_wam_superblock. + */ + #define SUPERBLOCK_SIZE 65536 + + /* + * Descriptor state constants + */ + #define STATE_EMPTY 0 + #define STATE_PARTIAL 2 + #define STATE_FULL 3 + + + struct t_wam_heap; + typedef volatile struct t_wam_heap* t_heap_ptr; + + #pragma pack(push) /* push current alignment to stack */ + #pragma pack(1) /* set alignment to 1 byte boundary */ + + typedef struct t_wam_anchor + { + union + { + struct + { + uint64_t avail:(62 - BLOCK_COUNT_BITS), + count:BLOCK_COUNT_BITS, + state:2; + }; + uint64_t value; + }; + } t_anchor; + + #pragma pack(pop) /* restore original alignment from stack */ + + struct t_wam_desc + { + volatile struct t_wam_desc *next; + #ifdef MAGIC + MAGIC_TYPE magic; + #endif + struct t_wam_anchor Anchor; + volatile void *sb; + t_heap_ptr heap; + unsigned int sz; + unsigned int maxcount; + slock_t DescLock; + }; + typedef volatile struct t_wam_desc* t_desc_ptr; + + struct t_wam_sizeclass + { + t_desc_ptr partial_desc_list; + unsigned int sz; + }; + typedef volatile struct t_wam_sizeclass* t_sizeclass_ptr; + + struct t_wam_superblock + { + volatile struct t_wam_superblock *next; + }; + typedef volatile struct t_wam_superblock* t_superblock_ptr; + + struct t_wam_heap + { + t_desc_ptr Active; + t_sizeclass_ptr sc; + slock_t HeapLock; + }; + + /* + * Global control structure, appears exactly once. + */ + struct t_wam_control + { + t_sizeclass_ptr sizeclasses; /* global sizeclasses */ + t_heap_ptr global_heap; /* multiple heaps per sizeclass */ + t_desc_ptr DescAvail; /* list of avail. descriptors */ + t_superblock_ptr SuperblockAvail; /* list of avail. superblocks */ + slock_t WamLock; /* big allocator lock */ + }; + typedef volatile struct t_wam_control* t_control_ptr; + + /* single global entry point(er) */ + static volatile struct t_wam_control *ctl; + + #define POINTER_MASK ((intptr_t) (-1) << POINTER_ALIGNMENT) + #define IS_ALIGNED(ptr) (((intptr_t) (ptr) & (~POINTER_MASK)) == 0) + #define ALIGN_POINTER(ptr) ((void*) (((intptr_t) ptr + ~POINTER_MASK) & POINTER_MASK)) + #define ALIGN_SIZE(i) (((intptr_t) i + ~POINTER_MASK) & POINTER_MASK) + #define USABLE_SUPERBLOCK_SIZE (SUPERBLOCK_SIZE - \ + sizeof(struct t_wam_superblock)) + + static t_heap_ptr find_heap(size_t request_size); + static t_superblock_ptr wam_alloc_sblock(void); + static void wam_free_sblock(t_superblock_ptr sb); + static volatile void* wam_desc_alloc(void); + + static void wam_partial_list_push(t_sizeclass_ptr sc, t_desc_ptr desc); + static t_desc_ptr wam_partial_list_pop(t_sizeclass_ptr sc); + + static void wam_desc_free(volatile void *ptr); + static void* wam_alloc_from_partial(t_heap_ptr heap); + static void* wam_alloc_from_sblock(t_heap_ptr heap); + + + static t_heap_ptr + find_heap(size_t request_size) + { + int sizeclass_no; + int heap_no; + + /* + * We require an additional header to point to the descriptor. Possibly + * add 64bit for a magic value to be checked. + */ + request_size += sizeof(t_desc_ptr); + + /* + * FIXME: there certainly are more efficient ways to find the target + * sizeclass. + */ + sizeclass_no = 0; + while (ctl->sizeclasses[sizeclass_no].sz < request_size) + sizeclass_no++; + Assert(sizeclass_no < NUMBER_OF_SIZECLASSES); + + heap_no = MyProcPid % NUMBER_OF_HEAPS; + + return &ctl->global_heap[sizeclass_no * NUMBER_OF_HEAPS + heap_no]; + } + + static t_superblock_ptr + wam_alloc_sblock(void) + { + t_superblock_ptr sb; + + sb = ctl->SuperblockAvail; + if (sb) + ctl->SuperblockAvail = sb->next; + + return sb; + } + + static void + wam_free_sblock(t_superblock_ptr sb) + { + sb->next = ctl->SuperblockAvail; + ctl->SuperblockAvail = sb; + } + + static volatile void* + wam_desc_alloc(void) + { + t_desc_ptr desc, next, this; + int i, max, dsize; + + desc = (t_desc_ptr) ctl->DescAvail; + + if (!desc) + { + desc = (t_desc_ptr) wam_alloc_sblock(); + + if (desc) + { + dsize = ALIGN_SIZE(sizeof(struct t_wam_desc)); + max = USABLE_SUPERBLOCK_SIZE / dsize; + + this = (t_desc_ptr) (((char*) desc) + dsize * (max - 1)); + this->next = NULL; + #ifdef MAGIC + this->magic = MAGIC_VALUE; + #endif + for (i = max - 2; i >= 0; i--) + { + this = (t_desc_ptr) (((char*) desc) + dsize * (i)); + next = (t_desc_ptr) (((char*) desc) + dsize * (i+1)); + + this->next = next; + #ifdef MAGIC + this->magic = MAGIC_VALUE; + #endif + } + + } + } + + if (desc) + ctl->DescAvail = desc->next; + + return (void*) desc; + } + + static void + wam_partial_list_push(t_sizeclass_ptr sc, t_desc_ptr desc) + { + #ifdef MAGIC + Assert(desc->magic == MAGIC_VALUE); + #endif + + desc->next = sc->partial_desc_list; + sc->partial_desc_list = desc; + } + + static t_desc_ptr + wam_partial_list_pop(t_sizeclass_ptr sc) + { + t_desc_ptr desc; + + desc = (t_desc_ptr) sc->partial_desc_list; + + #ifdef MAGIC + if (desc) + Assert(desc->magic == MAGIC_VALUE); + #endif + + if (desc) + sc->partial_desc_list = desc->next; + + return desc; + } + + static void + wam_desc_free(volatile void *ptr) + { + t_desc_ptr desc = ptr; + + #ifdef MAGIC + Assert(desc->magic == MAGIC_VALUE); + #endif + + desc->next = ctl->DescAvail; + ctl->DescAvail = desc; + } + + static void* + wam_alloc_from_partial(const t_heap_ptr heap) + { + t_desc_ptr desc; + t_anchor oldanchor; + intptr_t *addr; + + SpinLockAcquire(&heap->HeapLock); + + desc = heap->Active; + + retry: + if (!desc) + { + SpinLockRelease(&heap->HeapLock); + return NULL; + } + + SpinLockAcquire(&desc->DescLock); + + #ifdef MAGIC + Assert(desc->magic == MAGIC_VALUE); + #endif + + if (desc->Anchor.state == STATE_FULL) + { + SpinLockAcquire(&ctl->WamLock); + SpinLockRelease(&desc->DescLock); + + desc = wam_partial_list_pop(heap->sc); + heap->Active = desc; + + SpinLockRelease(&ctl->WamLock); + + goto retry; + } + else if (desc->Anchor.state == STATE_EMPTY) + { + SpinLockAcquire(&ctl->WamLock); + SpinLockRelease(&desc->DescLock); + + wam_desc_free(desc); + desc = wam_partial_list_pop(heap->sc); + heap->Active = desc; + + SpinLockRelease(&ctl->WamLock); + + goto retry; + } + + /* release the heap lock as early as possible */ + SpinLockRelease(&heap->HeapLock); + + desc->heap = heap; + + oldanchor.value = desc->Anchor.value; + + Assert(desc->Anchor.state == STATE_PARTIAL); + Assert(desc->Anchor.count > 0); + + desc->Anchor.count -= 1; + desc->Anchor.state = (desc->Anchor.count > 0 ? + STATE_PARTIAL : STATE_FULL); + + Assert(desc->Anchor.avail < desc->maxcount); + addr = (intptr_t*) ((Pointer) desc->sb + + desc->Anchor.avail * desc->sz); + Assert(*addr >= 0); + Assert(*addr < desc->maxcount); + + desc->Anchor.avail = *addr; + Assert(desc->Anchor.avail < desc->maxcount); + + SpinLockRelease(&desc->DescLock); + + *addr = (intptr_t) desc; + + return addr + 1; + } + + static void* + wam_alloc_from_sblock(const t_heap_ptr heap) + { + t_desc_ptr desc; + unsigned int i; + intptr_t *addr = NULL; + + SpinLockAcquire(&heap->HeapLock); + SpinLockAcquire(&ctl->WamLock); + + desc = wam_desc_alloc(); + if (desc) + { + #ifdef MAGIC + Assert(desc->magic == MAGIC_VALUE); + #endif + + desc->heap = heap; + Assert(IS_ALIGNED(heap->sc->sz)); + desc->sz = heap->sc->sz; + desc->maxcount = USABLE_SUPERBLOCK_SIZE / desc->sz; + Assert(desc->maxcount < MAX_BLOCK_COUNT); + Assert(desc->maxcount > 2); + + desc->Anchor.avail = 1; + desc->Anchor.count = desc->maxcount - 1; + + desc->Anchor.state = STATE_PARTIAL; + + /* allocate a superblock and initialize it */ + desc->sb = wam_alloc_sblock(); + + if (desc->sb) + { + /* organize blocks in a linked list starting with index 0 */ + i = 0; + addr = (intptr_t*) desc->sb; + while (1) + { + i++; + if (i < desc->maxcount) + { + *addr = i; + addr += desc->sz / sizeof(Pointer); + } + else + { + *addr = 0; + break; + } + } + + addr = (intptr_t*) desc->sb; + *addr = (intptr_t) desc; + + if (heap->Active) + wam_partial_list_push(heap->sc, desc); + else + heap->Active = desc; + + addr += 1; + } + else + wam_desc_free(desc); + } + + SpinLockRelease(&ctl->WamLock); + SpinLockRelease(&heap->HeapLock); + + return addr; + } + + void* + wam_alloc(size_t sz) + { + t_heap_ptr heap; + Pointer addr = NULL; + + #ifdef MAGIC + sz += 2 * sizeof(MAGIC_TYPE); + #endif + + heap = find_heap(sz); + Assert(heap); + + START_CRIT_SECTION(); + { + addr = wam_alloc_from_partial(heap); + if (!addr) + addr = wam_alloc_from_sblock(heap); + } + END_CRIT_SECTION(); + + #ifdef MAGIC + *((MAGIC_TYPE*) addr) = MAGIC_VALUE; + *((MAGIC_TYPE*) (addr + heap->sc->sz - sizeof(Pointer) + - sizeof(MAGIC_TYPE))) = MAGIC_VALUE; + addr += sizeof(MAGIC_TYPE); + #endif + + if (!addr) + elog(WARNING, "out of dynamic shared memory!"); + + return addr; + } + + void + wam_free(void* ptr) + { + t_desc_ptr desc; + t_heap_ptr heap = NULL; + t_anchor anchor, oldanchor; + t_superblock_ptr freeable_sb = NULL; + Pointer addr; + + Assert(ptr); + + addr = (Pointer) ptr; + + #ifdef MAGIC + addr -= sizeof(MAGIC_TYPE); + Assert(*((MAGIC_TYPE*) addr) == MAGIC_VALUE); + #endif + + addr -= sizeof(Pointer); + desc = *((t_desc_ptr*) addr); + + Assert(desc->sb); + Assert((intptr_t) desc > 0xff); + + START_CRIT_SECTION(); + { + SpinLockAcquire(&desc->DescLock); + + #ifdef MAGIC + Assert(desc->magic == MAGIC_VALUE); + Assert(*((MAGIC_TYPE*)(addr + desc->heap->sc->sz + - sizeof(MAGIC_TYPE))) == MAGIC_VALUE); + #endif + + Assert(desc->Anchor.count < desc->maxcount); + + *((intptr_t*) addr) = desc->Anchor.avail; + oldanchor.value = desc->Anchor.value; + if (desc->Anchor.count == desc->maxcount - 1) + { + Assert(desc->Anchor.state == STATE_PARTIAL); + + desc->Anchor.avail = 0; /* just here for the compiler */ + desc->Anchor.count = 0; /* just here for the compiler */ + desc->Anchor.state = STATE_EMPTY; + + freeable_sb = desc->sb; + desc->sb = NULL; + } + else + { + heap = desc->heap; + + desc->Anchor.avail = (addr - (Pointer) desc->sb) / desc->sz; + Assert(desc->Anchor.avail < desc->maxcount); + desc->Anchor.count++; + Assert(desc->Anchor.count < desc->maxcount); + desc->Anchor.state = STATE_PARTIAL; + } + + anchor.value = desc->Anchor.value; + + SpinLockRelease(&desc->DescLock); + + if (freeable_sb) + { + Assert(anchor.state == STATE_EMPTY); + + SpinLockAcquire(&ctl->WamLock); + wam_free_sblock(freeable_sb); + SpinLockRelease(&ctl->WamLock); + } + else if (oldanchor.state == STATE_FULL) + { + Assert(heap != NULL); + + SpinLockAcquire(&ctl->WamLock); + wam_partial_list_push(heap->sc, desc); + SpinLockRelease(&ctl->WamLock); + } + } + END_CRIT_SECTION(); + } + + void + wam_check(void *ptr) + { + Pointer addr; + t_desc_ptr desc; + + Assert(ptr); + + addr = (Pointer) ptr; + + #ifdef MAGIC + addr -= sizeof(MAGIC_TYPE); + Assert(*((MAGIC_TYPE*) addr) == MAGIC_VALUE); + #endif + + addr -= sizeof(Pointer); + desc = *((t_desc_ptr*) addr); + + Assert((intptr_t) desc > 0xff); + + #ifdef MAGIC + Assert(*((MAGIC_TYPE*)(addr + desc->heap->sc->sz + - sizeof(MAGIC_TYPE))) == MAGIC_VALUE); + Assert(desc->magic == MAGIC_VALUE); + #endif + + Assert(desc->Anchor.avail < desc->maxcount); + Assert(desc->Anchor.count < desc->maxcount); + } + + int + wam_size(void) + { + /* FIXME: correct size calculation */ + return MAXALIGN(sizeof(struct t_wam_control) + + sizeof(struct t_wam_sizeclass) * NUMBER_OF_SIZECLASSES + + sizeof(struct t_wam_heap) * NUMBER_OF_HEAPS * NUMBER_OF_SIZECLASSES + + 4 * POINTER_MASK + + ShmemDynBufferSize); + } + + void + wam_init() + { + Pointer ptr, shmem; + t_superblock_ptr sb; + int i, j, size; + bool found; + + size = wam_size(); + ptr = shmem = ShmemInitStruct("ShmemDynAllocCtl", size, &found); + + if (found) + return; + + ctl = (t_control_ptr) ptr; + ptr += sizeof(struct t_wam_control); + ptr = ALIGN_POINTER(ptr); + + /* + * Create a useful set of sizeclasses. + */ + ctl->sizeclasses = (t_sizeclass_ptr) ptr; + ctl->sizeclasses[0].partial_desc_list = NULL; + ctl->sizeclasses[0].sz = 1 << POINTER_ALIGNMENT; + for (i = 1; i < NUMBER_OF_SIZECLASSES; i++) + { + ctl->sizeclasses[i].partial_desc_list = NULL; + ctl->sizeclasses[i].sz = ctl->sizeclasses[i-1].sz * 2; + + Assert(IS_ALIGNED(ctl->sizeclasses[i].sz)); + + Assert(USABLE_SUPERBLOCK_SIZE / ctl->sizeclasses[i].sz < + MAX_BLOCK_COUNT); + } + ptr += sizeof(struct t_wam_sizeclass) * NUMBER_OF_SIZECLASSES; + ptr = ALIGN_POINTER(ptr); + + /* + * Initialize the global heap control structures + */ + ctl->global_heap = (t_heap_ptr) ptr; + for (i = 0; i < NUMBER_OF_SIZECLASSES; i++) + { + for (j = 0; j < NUMBER_OF_HEAPS; j++) + { + t_heap_ptr heap = &ctl->global_heap[i * NUMBER_OF_HEAPS + j]; + + SpinLockInit(&heap->HeapLock); + heap->Active = NULL; + heap->sc = &ctl->sizeclasses[i]; + } + } + ptr += sizeof(struct t_wam_heap) * + NUMBER_OF_HEAPS * NUMBER_OF_SIZECLASSES; + ptr = ALIGN_POINTER(ptr); + + /* + * Initialize the stack for parking available descriptors. + */ + ctl->DescAvail = NULL; + SpinLockInit(&ctl->WamLock); + + /* + * Organize the remaining space of shared memory into a singly linked + * lits of superblocks of size SUPERBLOCK_SIZE. + */ + ptr = ALIGN_POINTER(ptr); + + ctl->SuperblockAvail = NULL; + while ((ptr - shmem) < (size - SUPERBLOCK_SIZE)) + { + sb = (t_superblock_ptr) ptr; + ptr += SUPERBLOCK_SIZE; + + Assert(IS_ALIGNED(ptr)); + + /* push onto the stack */ + sb->next = ctl->SuperblockAvail; + ctl->SuperblockAvail = sb; + + i++; + } + } ============================================================ *** src/backend/storage/ipc/Makefile 6c6ff1afae22b8de6ffc2d092407478e66de6ff7 --- src/backend/storage/ipc/Makefile 0610a969a64989edaa2c19f9c25362bd888bdeb9 *************** OBJS = ipc.o ipci.o pmsignal.o procarray *** 16,21 **** endif OBJS = ipc.o ipci.o pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o \ ! sinval.o sinvaladt.o standby.o include $(top_srcdir)/src/backend/common.mk --- 16,21 ---- endif OBJS = ipc.o ipci.o pmsignal.o procarray.o procsignal.o shmem.o shmqueue.o \ ! sinval.o sinvaladt.o standby.o wamalloc.o include $(top_srcdir)/src/backend/common.mk ============================================================ *** src/backend/storage/ipc/ipci.c e342a127d85e601576379a4f58fb62c1fc23d97c --- src/backend/storage/ipc/ipci.c 2c2131711f38125a39ec0c9dfaef970ca873d142 *************** CreateSharedMemoryAndSemaphores(bool mak *** 104,109 **** --- 104,110 ---- size = add_size(size, hash_estimate_size(SHMEM_INDEX_SIZE, sizeof(ShmemIndexEnt))); size = add_size(size, BufferShmemSize()); + size = add_size(size, ShmemDynAllocSize()); size = add_size(size, LockShmemSize()); size = add_size(size, ProcGlobalShmemSize()); size = add_size(size, XLOGShmemSize()); *************** CreateSharedMemoryAndSemaphores(bool mak *** 185,190 **** --- 186,196 ---- InitShmemIndex(); /* + * Set up dynamically allocatable area in shared memory. + */ + ShmemDynAllocInit(); + + /* * Set up xlog, clog, and buffers */ XLOGShmemInit(); ============================================================ *** src/backend/storage/ipc/shmem.c bf9711329c544168e6b38dcf18a4e15a9a727b5c --- src/backend/storage/ipc/shmem.c 111243814fbf7d29e7f0ed36f031577ff101bba9 *************** InitShmemAllocation(void) *** 140,145 **** --- 140,161 ---- } /* + * Initialization of shared memory for dynamically allocated shared memory. + */ + int + ShmemDynAllocSize(void) + { + return wam_size(); + } + + void + ShmemDynAllocInit(void) + { + wam_init(); + } + + + /* * ShmemAlloc -- allocate max-aligned chunk from shared memory * * Assumes ShmemLock and ShmemSegHdr are initialized. *************** ShmemInitStruct(const char *name, Size s *** 411,416 **** --- 427,452 ---- } + void * + ShmemDynAlloc(size_t size) + { + return wam_alloc(size); + } + + void + ShmemDynFree(void *ptr) + { + wam_free(ptr); + } + + #ifdef MAGIC + void + ShmemDynCheck(void *ptr) + { + wam_check(ptr); + } + #endif + /* * Add two Size values, checking for overflow */ ============================================================ *** src/backend/storage/ipc/shmqueue.c d01f0bbb903a14e7fd4d2a5ec65985b32cad3718 --- src/backend/storage/ipc/shmqueue.c 2fbe744d1fc4b2a45f1eaa1704276a23edd3f542 *************** *** 26,31 **** --- 26,32 ---- #include "postgres.h" #include "storage/shmem.h" + #include "storage/spin.h" /* *************** SHMQueueEmpty(SHM_QUEUE *queue) *** 173,175 **** --- 174,241 ---- } return FALSE; } + + + void + deque_init(Deque *list) + { + DequeElem *tail; + + SpinLockInit(&list->lock); + + list->head.next = &list->head; + list->tail = &list->head; + + tail = list->tail; + Assert(tail->next == &list->head); + } + + void + deque_enqueue(Deque *list, DequeElem *elem) + { + DequeElem *tail; + + Assert(ShmemAddrIsValid(elem)); + Assert(list); + Assert(list->tail); + + tail = list->tail; + + Assert(ShmemAddrIsValid(tail)); + Assert(tail->next == &list->head); + + elem->next = &list->head; + tail->next = elem; + list->tail = elem; + + tail = list->tail; + Assert(tail->next == &list->head); + } + + DequeElem * + deque_dequeue(Deque *list) + { + DequeElem *tail; + DequeElem *elem = NULL; + + Assert(list); + Assert(list->tail); + + tail = list->tail; + Assert(tail->next == &list->head); + + if (list->head.next != &list->head) + { + elem = list->head.next; + list->head.next = elem->next; + + /* hm.. in a lock-free implementation, updating the tail pointer + here could pose a problem: if an enqueue adds an element + *before* we update the tail pointer, we miss that one. */ + + if (list->head.next == &list->head) + list->tail = &list->head; + } + + return elem; + } ============================================================ *** src/include/storage/shmem.h 3582e34b3882aaf554ca311f1d28fbe03775de6c --- src/include/storage/shmem.h 068b4aff617ae86bce155915e1a8137cb16337c0 *************** *** 21,29 **** --- 21,42 ---- #ifndef SHMEM_H #define SHMEM_H + #include #include "utils/hsearch.h" + #include "storage/s_lock.h" + /* + * For debug builds with assertions enabled we also enable magic value + * checking to help detect problems in dynamically allocated shared memory + * areas, because buffer overflows there can hurt very badly. + */ + #ifdef USE_ASSERT_CHECKING + #define MAGIC + typedef uint64_t MAGIC_TYPE; + #define MAGIC_VALUE 0x52b32fa9048c71deLL + #endif + /* shmqueue.c */ typedef struct SHM_QUEUE { *************** typedef struct SHM_QUEUE *** 31,37 **** --- 44,84 ---- struct SHM_QUEUE *next; } SHM_QUEUE; + typedef struct DequeElem + { + struct DequeElem *next; + } DequeElem; + + typedef struct Deque + { + DequeElem head; + DequeElem *tail; + slock_t lock; + } Deque; + + extern void deque_init(Deque *list); + extern void deque_enqueue(Deque *list, DequeElem *elem); + extern DequeElem *deque_dequeue(Deque *list); + + /* primalloc.c */ + extern int prim_size(void); + extern void prim_init(void); + extern void* prim_alloc(size_t sz); + extern void prim_free(void *ptr); + extern void prim_check(void *ptr); + + /* wamalloc.c */ + extern int wam_size(void); + extern void wam_init(void); + extern void* wam_alloc(size_t sz); + extern void wam_free(void *ptr); + extern void wam_check(void *ptr); + /* shmem.c */ + + /* TODO: replace with GUC variable to be configurable */ + #define ShmemDynBufferSize 2097152 /* 2 MiB */ + extern void InitShmemAccess(void *seghdr); extern void InitShmemAllocation(void); extern void *ShmemAlloc(Size size); *************** extern Size mul_size(Size s1, Size s2); *** 43,48 **** --- 90,103 ---- extern Size add_size(Size s1, Size s2); extern Size mul_size(Size s1, Size s2); + extern int ShmemDynAllocSize(void); + extern void ShmemDynAllocInit(void); + extern void *ShmemDynAlloc(size_t size); + extern void ShmemDynFree(void *ptr); + #ifdef MAGIC + extern void ShmemDynCheck(void *ptr); + #endif + /* ipci.c */ extern void RequestAddinShmemSpace(Size size);