#include "utils/memutils.h"

Include dependency graph for memutils_internal.h:

This graph shows which files directly or indirectly include this file:

Macros
#define	PallocAlignedExtraBytes(alignto) ((alignto) + (sizeof(MemoryChunk) - MAXIMUM_ALIGNOF))

#define	MEMORY_CONTEXT_METHODID_BITS 4

#define	MEMORY_CONTEXT_METHODID_MASK ((((uint64) 1) << MEMORY_CONTEXT_METHODID_BITS) - 1)

Typedefs
typedef enum MemoryContextMethodID	MemoryContextMethodID

Enumerations
enum	MemoryContextMethodID { MCTX_0_RESERVED_UNUSEDMEM_ID , MCTX_1_RESERVED_GLIBC_ID , MCTX_2_RESERVED_GLIBC_ID , MCTX_ASET_ID , MCTX_GENERATION_ID , MCTX_SLAB_ID , MCTX_ALIGNED_REDIRECT_ID , MCTX_BUMP_ID , MCTX_8_UNUSED_ID , MCTX_9_UNUSED_ID , MCTX_10_UNUSED_ID , MCTX_11_UNUSED_ID , MCTX_12_UNUSED_ID , MCTX_13_UNUSED_ID , MCTX_14_UNUSED_ID , MCTX_15_RESERVED_WIPEDMEM_ID }

Functions
void *	AllocSetAlloc (MemoryContext context, Size size, int flags)

void	AllocSetFree (void *pointer)

void *	AllocSetRealloc (void *pointer, Size size, int flags)

void	AllocSetReset (MemoryContext context)

void	AllocSetDelete (MemoryContext context)

MemoryContext	AllocSetGetChunkContext (void *pointer)

Size	AllocSetGetChunkSpace (void *pointer)

bool	AllocSetIsEmpty (MemoryContext context)

void	AllocSetStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void passthru, MemoryContextCounters totals, bool print_to_stderr)

void *	GenerationAlloc (MemoryContext context, Size size, int flags)

void	GenerationFree (void *pointer)

void *	GenerationRealloc (void *pointer, Size size, int flags)

void	GenerationReset (MemoryContext context)

void	GenerationDelete (MemoryContext context)

MemoryContext	GenerationGetChunkContext (void *pointer)

Size	GenerationGetChunkSpace (void *pointer)

bool	GenerationIsEmpty (MemoryContext context)

void	GenerationStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void passthru, MemoryContextCounters totals, bool print_to_stderr)

void *	SlabAlloc (MemoryContext context, Size size, int flags)

void	SlabFree (void *pointer)

void *	SlabRealloc (void *pointer, Size size, int flags)

void	SlabReset (MemoryContext context)

void	SlabDelete (MemoryContext context)

MemoryContext	SlabGetChunkContext (void *pointer)

Size	SlabGetChunkSpace (void *pointer)

bool	SlabIsEmpty (MemoryContext context)

void	SlabStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void passthru, MemoryContextCounters totals, bool print_to_stderr)

void	AlignedAllocFree (void *pointer)

void *	AlignedAllocRealloc (void *pointer, Size size, int flags)

MemoryContext	AlignedAllocGetChunkContext (void *pointer)

Size	AlignedAllocGetChunkSpace (void *pointer)

void *	BumpAlloc (MemoryContext context, Size size, int flags)

void	BumpFree (void *pointer)

void *	BumpRealloc (void *pointer, Size size, int flags)

void	BumpReset (MemoryContext context)

void	BumpDelete (MemoryContext context)

MemoryContext	BumpGetChunkContext (void *pointer)

Size	BumpGetChunkSpace (void *pointer)

bool	BumpIsEmpty (MemoryContext context)

void	BumpStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void passthru, MemoryContextCounters totals, bool print_to_stderr)

void	MemoryContextCreate (MemoryContext node, NodeTag tag, MemoryContextMethodID method_id, MemoryContext parent, const char *name)

void *	MemoryContextAllocationFailure (MemoryContext context, Size size, int flags)

void	MemoryContextSizeFailure (MemoryContext context, Size size, int flags) pg_attribute_noreturn()

static void	MemoryContextCheckSize (MemoryContext context, Size size, int flags)

Macro Definition Documentation

◆ MEMORY_CONTEXT_METHODID_BITS

#define MEMORY_CONTEXT_METHODID_BITS 4

Definition at line 145 of file memutils_internal.h.

◆ MEMORY_CONTEXT_METHODID_MASK

#define MEMORY_CONTEXT_METHODID_MASK ((((uint64) 1) << MEMORY_CONTEXT_METHODID_BITS) - 1)

Definition at line 146 of file memutils_internal.h.

◆ PallocAlignedExtraBytes

#define PallocAlignedExtraBytes ( alignto ) ((alignto) + (sizeof(MemoryChunk) - MAXIMUM_ALIGNOF))

Definition at line 104 of file memutils_internal.h.

Typedef Documentation

◆ MemoryContextMethodID

typedef enum MemoryContextMethodID MemoryContextMethodID

Enumeration Type Documentation

◆ MemoryContextMethodID

enum MemoryContextMethodID

Enumerator
MCTX_0_RESERVED_UNUSEDMEM_ID
MCTX_1_RESERVED_GLIBC_ID
MCTX_2_RESERVED_GLIBC_ID
MCTX_ASET_ID
MCTX_GENERATION_ID
MCTX_SLAB_ID
MCTX_ALIGNED_REDIRECT_ID
MCTX_BUMP_ID
MCTX_8_UNUSED_ID
MCTX_9_UNUSED_ID
MCTX_10_UNUSED_ID
MCTX_11_UNUSED_ID
MCTX_12_UNUSED_ID
MCTX_13_UNUSED_ID
MCTX_14_UNUSED_ID
MCTX_15_RESERVED_WIPEDMEM_ID

Definition at line 121 of file memutils_internal.h.

 {
     MCTX_0_RESERVED_UNUSEDMEM_ID,   /* 0000 occurs in never-used memory */
     MCTX_1_RESERVED_GLIBC_ID,   /* glibc malloc'd chunks usually match 0001 */
     MCTX_2_RESERVED_GLIBC_ID,   /* glibc malloc'd chunks > 128kB match 0010 */
     MCTX_ASET_ID,
     MCTX_GENERATION_ID,
     MCTX_SLAB_ID,
     MCTX_ALIGNED_REDIRECT_ID,
     MCTX_BUMP_ID,
     MCTX_8_UNUSED_ID,
     MCTX_9_UNUSED_ID,
     MCTX_10_UNUSED_ID,
     MCTX_11_UNUSED_ID,
     MCTX_12_UNUSED_ID,
     MCTX_13_UNUSED_ID,
     MCTX_14_UNUSED_ID,
     MCTX_15_RESERVED_WIPEDMEM_ID    /* 1111 occurs in wipe_mem'd memory */
 } MemoryContextMethodID;

Function Documentation

◆ AlignedAllocFree()

void AlignedAllocFree ( void * pointer )

Definition at line 29 of file alignedalloc.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     void       *unaligned;
  
     VALGRIND_MAKE_MEM_DEFINED(chunk, sizeof(MemoryChunk));
  
     Assert(!MemoryChunkIsExternal(chunk));
  
     /* obtain the original (unaligned) allocated pointer */
     unaligned = MemoryChunkGetBlock(chunk);
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Test for someone scribbling on unused space in chunk */
     if (!sentinel_ok(pointer, chunk->requested_size))
         elog(WARNING, "detected write past chunk end in %s %p",
              GetMemoryChunkContext(unaligned)->name, chunk);
 #endif
  
     pfree(unaligned);
 }

References Assert, chunk, elog, GetMemoryChunkContext(), MemoryChunkGetBlock(), MemoryChunkIsExternal(), name, pfree(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

◆ AlignedAllocGetChunkContext()

MemoryContext AlignedAllocGetChunkContext ( void * pointer )

Definition at line 121 of file alignedalloc.c.

 {
     MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
     MemoryContext cxt;
  
     VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
  
     Assert(!MemoryChunkIsExternal(redirchunk));
  
     cxt = GetMemoryChunkContext(MemoryChunkGetBlock(redirchunk));
  
     VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
  
     return cxt;
 }

References Assert, GetMemoryChunkContext(), MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AlignedAllocGetChunkSpace()

Size AlignedAllocGetChunkSpace ( void * pointer )

Definition at line 143 of file alignedalloc.c.

 {
     MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
     void       *unaligned;
     Size        space;
  
     VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
  
     unaligned = MemoryChunkGetBlock(redirchunk);
     space = GetMemoryChunkSpace(unaligned);
  
     VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
  
     return space;
 }

References GetMemoryChunkSpace(), MemoryChunkGetBlock(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AlignedAllocRealloc()

void* AlignedAllocRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 60 of file alignedalloc.c.

 {
     MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
     Size        alignto;
     void       *unaligned;
     MemoryContext ctx;
     Size        old_size;
     void       *newptr;
  
     VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
  
     alignto = MemoryChunkGetValue(redirchunk);
     unaligned = MemoryChunkGetBlock(redirchunk);
  
     /* sanity check this is a power of 2 value */
     Assert((alignto & (alignto - 1)) == 0);
  
     /*
      * Determine the size of the original allocation.  We can't determine this
      * exactly as GetMemoryChunkSpace() returns the total space used for the
      * allocation, which for contexts like aset includes rounding up to the
      * next power of 2.  However, this value is just used to memcpy() the old
      * data into the new allocation, so we only need to concern ourselves with
      * not reading beyond the end of the original allocation's memory.  The
      * drawback here is that we may copy more bytes than we need to, which
      * only amounts to wasted effort.  We can safely subtract the extra bytes
      * that we requested to allow us to align the pointer.  We must also
      * subtract the space for the unaligned pointer's MemoryChunk since
      * GetMemoryChunkSpace should have included that.  This does assume that
      * all context types use MemoryChunk as a chunk header.
      */
     old_size = GetMemoryChunkSpace(unaligned) -
         PallocAlignedExtraBytes(alignto) - sizeof(MemoryChunk);
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* check that GetMemoryChunkSpace returned something realistic */
     Assert(old_size >= redirchunk->requested_size);
 #endif
  
     ctx = GetMemoryChunkContext(unaligned);
     newptr = MemoryContextAllocAligned(ctx, size, alignto, flags);
  
     /*
      * We may memcpy beyond the end of the original allocation request size,
      * so we must mark the entire allocation as defined.
      */
     if (likely(newptr != NULL))
     {
         VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
         memcpy(newptr, pointer, Min(size, old_size));
     }
     pfree(unaligned);
  
     return newptr;
 }

References Assert, GetMemoryChunkContext(), GetMemoryChunkSpace(), likely, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryContextAllocAligned(), Min, PallocAlignedExtraBytes, pfree(), PointerGetMemoryChunk, size, and VALGRIND_MAKE_MEM_DEFINED.

◆ AllocSetAlloc()

void* AllocSetAlloc	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 967 of file aset.c.

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block;
     MemoryChunk *chunk;
     int         fidx;
     Size        chunk_size;
     Size        availspace;
  
     Assert(AllocSetIsValid(set));
  
     /* due to the keeper block set->blocks should never be NULL */
     Assert(set->blocks != NULL);
  
     /*
      * If requested size exceeds maximum for chunks we hand the request off to
      * AllocSetAllocLarge().
      */
     if (size > set->allocChunkLimit)
         return AllocSetAllocLarge(context, size, flags);
  
     /*
      * Request is small enough to be treated as a chunk.  Look in the
      * corresponding free list to see if there is a free chunk we could reuse.
      * If one is found, remove it from the free list, make it again a member
      * of the alloc set and return its data address.
      *
      * Note that we don't attempt to ensure there's space for the sentinel
      * byte here.  We expect a large proportion of allocations to be for sizes
      * which are already a power of 2.  If we were to always make space for a
      * sentinel byte in MEMORY_CONTEXT_CHECKING builds, then we'd end up
      * doubling the memory requirements for such allocations.
      */
     fidx = AllocSetFreeIndex(size);
     chunk = set->freelist[fidx];
     if (chunk != NULL)
     {
         AllocFreeListLink *link = GetFreeListLink(chunk);
  
         /* Allow access to the chunk header. */
         VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
  
         Assert(fidx == MemoryChunkGetValue(chunk));
  
         /* pop this chunk off the freelist */
         VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
         set->freelist[fidx] = link->next;
         VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
  
 #ifdef MEMORY_CONTEXT_CHECKING
         chunk->requested_size = size;
         /* set mark to catch clobber of "unused" space */
         if (size < GetChunkSizeFromFreeListIdx(fidx))
             set_sentinel(MemoryChunkGetPointer(chunk), size);
 #endif
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* fill the allocated space with junk */
         randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
 #endif
  
         /* Ensure any padding bytes are marked NOACCESS. */
         VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                                    GetChunkSizeFromFreeListIdx(fidx) - size);
  
         /* Disallow access to the chunk header. */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
         return MemoryChunkGetPointer(chunk);
     }
  
     /*
      * Choose the actual chunk size to allocate.
      */
     chunk_size = GetChunkSizeFromFreeListIdx(fidx);
     Assert(chunk_size >= size);
  
     block = set->blocks;
     availspace = block->endptr - block->freeptr;
  
     /*
      * If there is enough room in the active allocation block, we will put the
      * chunk into that block.  Else must start a new one.
      */
     if (unlikely(availspace < (chunk_size + ALLOC_CHUNKHDRSZ)))
         return AllocSetAllocFromNewBlock(context, size, flags, fidx);
  
     /* There's enough space on the current block, so allocate from that */
     return AllocSetAllocChunkFromBlock(context, block, size, chunk_size, fidx);
 }

References ALLOC_CHUNKHDRSZ, AllocSetContext::allocChunkLimit, AllocSetAllocChunkFromBlock(), AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetFreeIndex(), AllocSetIsValid, Assert, AllocSetContext::blocks, chunk, context, AllocBlockData::endptr, AllocSetContext::freelist, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, MemoryChunkGetPointer, MemoryChunkGetValue(), size, unlikely, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by AllocSetRealloc().

◆ AllocSetDelete()

void AllocSetDelete ( MemoryContext context )

Definition at line 607 of file aset.c.

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block = set->blocks;
     Size        keepersize PG_USED_FOR_ASSERTS_ONLY;
  
     Assert(AllocSetIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     AllocSetCheck(context);
 #endif
  
     /* Remember keeper block size for Assert below */
     keepersize = KeeperBlock(set)->endptr - ((char *) set);
  
     /*
      * If the context is a candidate for a freelist, put it into that freelist
      * instead of destroying it.
      */
     if (set->freeListIndex >= 0)
     {
         AllocSetFreeList *freelist = &context_freelists[set->freeListIndex];
  
         /*
          * Reset the context, if it needs it, so that we aren't hanging on to
          * more than the initial malloc chunk.
          */
         if (!context->isReset)
             MemoryContextResetOnly(context);
  
         /*
          * If the freelist is full, just discard what's already in it.  See
          * comments with context_freelists[].
          */
         if (freelist->num_free >= MAX_FREE_CONTEXTS)
         {
             while (freelist->first_free != NULL)
             {
                 AllocSetContext *oldset = freelist->first_free;
  
                 freelist->first_free = (AllocSetContext *) oldset->header.nextchild;
                 freelist->num_free--;
  
                 /* All that remains is to free the header/initial block */
                 free(oldset);
             }
             Assert(freelist->num_free == 0);
         }
  
         /* Now add the just-deleted context to the freelist. */
         set->header.nextchild = (MemoryContext) freelist->first_free;
         freelist->first_free = set;
         freelist->num_free++;
  
         return;
     }
  
     /* Free all blocks, except the keeper which is part of context header */
     while (block != NULL)
     {
         AllocBlock  next = block->next;
  
         if (!IsKeeperBlock(set, block))
             context->mem_allocated -= block->endptr - ((char *) block);
  
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(block, block->freeptr - ((char *) block));
 #endif
  
         if (!IsKeeperBlock(set, block))
             free(block);
  
         block = next;
     }
  
     Assert(context->mem_allocated == keepersize);
  
     /* Finally, free the context header, including the keeper block */
     free(set);
 }

References AllocSetIsValid, Assert, AllocSetContext::blocks, context, context_freelists, AllocBlockData::endptr, AllocSetFreeList::first_free, free, AllocSetContext::freeListIndex, AllocBlockData::freeptr, AllocSetContext::header, IsKeeperBlock, KeeperBlock, MAX_FREE_CONTEXTS, MemoryContextResetOnly(), next, AllocBlockData::next, MemoryContextData::nextchild, AllocSetFreeList::num_free, and PG_USED_FOR_ASSERTS_ONLY.

◆ AllocSetFree()

void AllocSetFree ( void * pointer )

Definition at line 1062 of file aset.c.

 {
     AllocSet    set;
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         /* Release single-chunk block. */
         AllocBlock  block = ExternalChunkGetBlock(chunk);
  
         /*
          * Try to verify that we have a sane block pointer: the block header
          * should reference an aset and the freeptr should match the endptr.
          */
         if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
             elog(ERROR, "could not find block containing chunk %p", chunk);
  
         set = block->aset;
  
 #ifdef MEMORY_CONTEXT_CHECKING
         {
             /* Test for someone scribbling on unused space in chunk */
             Assert(chunk->requested_size < (block->endptr - (char *) pointer));
             if (!sentinel_ok(pointer, chunk->requested_size))
                 elog(WARNING, "detected write past chunk end in %s %p",
                      set->header.name, chunk);
         }
 #endif
  
         /* OK, remove block from aset's list and free it */
         if (block->prev)
             block->prev->next = block->next;
         else
             set->blocks = block->next;
         if (block->next)
             block->next->prev = block->prev;
  
         set->header.mem_allocated -= block->endptr - ((char *) block);
  
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(block, block->freeptr - ((char *) block));
 #endif
         free(block);
     }
     else
     {
         AllocBlock  block = MemoryChunkGetBlock(chunk);
         int         fidx;
         AllocFreeListLink *link;
  
         /*
          * In this path, for speed reasons we just Assert that the referenced
          * block is good.  We can also Assert that the value field is sane.
          * Future field experience may show that these Asserts had better
          * become regular runtime test-and-elog checks.
          */
         Assert(AllocBlockIsValid(block));
         set = block->aset;
  
         fidx = MemoryChunkGetValue(chunk);
         Assert(FreeListIdxIsValid(fidx));
         link = GetFreeListLink(chunk);
  
 #ifdef MEMORY_CONTEXT_CHECKING
         /* Test for someone scribbling on unused space in chunk */
         if (chunk->requested_size < GetChunkSizeFromFreeListIdx(fidx))
             if (!sentinel_ok(pointer, chunk->requested_size))
                 elog(WARNING, "detected write past chunk end in %s %p",
                      set->header.name, chunk);
 #endif
  
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(pointer, GetChunkSizeFromFreeListIdx(fidx));
 #endif
         /* push this chunk onto the top of the free list */
         VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
         link->next = set->freelist[fidx];
         VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
         set->freelist[fidx] = chunk;
  
 #ifdef MEMORY_CONTEXT_CHECKING
  
         /*
          * Reset requested_size to InvalidAllocSize in chunks that are on free
          * list.
          */
         chunk->requested_size = InvalidAllocSize;
 #endif
     }
 }

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocBlockData::aset, Assert, AllocSetContext::blocks, chunk, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, free, AllocSetContext::freelist, FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, AllocSetContext::header, InvalidAllocSize, link(), MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and WARNING.

Referenced by AllocSetRealloc().

◆ AllocSetGetChunkContext()

MemoryContext AllocSetGetChunkContext ( void * pointer )

Definition at line 1433 of file aset.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     AllocBlock  block;
     AllocSet    set;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
         block = ExternalChunkGetBlock(chunk);
     else
         block = (AllocBlock) MemoryChunkGetBlock(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
     Assert(AllocBlockIsValid(block));
     set = block->aset;
  
     return &set->header;
 }

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocBlockData::aset, Assert, chunk, ExternalChunkGetBlock, AllocSetContext::header, MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AllocSetGetChunkSpace()

Size AllocSetGetChunkSpace ( void * pointer )

Definition at line 1462 of file aset.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     int         fidx;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         AllocBlock  block = ExternalChunkGetBlock(chunk);
  
         /* Disallow access to the chunk header. */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
         Assert(AllocBlockIsValid(block));
  
         return block->endptr - (char *) chunk;
     }
  
     fidx = MemoryChunkGetValue(chunk);
     Assert(FreeListIdxIsValid(fidx));
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
     return GetChunkSizeFromFreeListIdx(fidx) + ALLOC_CHUNKHDRSZ;
 }

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, Assert, chunk, AllocBlockData::endptr, ExternalChunkGetBlock, FreeListIdxIsValid, GetChunkSizeFromFreeListIdx, MemoryChunkGetValue(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AllocSetIsEmpty()

bool AllocSetIsEmpty ( MemoryContext context )

Definition at line 1496 of file aset.c.

 {
     Assert(AllocSetIsValid(context));
  
     /*
      * For now, we say "empty" only if the context is new or just reset. We
      * could examine the freelists to determine if all space has been freed,
      * but it's not really worth the trouble for present uses of this
      * functionality.
      */
     if (context->isReset)
         return true;
     return false;
 }

References AllocSetIsValid, Assert, and context.

◆ AllocSetRealloc()

void* AllocSetRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 1169 of file aset.c.

 {
     AllocBlock  block;
     AllocSet    set;
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     Size        oldchksize;
     int         fidx;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         /*
          * The chunk must have been allocated as a single-chunk block.  Use
          * realloc() to make the containing block bigger, or smaller, with
          * minimum space wastage.
          */
         Size        chksize;
         Size        blksize;
         Size        oldblksize;
  
         block = ExternalChunkGetBlock(chunk);
  
         /*
          * Try to verify that we have a sane block pointer: the block header
          * should reference an aset and the freeptr should match the endptr.
          */
         if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
             elog(ERROR, "could not find block containing chunk %p", chunk);
  
         set = block->aset;
  
         /* only check size in paths where the limits could be hit */
         MemoryContextCheckSize((MemoryContext) set, size, flags);
  
         oldchksize = block->endptr - (char *) pointer;
  
 #ifdef MEMORY_CONTEXT_CHECKING
         /* Test for someone scribbling on unused space in chunk */
         Assert(chunk->requested_size < oldchksize);
         if (!sentinel_ok(pointer, chunk->requested_size))
             elog(WARNING, "detected write past chunk end in %s %p",
                  set->header.name, chunk);
 #endif
  
 #ifdef MEMORY_CONTEXT_CHECKING
         /* ensure there's always space for the sentinel byte */
         chksize = MAXALIGN(size + 1);
 #else
         chksize = MAXALIGN(size);
 #endif
  
         /* Do the realloc */
         blksize = chksize + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
         oldblksize = block->endptr - ((char *) block);
  
         block = (AllocBlock) realloc(block, blksize);
         if (block == NULL)
         {
             /* Disallow access to the chunk header. */
             VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
             return MemoryContextAllocationFailure(&set->header, size, flags);
         }
  
         /* updated separately, not to underflow when (oldblksize > blksize) */
         set->header.mem_allocated -= oldblksize;
         set->header.mem_allocated += blksize;
  
         block->freeptr = block->endptr = ((char *) block) + blksize;
  
         /* Update pointers since block has likely been moved */
         chunk = (MemoryChunk *) (((char *) block) + ALLOC_BLOCKHDRSZ);
         pointer = MemoryChunkGetPointer(chunk);
         if (block->prev)
             block->prev->next = block;
         else
             set->blocks = block;
         if (block->next)
             block->next->prev = block;
  
 #ifdef MEMORY_CONTEXT_CHECKING
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
  
         /*
          * We can only randomize the extra space if we know the prior request.
          * When using Valgrind, randomize_mem() also marks memory UNDEFINED.
          */
         if (size > chunk->requested_size)
             randomize_mem((char *) pointer + chunk->requested_size,
                           size - chunk->requested_size);
 #else
  
         /*
          * If this is an increase, realloc() will have marked any
          * newly-allocated part (from oldchksize to chksize) UNDEFINED, but we
          * also need to adjust trailing bytes from the old allocation (from
          * chunk->requested_size to oldchksize) as they are marked NOACCESS.
          * Make sure not to mark too many bytes in case chunk->requested_size
          * < size < oldchksize.
          */
 #ifdef USE_VALGRIND
         if (Min(size, oldchksize) > chunk->requested_size)
             VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + chunk->requested_size,
                                         Min(size, oldchksize) - chunk->requested_size);
 #endif
 #endif
  
         chunk->requested_size = size;
         /* set mark to catch clobber of "unused" space */
         Assert(size < chksize);
         set_sentinel(pointer, size);
 #else                           /* !MEMORY_CONTEXT_CHECKING */
  
         /*
          * We may need to adjust marking of bytes from the old allocation as
          * some of them may be marked NOACCESS.  We don't know how much of the
          * old chunk size was the requested size; it could have been as small
          * as one byte.  We have to be conservative and just mark the entire
          * old portion DEFINED.  Make sure not to mark memory beyond the new
          * allocation in case it's smaller than the old one.
          */
         VALGRIND_MAKE_MEM_DEFINED(pointer, Min(size, oldchksize));
 #endif
  
         /* Ensure any padding bytes are marked NOACCESS. */
         VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size, chksize - size);
  
         /* Disallow access to the chunk header . */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
         return pointer;
     }
  
     block = MemoryChunkGetBlock(chunk);
  
     /*
      * In this path, for speed reasons we just Assert that the referenced
      * block is good. We can also Assert that the value field is sane. Future
      * field experience may show that these Asserts had better become regular
      * runtime test-and-elog checks.
      */
     Assert(AllocBlockIsValid(block));
     set = block->aset;
  
     fidx = MemoryChunkGetValue(chunk);
     Assert(FreeListIdxIsValid(fidx));
     oldchksize = GetChunkSizeFromFreeListIdx(fidx);
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Test for someone scribbling on unused space in chunk */
     if (chunk->requested_size < oldchksize)
         if (!sentinel_ok(pointer, chunk->requested_size))
             elog(WARNING, "detected write past chunk end in %s %p",
                  set->header.name, chunk);
 #endif
  
     /*
      * Chunk sizes are aligned to power of 2 in AllocSetAlloc().  Maybe the
      * allocated area already is >= the new size.  (In particular, we will
      * fall out here if the requested size is a decrease.)
      */
     if (oldchksize >= size)
     {
 #ifdef MEMORY_CONTEXT_CHECKING
         Size        oldrequest = chunk->requested_size;
  
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* We can only fill the extra space if we know the prior request */
         if (size > oldrequest)
             randomize_mem((char *) pointer + oldrequest,
                           size - oldrequest);
 #endif
  
         chunk->requested_size = size;
  
         /*
          * If this is an increase, mark any newly-available part UNDEFINED.
          * Otherwise, mark the obsolete part NOACCESS.
          */
         if (size > oldrequest)
             VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + oldrequest,
                                         size - oldrequest);
         else
             VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size,
                                        oldchksize - size);
  
         /* set mark to catch clobber of "unused" space */
         if (size < oldchksize)
             set_sentinel(pointer, size);
 #else                           /* !MEMORY_CONTEXT_CHECKING */
  
         /*
          * We don't have the information to determine whether we're growing
          * the old request or shrinking it, so we conservatively mark the
          * entire new allocation DEFINED.
          */
         VALGRIND_MAKE_MEM_NOACCESS(pointer, oldchksize);
         VALGRIND_MAKE_MEM_DEFINED(pointer, size);
 #endif
  
         /* Disallow access to the chunk header. */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
         return pointer;
     }
     else
     {
         /*
          * Enlarge-a-small-chunk case.  We just do this by brute force, ie,
          * allocate a new chunk and copy the data.  Since we know the existing
          * data isn't huge, this won't involve any great memcpy expense, so
          * it's not worth being smarter.  (At one time we tried to avoid
          * memcpy when it was possible to enlarge the chunk in-place, but that
          * turns out to misbehave unpleasantly for repeated cycles of
          * palloc/repalloc/pfree: the eventually freed chunks go into the
          * wrong freelist for the next initial palloc request, and so we leak
          * memory indefinitely.  See pgsql-hackers archives for 2007-08-11.)
          */
         AllocPointer newPointer;
         Size        oldsize;
  
         /* allocate new chunk (this also checks size is valid) */
         newPointer = AllocSetAlloc((MemoryContext) set, size, flags);
  
         /* leave immediately if request was not completed */
         if (newPointer == NULL)
         {
             /* Disallow access to the chunk header. */
             VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
             return MemoryContextAllocationFailure((MemoryContext) set, size, flags);
         }
  
         /*
          * AllocSetAlloc() may have returned a region that is still NOACCESS.
          * Change it to UNDEFINED for the moment; memcpy() will then transfer
          * definedness from the old allocation to the new.  If we know the old
          * allocation, copy just that much.  Otherwise, make the entire old
          * chunk defined to avoid errors as we copy the currently-NOACCESS
          * trailing bytes.
          */
         VALGRIND_MAKE_MEM_UNDEFINED(newPointer, size);
 #ifdef MEMORY_CONTEXT_CHECKING
         oldsize = chunk->requested_size;
 #else
         oldsize = oldchksize;
         VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
 #endif
  
         /* transfer existing data (certain to fit) */
         memcpy(newPointer, pointer, oldsize);
  
         /* free old chunk */
         AllocSetFree(pointer);
  
         return newPointer;
     }
 }

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocSetAlloc(), AllocSetFree(), AllocBlockData::aset, Assert, chunk, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, AllocSetContext::header, MAXALIGN, MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryChunkGetPointer, MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextAllocationFailure(), MemoryContextCheckSize(), Min, MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, realloc, size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

◆ AllocSetReset()

void AllocSetReset ( MemoryContext context )

Definition at line 537 of file aset.c.

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block;
     Size        keepersize PG_USED_FOR_ASSERTS_ONLY;
  
     Assert(AllocSetIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     AllocSetCheck(context);
 #endif
  
     /* Remember keeper block size for Assert below */
     keepersize = KeeperBlock(set)->endptr - ((char *) set);
  
     /* Clear chunk freelists */
     MemSetAligned(set->freelist, 0, sizeof(set->freelist));
  
     block = set->blocks;
  
     /* New blocks list will be just the keeper block */
     set->blocks = KeeperBlock(set);
  
     while (block != NULL)
     {
         AllocBlock  next = block->next;
  
         if (IsKeeperBlock(set, block))
         {
             /* Reset the block, but don't return it to malloc */
             char       *datastart = ((char *) block) + ALLOC_BLOCKHDRSZ;
  
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(datastart, block->freeptr - datastart);
 #else
             /* wipe_mem() would have done this */
             VALGRIND_MAKE_MEM_NOACCESS(datastart, block->freeptr - datastart);
 #endif
             block->freeptr = datastart;
             block->prev = NULL;
             block->next = NULL;
         }
         else
         {
             /* Normal case, release the block */
             context->mem_allocated -= block->endptr - ((char *) block);
  
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(block, block->freeptr - ((char *) block));
 #endif
             free(block);
         }
         block = next;
     }
  
     Assert(context->mem_allocated == keepersize);
  
     /* Reset block size allocation sequence, too */
     set->nextBlockSize = set->initBlockSize;
 }

References ALLOC_BLOCKHDRSZ, AllocSetIsValid, Assert, AllocSetContext::blocks, context, AllocBlockData::endptr, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::initBlockSize, IsKeeperBlock, KeeperBlock, MemSetAligned, next, AllocBlockData::next, AllocSetContext::nextBlockSize, PG_USED_FOR_ASSERTS_ONLY, AllocBlockData::prev, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AllocSetStats()

void AllocSetStats	(	MemoryContext	context,
		MemoryStatsPrintFunc	printfunc,
		void *	passthru,
		MemoryContextCounters *	totals,
		bool	print_to_stderr
	)

Definition at line 1521 of file aset.c.

 {
     AllocSet    set = (AllocSet) context;
     Size        nblocks = 0;
     Size        freechunks = 0;
     Size        totalspace;
     Size        freespace = 0;
     AllocBlock  block;
     int         fidx;
  
     Assert(AllocSetIsValid(set));
  
     /* Include context header in totalspace */
     totalspace = MAXALIGN(sizeof(AllocSetContext));
  
     for (block = set->blocks; block != NULL; block = block->next)
     {
         nblocks++;
         totalspace += block->endptr - ((char *) block);
         freespace += block->endptr - block->freeptr;
     }
     for (fidx = 0; fidx < ALLOCSET_NUM_FREELISTS; fidx++)
     {
         Size        chksz = GetChunkSizeFromFreeListIdx(fidx);
         MemoryChunk *chunk = set->freelist[fidx];
  
         while (chunk != NULL)
         {
             AllocFreeListLink *link = GetFreeListLink(chunk);
  
             /* Allow access to the chunk header. */
             VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
             Assert(MemoryChunkGetValue(chunk) == fidx);
             VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
  
             freechunks++;
             freespace += chksz + ALLOC_CHUNKHDRSZ;
  
             VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
             chunk = link->next;
             VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
         }
     }
  
     if (printfunc)
     {
         char        stats_string[200];
  
         snprintf(stats_string, sizeof(stats_string),
                  "%zu total in %zu blocks; %zu free (%zu chunks); %zu used",
                  totalspace, nblocks, freespace, freechunks,
                  totalspace - freespace);
         printfunc(context, passthru, stats_string, print_to_stderr);
     }
  
     if (totals)
     {
         totals->nblocks += nblocks;
         totals->freechunks += freechunks;
         totals->totalspace += totalspace;
         totals->freespace += freespace;
     }
 }

References ALLOC_CHUNKHDRSZ, ALLOCSET_NUM_FREELISTS, AllocSetIsValid, Assert, AllocSetContext::blocks, chunk, context, AllocBlockData::endptr, MemoryContextCounters::freechunks, AllocSetContext::freelist, AllocBlockData::freeptr, MemoryContextCounters::freespace, GetChunkSizeFromFreeListIdx, GetFreeListLink, MAXALIGN, MemoryChunkGetValue(), MemoryContextCounters::nblocks, AllocBlockData::next, snprintf, MemoryContextCounters::totalspace, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ BumpAlloc()

void* BumpAlloc	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 491 of file bump.c.

 {
     BumpContext *set = (BumpContext *) context;
     BumpBlock  *block;
     Size        chunk_size;
     Size        required_size;
  
     Assert(BumpIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* ensure there's always space for the sentinel byte */
     chunk_size = MAXALIGN(size + 1);
 #else
     chunk_size = MAXALIGN(size);
 #endif
  
     /*
      * If requested size exceeds maximum for chunks we hand the request off to
      * BumpAllocLarge().
      */
     if (chunk_size > set->allocChunkLimit)
         return BumpAllocLarge(context, size, flags);
  
     required_size = chunk_size + Bump_CHUNKHDRSZ;
  
     /*
      * Not an oversized chunk.  We try to first make use of the latest block,
      * but if there's not enough space in it we must allocate a new block.
      */
     block = dlist_container(BumpBlock, node, dlist_head_node(&set->blocks));
  
     if (BumpBlockFreeBytes(block) < required_size)
         return BumpAllocFromNewBlock(context, size, flags, chunk_size);
  
     /* The current block has space, so just allocate chunk there. */
     return BumpAllocChunkFromBlock(context, block, size, chunk_size);
 }

References BumpContext::allocChunkLimit, Assert, BumpContext::blocks, Bump_CHUNKHDRSZ, BumpAllocChunkFromBlock(), BumpAllocFromNewBlock(), BumpAllocLarge(), BumpBlockFreeBytes(), BumpIsValid, context, dlist_container, dlist_head_node(), MAXALIGN, and size.

◆ BumpDelete()

void BumpDelete ( MemoryContext context )

Definition at line 278 of file bump.c.

 {
     /* Reset to release all releasable BumpBlocks */
     BumpReset(context);
     /* And free the context header and keeper block */
     free(context);
 }

References BumpReset(), context, and free.

◆ BumpFree()

void BumpFree ( void * pointer )

Definition at line 617 of file bump.c.

 {
     elog(ERROR, "%s is not supported by the bump memory allocator", "pfree");
 }

References elog, and ERROR.

◆ BumpGetChunkContext()

MemoryContext BumpGetChunkContext ( void * pointer )

Definition at line 638 of file bump.c.

 {
     elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkContext");
     return NULL;                /* keep compiler quiet */
 }

References elog, and ERROR.

◆ BumpGetChunkSpace()

Size BumpGetChunkSpace ( void * pointer )

Definition at line 649 of file bump.c.

 {
     elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkSpace");
     return 0;                   /* keep compiler quiet */
 }

References elog, and ERROR.

◆ BumpIsEmpty()

bool BumpIsEmpty ( MemoryContext context )

Definition at line 660 of file bump.c.

 {
     BumpContext *set = (BumpContext *) context;
     dlist_iter  iter;
  
     Assert(BumpIsValid(set));
  
     dlist_foreach(iter, &set->blocks)
     {
         BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
  
         if (!BumpBlockIsEmpty(block))
             return false;
     }
  
     return true;
 }

References Assert, BumpContext::blocks, BumpBlockIsEmpty(), BumpIsValid, context, dlist_iter::cur, dlist_container, and dlist_foreach.

◆ BumpRealloc()

void* BumpRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 627 of file bump.c.

 {
     elog(ERROR, "%s is not supported by the bump memory allocator", "realloc");
     return NULL;                /* keep compiler quiet */
 }

References elog, and ERROR.

◆ BumpReset()

void BumpReset ( MemoryContext context )

Definition at line 243 of file bump.c.

 {
     BumpContext *set = (BumpContext *) context;
     dlist_mutable_iter miter;
  
     Assert(BumpIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     BumpCheck(context);
 #endif
  
     dlist_foreach_modify(miter, &set->blocks)
     {
         BumpBlock  *block = dlist_container(BumpBlock, node, miter.cur);
  
         if (IsKeeperBlock(set, block))
             BumpBlockMarkEmpty(block);
         else
             BumpBlockFree(set, block);
     }
  
     /* Reset block size allocation sequence, too */
     set->nextBlockSize = set->initBlockSize;
  
     /* Ensure there is only 1 item in the dlist */
     Assert(!dlist_is_empty(&set->blocks));
     Assert(!dlist_has_next(&set->blocks, dlist_head_node(&set->blocks)));
 }

References Assert, BumpContext::blocks, BumpBlockFree(), BumpBlockMarkEmpty(), BumpIsValid, context, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, dlist_has_next(), dlist_head_node(), dlist_is_empty(), BumpContext::initBlockSize, IsKeeperBlock, and BumpContext::nextBlockSize.

Referenced by BumpDelete().

◆ BumpStats()

void BumpStats	(	MemoryContext	context,
		MemoryStatsPrintFunc	printfunc,
		void *	passthru,
		MemoryContextCounters *	totals,
		bool	print_to_stderr
	)

Definition at line 688 of file bump.c.

 {
     BumpContext *set = (BumpContext *) context;
     Size        nblocks = 0;
     Size        totalspace = 0;
     Size        freespace = 0;
     dlist_iter  iter;
  
     Assert(BumpIsValid(set));
  
     dlist_foreach(iter, &set->blocks)
     {
         BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
  
         nblocks++;
         totalspace += (block->endptr - (char *) block);
         freespace += (block->endptr - block->freeptr);
     }
  
     if (printfunc)
     {
         char        stats_string[200];
  
         snprintf(stats_string, sizeof(stats_string),
                  "%zu total in %zu blocks; %zu free; %zu used",
                  totalspace, nblocks, freespace, totalspace - freespace);
         printfunc(context, passthru, stats_string, print_to_stderr);
     }
  
     if (totals)
     {
         totals->nblocks += nblocks;
         totals->totalspace += totalspace;
         totals->freespace += freespace;
     }
 }

References Assert, BumpContext::blocks, BumpIsValid, context, dlist_iter::cur, dlist_container, dlist_foreach, BumpBlock::endptr, BumpBlock::freeptr, MemoryContextCounters::freespace, MemoryContextCounters::nblocks, snprintf, and MemoryContextCounters::totalspace.

◆ GenerationAlloc()

void* GenerationAlloc	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 527 of file generation.c.

 {
     GenerationContext *set = (GenerationContext *) context;
     GenerationBlock *block;
     Size        chunk_size;
     Size        required_size;
  
     Assert(GenerationIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* ensure there's always space for the sentinel byte */
     chunk_size = MAXALIGN(size + 1);
 #else
     chunk_size = MAXALIGN(size);
 #endif
  
     /*
      * If requested size exceeds maximum for chunks we hand the request off to
      * GenerationAllocLarge().
      */
     if (chunk_size > set->allocChunkLimit)
         return GenerationAllocLarge(context, size, flags);
  
     required_size = chunk_size + Generation_CHUNKHDRSZ;
  
     /*
      * Not an oversized chunk.  We try to first make use of the current block,
      * but if there's not enough space in it, instead of allocating a new
      * block, we look to see if the empty freeblock has enough space.  We
      * don't try reusing the keeper block.  If it's become empty we'll reuse
      * that again only if the context is reset.
      *
      * We only try reusing the freeblock if we've no space for this allocation
      * on the current block.  When a freeblock exists, we'll switch to it once
      * the first time we can't fit an allocation in the current block.  We
      * avoid ping-ponging between the two as we need to be careful not to
      * fragment differently sized consecutive allocations between several
      * blocks.  Going between the two could cause fragmentation for FIFO
      * workloads, which generation is meant to be good at.
      */
     block = set->block;
  
     if (unlikely(GenerationBlockFreeBytes(block) < required_size))
     {
         GenerationBlock *freeblock = set->freeblock;
  
         /* freeblock, if set, must be empty */
         Assert(freeblock == NULL || GenerationBlockIsEmpty(freeblock));
  
         /* check if we have a freeblock and if it's big enough */
         if (freeblock != NULL &&
             GenerationBlockFreeBytes(freeblock) >= required_size)
         {
             /* make the freeblock the current block */
             set->freeblock = NULL;
             set->block = freeblock;
  
             return GenerationAllocChunkFromBlock(context,
                                                  freeblock,
                                                  size,
                                                  chunk_size);
         }
         else
         {
             /*
              * No freeblock, or it's not big enough for this allocation.  Make
              * a new block.
              */
             return GenerationAllocFromNewBlock(context, size, flags, chunk_size);
         }
     }
  
     /* The current block has space, so just allocate chunk there. */
     return GenerationAllocChunkFromBlock(context, block, size, chunk_size);
 }

References GenerationContext::allocChunkLimit, Assert, GenerationContext::block, context, GenerationContext::freeblock, Generation_CHUNKHDRSZ, GenerationAllocChunkFromBlock(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationBlockFreeBytes(), GenerationBlockIsEmpty, GenerationIsValid, MAXALIGN, size, and unlikely.

Referenced by GenerationRealloc().

◆ GenerationDelete()

void GenerationDelete ( MemoryContext context )

Definition at line 328 of file generation.c.

 {
     /* Reset to release all releasable GenerationBlocks */
     GenerationReset(context);
     /* And free the context header and keeper block */
     free(context);
 }

References context, free, and GenerationReset().

◆ GenerationFree()

void GenerationFree ( void * pointer )

Definition at line 689 of file generation.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     GenerationBlock *block;
     GenerationContext *set;
 #if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
     || defined(CLOBBER_FREED_MEMORY)
     Size        chunksize;
 #endif
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         block = ExternalChunkGetBlock(chunk);
  
         /*
          * Try to verify that we have a sane block pointer: the block header
          * should reference a generation context.
          */
         if (!GenerationBlockIsValid(block))
             elog(ERROR, "could not find block containing chunk %p", chunk);
  
 #if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
     || defined(CLOBBER_FREED_MEMORY)
         chunksize = block->endptr - (char *) pointer;
 #endif
     }
     else
     {
         block = MemoryChunkGetBlock(chunk);
  
         /*
          * In this path, for speed reasons we just Assert that the referenced
          * block is good.  Future field experience may show that this Assert
          * had better become a regular runtime test-and-elog check.
          */
         Assert(GenerationBlockIsValid(block));
  
 #if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
     || defined(CLOBBER_FREED_MEMORY)
         chunksize = MemoryChunkGetValue(chunk);
 #endif
     }
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Test for someone scribbling on unused space in chunk */
     Assert(chunk->requested_size < chunksize);
     if (!sentinel_ok(pointer, chunk->requested_size))
         elog(WARNING, "detected write past chunk end in %s %p",
              ((MemoryContext) block->context)->name, chunk);
 #endif
  
 #ifdef CLOBBER_FREED_MEMORY
     wipe_mem(pointer, chunksize);
 #endif
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Reset requested_size to InvalidAllocSize in freed chunks */
     chunk->requested_size = InvalidAllocSize;
 #endif
  
     block->nfree += 1;
  
     Assert(block->nchunks > 0);
     Assert(block->nfree <= block->nchunks);
     Assert(block != block->context->freeblock);
  
     /* If there are still allocated chunks in the block, we're done. */
     if (likely(block->nfree < block->nchunks))
         return;
  
     set = block->context;
  
     /*-----------------------
      * The block this allocation was on has now become completely empty of
      * chunks.  In the general case, we can now return the memory for this
      * block back to malloc.  However, there are cases where we don't want to
      * do that:
      *
      * 1)   If it's the keeper block.  This block was malloc'd in the same
      *      allocation as the context itself and can't be free'd without
      *      freeing the context.
      * 2)   If it's the current block.  We could free this, but doing so would
      *      leave us nothing to set the current block to, so we just mark the
      *      block as empty so new allocations can reuse it again.
      * 3)   If we have no "freeblock" set, then we save a single block for
      *      future allocations to avoid having to malloc a new block again.
      *      This is useful for FIFO workloads as it avoids continual
      *      free/malloc cycles.
      */
     if (IsKeeperBlock(set, block) || set->block == block)
         GenerationBlockMarkEmpty(block);    /* case 1 and 2 */
     else if (set->freeblock == NULL)
     {
         /* case 3 */
         GenerationBlockMarkEmpty(block);
         set->freeblock = block;
     }
     else
         GenerationBlockFree(set, block);    /* Otherwise, free it */
 }

References Assert, GenerationContext::block, chunk, GenerationBlock::context, elog, GenerationBlock::endptr, ERROR, ExternalChunkGetBlock, GenerationContext::freeblock, Generation_CHUNKHDRSZ, GenerationBlockFree(), GenerationBlockIsValid, GenerationBlockMarkEmpty(), InvalidAllocSize, IsKeeperBlock, likely, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), GenerationBlock::nchunks, GenerationBlock::nfree, PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

Referenced by GenerationRealloc().

◆ GenerationGetChunkContext()

MemoryContext GenerationGetChunkContext ( void * pointer )

Definition at line 947 of file generation.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     GenerationBlock *block;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
         block = ExternalChunkGetBlock(chunk);
     else
         block = (GenerationBlock *) MemoryChunkGetBlock(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
  
     Assert(GenerationBlockIsValid(block));
     return &block->context->header;
 }

References Assert, chunk, GenerationBlock::context, ExternalChunkGetBlock, Generation_CHUNKHDRSZ, GenerationBlockIsValid, GenerationContext::header, MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ GenerationGetChunkSpace()

Size GenerationGetChunkSpace ( void * pointer )

Definition at line 973 of file generation.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     Size        chunksize;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         GenerationBlock *block = ExternalChunkGetBlock(chunk);
  
         Assert(GenerationBlockIsValid(block));
         chunksize = block->endptr - (char *) pointer;
     }
     else
         chunksize = MemoryChunkGetValue(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
  
     return Generation_CHUNKHDRSZ + chunksize;
 }

References Assert, chunk, GenerationBlock::endptr, ExternalChunkGetBlock, Generation_CHUNKHDRSZ, GenerationBlockIsValid, MemoryChunkGetValue(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ GenerationIsEmpty()

bool GenerationIsEmpty ( MemoryContext context )

Definition at line 1002 of file generation.c.

 {
     GenerationContext *set = (GenerationContext *) context;
     dlist_iter  iter;
  
     Assert(GenerationIsValid(set));
  
     dlist_foreach(iter, &set->blocks)
     {
         GenerationBlock *block = dlist_container(GenerationBlock, node, iter.cur);
  
         if (block->nchunks > 0)
             return false;
     }
  
     return true;
 }

References Assert, GenerationContext::blocks, context, dlist_iter::cur, dlist_container, dlist_foreach, GenerationIsValid, and GenerationBlock::nchunks.

◆ GenerationRealloc()

void* GenerationRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 800 of file generation.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     GenerationContext *set;
     GenerationBlock *block;
     GenerationPointer newPointer;
     Size        oldsize;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
  
     if (MemoryChunkIsExternal(chunk))
     {
         block = ExternalChunkGetBlock(chunk);
  
         /*
          * Try to verify that we have a sane block pointer: the block header
          * should reference a generation context.
          */
         if (!GenerationBlockIsValid(block))
             elog(ERROR, "could not find block containing chunk %p", chunk);
  
         oldsize = block->endptr - (char *) pointer;
     }
     else
     {
         block = MemoryChunkGetBlock(chunk);
  
         /*
          * In this path, for speed reasons we just Assert that the referenced
          * block is good.  Future field experience may show that this Assert
          * had better become a regular runtime test-and-elog check.
          */
         Assert(GenerationBlockIsValid(block));
  
         oldsize = MemoryChunkGetValue(chunk);
     }
  
     set = block->context;
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Test for someone scribbling on unused space in chunk */
     Assert(chunk->requested_size < oldsize);
     if (!sentinel_ok(pointer, chunk->requested_size))
         elog(WARNING, "detected write past chunk end in %s %p",
              ((MemoryContext) set)->name, chunk);
 #endif
  
     /*
      * Maybe the allocated area already big enough.  (In particular, we always
      * fall out here if the requested size is a decrease.)
      *
      * This memory context does not use power-of-2 chunk sizing and instead
      * carves the chunks to be as small as possible, so most repalloc() calls
      * will end up in the palloc/memcpy/pfree branch.
      *
      * XXX Perhaps we should annotate this condition with unlikely()?
      */
 #ifdef MEMORY_CONTEXT_CHECKING
     /* With MEMORY_CONTEXT_CHECKING, we need an extra byte for the sentinel */
     if (oldsize > size)
 #else
     if (oldsize >= size)
 #endif
     {
 #ifdef MEMORY_CONTEXT_CHECKING
         Size        oldrequest = chunk->requested_size;
  
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* We can only fill the extra space if we know the prior request */
         if (size > oldrequest)
             randomize_mem((char *) pointer + oldrequest,
                           size - oldrequest);
 #endif
  
         chunk->requested_size = size;
  
         /*
          * If this is an increase, mark any newly-available part UNDEFINED.
          * Otherwise, mark the obsolete part NOACCESS.
          */
         if (size > oldrequest)
             VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + oldrequest,
                                         size - oldrequest);
         else
             VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size,
                                        oldsize - size);
  
         /* set mark to catch clobber of "unused" space */
         set_sentinel(pointer, size);
 #else                           /* !MEMORY_CONTEXT_CHECKING */
  
         /*
          * We don't have the information to determine whether we're growing
          * the old request or shrinking it, so we conservatively mark the
          * entire new allocation DEFINED.
          */
         VALGRIND_MAKE_MEM_NOACCESS(pointer, oldsize);
         VALGRIND_MAKE_MEM_DEFINED(pointer, size);
 #endif
  
         /* Disallow access to the chunk header. */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
  
         return pointer;
     }
  
     /* allocate new chunk (this also checks size is valid) */
     newPointer = GenerationAlloc((MemoryContext) set, size, flags);
  
     /* leave immediately if request was not completed */
     if (newPointer == NULL)
     {
         /* Disallow access to the chunk header. */
         VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
         return MemoryContextAllocationFailure((MemoryContext) set, size, flags);
     }
  
     /*
      * GenerationAlloc() may have returned a region that is still NOACCESS.
      * Change it to UNDEFINED for the moment; memcpy() will then transfer
      * definedness from the old allocation to the new.  If we know the old
      * allocation, copy just that much.  Otherwise, make the entire old chunk
      * defined to avoid errors as we copy the currently-NOACCESS trailing
      * bytes.
      */
     VALGRIND_MAKE_MEM_UNDEFINED(newPointer, size);
 #ifdef MEMORY_CONTEXT_CHECKING
     oldsize = chunk->requested_size;
 #else
     VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
 #endif
  
     /* transfer existing data (certain to fit) */
     memcpy(newPointer, pointer, oldsize);
  
     /* free old chunk */
     GenerationFree(pointer);
  
     return newPointer;
 }

References Assert, chunk, GenerationBlock::context, elog, GenerationBlock::endptr, ERROR, ExternalChunkGetBlock, Generation_CHUNKHDRSZ, GenerationAlloc(), GenerationBlockIsValid, GenerationFree(), MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextAllocationFailure(), name, PointerGetMemoryChunk, size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

◆ GenerationReset()

void GenerationReset ( MemoryContext context )

Definition at line 283 of file generation.c.

 {
     GenerationContext *set = (GenerationContext *) context;
     dlist_mutable_iter miter;
  
     Assert(GenerationIsValid(set));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     GenerationCheck(context);
 #endif
  
     /*
      * NULLify the free block pointer.  We must do this before calling
      * GenerationBlockFree as that function never expects to free the
      * freeblock.
      */
     set->freeblock = NULL;
  
     dlist_foreach_modify(miter, &set->blocks)
     {
         GenerationBlock *block = dlist_container(GenerationBlock, node, miter.cur);
  
         if (IsKeeperBlock(set, block))
             GenerationBlockMarkEmpty(block);
         else
             GenerationBlockFree(set, block);
     }
  
     /* set it so new allocations to make use of the keeper block */
     set->block = KeeperBlock(set);
  
     /* Reset block size allocation sequence, too */
     set->nextBlockSize = set->initBlockSize;
  
     /* Ensure there is only 1 item in the dlist */
     Assert(!dlist_is_empty(&set->blocks));
     Assert(!dlist_has_next(&set->blocks, dlist_head_node(&set->blocks)));
 }

References Assert, GenerationContext::block, GenerationContext::blocks, context, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, dlist_has_next(), dlist_head_node(), dlist_is_empty(), GenerationContext::freeblock, GenerationBlockFree(), GenerationBlockMarkEmpty(), GenerationIsValid, GenerationContext::initBlockSize, IsKeeperBlock, KeeperBlock, and GenerationContext::nextBlockSize.

Referenced by GenerationDelete().

◆ GenerationStats()

void GenerationStats	(	MemoryContext	context,
		MemoryStatsPrintFunc	printfunc,
		void *	passthru,
		MemoryContextCounters *	totals,
		bool	print_to_stderr
	)

Definition at line 1033 of file generation.c.

 {
     GenerationContext *set = (GenerationContext *) context;
     Size        nblocks = 0;
     Size        nchunks = 0;
     Size        nfreechunks = 0;
     Size        totalspace;
     Size        freespace = 0;
     dlist_iter  iter;
  
     Assert(GenerationIsValid(set));
  
     /* Include context header in totalspace */
     totalspace = MAXALIGN(sizeof(GenerationContext));
  
     dlist_foreach(iter, &set->blocks)
     {
         GenerationBlock *block = dlist_container(GenerationBlock, node, iter.cur);
  
         nblocks++;
         nchunks += block->nchunks;
         nfreechunks += block->nfree;
         totalspace += block->blksize;
         freespace += (block->endptr - block->freeptr);
     }
  
     if (printfunc)
     {
         char        stats_string[200];
  
         snprintf(stats_string, sizeof(stats_string),
                  "%zu total in %zu blocks (%zu chunks); %zu free (%zu chunks); %zu used",
                  totalspace, nblocks, nchunks, freespace,
                  nfreechunks, totalspace - freespace);
         printfunc(context, passthru, stats_string, print_to_stderr);
     }
  
     if (totals)
     {
         totals->nblocks += nblocks;
         totals->freechunks += nfreechunks;
         totals->totalspace += totalspace;
         totals->freespace += freespace;
     }
 }

References Assert, GenerationBlock::blksize, GenerationContext::blocks, context, dlist_iter::cur, dlist_container, dlist_foreach, GenerationBlock::endptr, MemoryContextCounters::freechunks, GenerationBlock::freeptr, MemoryContextCounters::freespace, GenerationIsValid, MAXALIGN, MemoryContextCounters::nblocks, GenerationBlock::nchunks, GenerationBlock::nfree, snprintf, and MemoryContextCounters::totalspace.

◆ MemoryContextAllocationFailure()

void* MemoryContextAllocationFailure	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 1147 of file mcxt.c.

 {
     if ((flags & MCXT_ALLOC_NO_OOM) == 0)
     {
         if (TopMemoryContext)
             MemoryContextStats(TopMemoryContext);
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed on request of size %zu in memory context \"%s\".",
                            size, context->name)));
     }
     return NULL;
 }

References context, ereport, errcode(), errdetail(), errmsg(), ERROR, MCXT_ALLOC_NO_OOM, MemoryContextStats(), size, and TopMemoryContext.

Referenced by AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetRealloc(), BumpAllocFromNewBlock(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationRealloc(), and SlabAllocFromNewBlock().

◆ MemoryContextCheckSize()

static void MemoryContextCheckSize	(	MemoryContext	context,
		Size	size,
		int	flags
	)

inlinestatic

Definition at line 167 of file memutils_internal.h.

 {
     if (unlikely(!AllocSizeIsValid(size)))
     {
         if (!(flags & MCXT_ALLOC_HUGE) || !AllocHugeSizeIsValid(size))
             MemoryContextSizeFailure(context, size, flags);
     }
 }

References AllocHugeSizeIsValid, AllocSizeIsValid, context, MCXT_ALLOC_HUGE, MemoryContextSizeFailure(), size, and unlikely.

Referenced by AllocSetAllocLarge(), AllocSetRealloc(), BumpAllocLarge(), and GenerationAllocLarge().

◆ MemoryContextCreate()

void MemoryContextCreate	(	MemoryContext	node,
		NodeTag	tag,
		MemoryContextMethodID	method_id,
		MemoryContext	parent,
		const char *	name
	)

Definition at line 1100 of file mcxt.c.

 {
     /* Creating new memory contexts is not allowed in a critical section */
     Assert(CritSectionCount == 0);
  
     /* Initialize all standard fields of memory context header */
     node->type = tag;
     node->isReset = true;
     node->methods = &mcxt_methods[method_id];
     node->parent = parent;
     node->firstchild = NULL;
     node->mem_allocated = 0;
     node->prevchild = NULL;
     node->name = name;
     node->ident = NULL;
     node->reset_cbs = NULL;
  
     /* OK to link node into context tree */
     if (parent)
     {
         node->nextchild = parent->firstchild;
         if (parent->firstchild != NULL)
             parent->firstchild->prevchild = node;
         parent->firstchild = node;
         /* inherit allowInCritSection flag from parent */
         node->allowInCritSection = parent->allowInCritSection;
     }
     else
     {
         node->nextchild = NULL;
         node->allowInCritSection = false;
     }
  
     VALGRIND_CREATE_MEMPOOL(node, 0, false);
 }

References MemoryContextData::allowInCritSection, Assert, CritSectionCount, MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextData::isReset, mcxt_methods, MemoryContextData::mem_allocated, MemoryContextData::methods, name, MemoryContextData::name, MemoryContextData::nextchild, MemoryContextData::parent, MemoryContextData::prevchild, MemoryContextData::reset_cbs, and VALGRIND_CREATE_MEMPOOL.

Referenced by AllocSetContextCreateInternal(), BumpContextCreate(), GenerationContextCreate(), and SlabContextCreate().

◆ MemoryContextSizeFailure()

void MemoryContextSizeFailure	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 1168 of file mcxt.c.

 {
     elog(ERROR, "invalid memory alloc request size %zu", size);
 }

References elog, ERROR, and size.

Referenced by MemoryContextCheckSize().

◆ SlabAlloc()

void* SlabAlloc	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 630 of file slab.c.

 {
     SlabContext *slab = (SlabContext *) context;
     SlabBlock  *block;
     MemoryChunk *chunk;
  
     Assert(SlabIsValid(slab));
  
     /* sanity check that this is pointing to a valid blocklist */
     Assert(slab->curBlocklistIndex >= 0);
     Assert(slab->curBlocklistIndex <= SlabBlocklistIndex(slab, slab->chunksPerBlock));
  
     /*
      * Make sure we only allow correct request size.  This doubles as the
      * MemoryContextCheckSize check.
      */
     if (unlikely(size != slab->chunkSize))
         SlabAllocInvalidSize(context, size);
  
     if (unlikely(slab->curBlocklistIndex == 0))
     {
         /*
          * Handle the case when there are no partially filled blocks
          * available.  This happens either when the last allocation took the
          * last chunk in the block, or when SlabFree() free'd the final block.
          */
         return SlabAllocFromNewBlock(context, size, flags);
     }
     else
     {
         dlist_head *blocklist = &slab->blocklist[slab->curBlocklistIndex];
         int         new_blocklist_idx;
  
         Assert(!dlist_is_empty(blocklist));
  
         /* grab the block from the blocklist */
         block = dlist_head_element(SlabBlock, node, blocklist);
  
         /* make sure we actually got a valid block, with matching nfree */
         Assert(block != NULL);
         Assert(slab->curBlocklistIndex == SlabBlocklistIndex(slab, block->nfree));
         Assert(block->nfree > 0);
  
         /* fetch the next chunk from this block */
         chunk = SlabGetNextFreeChunk(slab, block);
  
         /* get the new blocklist index based on the new free chunk count */
         new_blocklist_idx = SlabBlocklistIndex(slab, block->nfree);
  
         /*
          * Handle the case where the blocklist index changes.  This also deals
          * with blocks becoming full as only full blocks go at index 0.
          */
         if (unlikely(slab->curBlocklistIndex != new_blocklist_idx))
         {
             dlist_delete_from(blocklist, &block->node);
             dlist_push_head(&slab->blocklist[new_blocklist_idx], &block->node);
  
             if (dlist_is_empty(blocklist))
                 slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
         }
     }
  
     return SlabAllocSetupNewChunk(context, block, chunk, size);
 }

References Assert, SlabContext::blocklist, chunk, SlabContext::chunkSize, SlabContext::chunksPerBlock, context, SlabContext::curBlocklistIndex, dlist_delete_from(), dlist_head_element, dlist_is_empty(), dlist_push_head(), SlabBlock::nfree, SlabBlock::node, size, SlabAllocFromNewBlock(), SlabAllocSetupNewChunk(), SlabBlocklistIndex(), SlabFindNextBlockListIndex(), SlabGetNextFreeChunk(), SlabIsValid, and unlikely.

◆ SlabDelete()

void SlabDelete ( MemoryContext context )

Definition at line 485 of file slab.c.

 {
     /* Reset to release all the SlabBlocks */
     SlabReset(context);
     /* And free the context header */
     free(context);
 }

References context, free, and SlabReset().

◆ SlabFree()

void SlabFree ( void * pointer )

Definition at line 701 of file slab.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     SlabBlock  *block;
     SlabContext *slab;
     int         curBlocklistIdx;
     int         newBlocklistIdx;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
  
     block = MemoryChunkGetBlock(chunk);
  
     /*
      * For speed reasons we just Assert that the referenced block is good.
      * Future field experience may show that this Assert had better become a
      * regular runtime test-and-elog check.
      */
     Assert(SlabBlockIsValid(block));
     slab = block->slab;
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Test for someone scribbling on unused space in chunk */
     Assert(slab->chunkSize < (slab->fullChunkSize - Slab_CHUNKHDRSZ));
     if (!sentinel_ok(pointer, slab->chunkSize))
         elog(WARNING, "detected write past chunk end in %s %p",
              slab->header.name, chunk);
 #endif
  
     /* push this chunk onto the head of the block's free list */
     *(MemoryChunk **) pointer = block->freehead;
     block->freehead = chunk;
  
     block->nfree++;
  
     Assert(block->nfree > 0);
     Assert(block->nfree <= slab->chunksPerBlock);
  
 #ifdef CLOBBER_FREED_MEMORY
     /* don't wipe the free list MemoryChunk pointer stored in the chunk */
     wipe_mem((char *) pointer + sizeof(MemoryChunk *),
              slab->chunkSize - sizeof(MemoryChunk *));
 #endif
  
     curBlocklistIdx = SlabBlocklistIndex(slab, block->nfree - 1);
     newBlocklistIdx = SlabBlocklistIndex(slab, block->nfree);
  
     /*
      * Check if the block needs to be moved to another element on the
      * blocklist based on it now having 1 more free chunk.
      */
     if (unlikely(curBlocklistIdx != newBlocklistIdx))
     {
         /* do the move */
         dlist_delete_from(&slab->blocklist[curBlocklistIdx], &block->node);
         dlist_push_head(&slab->blocklist[newBlocklistIdx], &block->node);
  
         /*
          * The blocklist[curBlocklistIdx] may now be empty or we may now be
          * able to use a lower-element blocklist.  We'll need to redetermine
          * what the slab->curBlocklistIndex is if the current blocklist was
          * changed or if a lower element one was changed.  We must ensure we
          * use the list with the fullest block(s).
          */
         if (slab->curBlocklistIndex >= curBlocklistIdx)
         {
             slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
  
             /*
              * We know there must be a block with at least 1 unused chunk as
              * we just pfree'd one.  Ensure curBlocklistIndex reflects this.
              */
             Assert(slab->curBlocklistIndex > 0);
         }
     }
  
     /* Handle when a block becomes completely empty */
     if (unlikely(block->nfree == slab->chunksPerBlock))
     {
         /* remove the block */
         dlist_delete_from(&slab->blocklist[newBlocklistIdx], &block->node);
  
         /*
          * To avoid thrashing malloc/free, we keep a list of empty blocks that
          * we can reuse again instead of having to malloc a new one.
          */
         if (dclist_count(&slab->emptyblocks) < SLAB_MAXIMUM_EMPTY_BLOCKS)
             dclist_push_head(&slab->emptyblocks, &block->node);
         else
         {
             /*
              * When we have enough empty blocks stored already, we actually
              * free the block.
              */
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(block, slab->blockSize);
 #endif
             free(block);
             slab->header.mem_allocated -= slab->blockSize;
         }
  
         /*
          * Check if we need to reset the blocklist index.  This is required
          * when the blocklist this block is on has become completely empty.
          */
         if (slab->curBlocklistIndex == newBlocklistIdx &&
             dlist_is_empty(&slab->blocklist[newBlocklistIdx]))
             slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
     }
 }

References Assert, SlabContext::blocklist, SlabContext::blockSize, chunk, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dclist_count(), dclist_push_head(), dlist_delete_from(), dlist_is_empty(), dlist_push_head(), elog(), SlabContext::emptyblocks, free, SlabBlock::freehead, SlabContext::fullChunkSize, SlabContext::header, MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryContextData::name, SlabBlock::nfree, SlabBlock::node, PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SLAB_MAXIMUM_EMPTY_BLOCKS, SlabBlockIsValid, SlabBlocklistIndex(), SlabFindNextBlockListIndex(), unlikely, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

◆ SlabGetChunkContext()

MemoryContext SlabGetChunkContext ( void * pointer )

Definition at line 863 of file slab.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     SlabBlock  *block;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
  
     block = MemoryChunkGetBlock(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
  
     Assert(SlabBlockIsValid(block));
  
     return &block->slab->header;
 }

References Assert, chunk, SlabContext::header, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ SlabGetChunkSpace()

Size SlabGetChunkSpace ( void * pointer )

Definition at line 887 of file slab.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     SlabBlock  *block;
     SlabContext *slab;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
  
     block = MemoryChunkGetBlock(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
  
     Assert(SlabBlockIsValid(block));
     slab = block->slab;
  
     return slab->fullChunkSize;
 }

References Assert, chunk, SlabContext::fullChunkSize, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ SlabIsEmpty()

bool SlabIsEmpty ( MemoryContext context )

Definition at line 912 of file slab.c.

 {
     Assert(SlabIsValid((SlabContext *) context));
  
     return (context->mem_allocated == 0);
 }

References Assert, context, and SlabIsValid.

◆ SlabRealloc()

void* SlabRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 826 of file slab.c.

 {
     MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
     SlabBlock  *block;
     SlabContext *slab;
  
     /* Allow access to the chunk header. */
     VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
  
     block = MemoryChunkGetBlock(chunk);
  
     /* Disallow access to the chunk header. */
     VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
  
     /*
      * Try to verify that we have a sane block pointer: the block header
      * should reference a slab context.  (We use a test-and-elog, not just
      * Assert, because it seems highly likely that we're here in error in the
      * first place.)
      */
     if (!SlabBlockIsValid(block))
         elog(ERROR, "could not find block containing chunk %p", chunk);
     slab = block->slab;
  
     /* can't do actual realloc with slab, but let's try to be gentle */
     if (size == slab->chunkSize)
         return pointer;
  
     elog(ERROR, "slab allocator does not support realloc()");
     return NULL;                /* keep compiler quiet */
 }

References chunk, SlabContext::chunkSize, elog(), ERROR, MemoryChunkGetBlock(), PointerGetMemoryChunk, size, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

◆ SlabReset()

void SlabReset ( MemoryContext context )

Definition at line 431 of file slab.c.

 {
     SlabContext *slab = (SlabContext *) context;
     dlist_mutable_iter miter;
     int         i;
  
     Assert(SlabIsValid(slab));
  
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     SlabCheck(context);
 #endif
  
     /* release any retained empty blocks */
     dclist_foreach_modify(miter, &slab->emptyblocks)
     {
         SlabBlock  *block = dlist_container(SlabBlock, node, miter.cur);
  
         dclist_delete_from(&slab->emptyblocks, miter.cur);
  
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(block, slab->blockSize);
 #endif
         free(block);
         context->mem_allocated -= slab->blockSize;
     }
  
     /* walk over blocklist and free the blocks */
     for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
     {
         dlist_foreach_modify(miter, &slab->blocklist[i])
         {
             SlabBlock  *block = dlist_container(SlabBlock, node, miter.cur);
  
             dlist_delete(miter.cur);
  
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(block, slab->blockSize);
 #endif
             free(block);
             context->mem_allocated -= slab->blockSize;
         }
     }
  
     slab->curBlocklistIndex = 0;
  
     Assert(context->mem_allocated == 0);
 }

References Assert, SlabContext::blocklist, SlabContext::blockSize, context, dlist_mutable_iter::cur, SlabContext::curBlocklistIndex, dclist_delete_from(), dclist_foreach_modify, dlist_container, dlist_delete(), dlist_foreach_modify, SlabContext::emptyblocks, free, i, SLAB_BLOCKLIST_COUNT, and SlabIsValid.

Referenced by SlabDelete().

◆ SlabStats()

void SlabStats	(	MemoryContext	context,
		MemoryStatsPrintFunc	printfunc,
		void *	passthru,
		MemoryContextCounters *	totals,
		bool	print_to_stderr
	)

Definition at line 929 of file slab.c.

 {
     SlabContext *slab = (SlabContext *) context;
     Size        nblocks = 0;
     Size        freechunks = 0;
     Size        totalspace;
     Size        freespace = 0;
     int         i;
  
     Assert(SlabIsValid(slab));
  
     /* Include context header in totalspace */
     totalspace = Slab_CONTEXT_HDRSZ(slab->chunksPerBlock);
  
     /* Add the space consumed by blocks in the emptyblocks list */
     totalspace += dclist_count(&slab->emptyblocks) * slab->blockSize;
  
     for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
     {
         dlist_iter  iter;
  
         dlist_foreach(iter, &slab->blocklist[i])
         {
             SlabBlock  *block = dlist_container(SlabBlock, node, iter.cur);
  
             nblocks++;
             totalspace += slab->blockSize;
             freespace += slab->fullChunkSize * block->nfree;
             freechunks += block->nfree;
         }
     }
  
     if (printfunc)
     {
         char        stats_string[200];
  
         /* XXX should we include free chunks on empty blocks? */
         snprintf(stats_string, sizeof(stats_string),
                  "%zu total in %zu blocks; %u empty blocks; %zu free (%zu chunks); %zu used",
                  totalspace, nblocks, dclist_count(&slab->emptyblocks),
                  freespace, freechunks, totalspace - freespace);
         printfunc(context, passthru, stats_string, print_to_stderr);
     }
  
     if (totals)
     {
         totals->nblocks += nblocks;
         totals->freechunks += freechunks;
         totals->totalspace += totalspace;
         totals->freespace += freespace;
     }
 }

References Assert, SlabContext::blocklist, SlabContext::blockSize, SlabContext::chunksPerBlock, context, dlist_iter::cur, dclist_count(), dlist_container, dlist_foreach, SlabContext::emptyblocks, MemoryContextCounters::freechunks, MemoryContextCounters::freespace, SlabContext::fullChunkSize, i, MemoryContextCounters::nblocks, SlabBlock::nfree, SLAB_BLOCKLIST_COUNT, Slab_CONTEXT_HDRSZ, SlabIsValid, snprintf, and MemoryContextCounters::totalspace.

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ MEMORY_CONTEXT_METHODID_BITS

◆ MEMORY_CONTEXT_METHODID_MASK

◆ PallocAlignedExtraBytes

Typedef Documentation

◆ MemoryContextMethodID

Enumeration Type Documentation

◆ MemoryContextMethodID

Function Documentation

◆ AlignedAllocFree()

◆ AlignedAllocGetChunkContext()

◆ AlignedAllocGetChunkSpace()

◆ AlignedAllocRealloc()

◆ AllocSetAlloc()

◆ AllocSetDelete()

◆ AllocSetFree()

◆ AllocSetGetChunkContext()

◆ AllocSetGetChunkSpace()

◆ AllocSetIsEmpty()

◆ AllocSetRealloc()

◆ AllocSetReset()

◆ AllocSetStats()

◆ BumpAlloc()

◆ BumpDelete()

◆ BumpFree()

◆ BumpGetChunkContext()

◆ BumpGetChunkSpace()

◆ BumpIsEmpty()

◆ BumpRealloc()

◆ BumpReset()

◆ BumpStats()

◆ GenerationAlloc()

◆ GenerationDelete()

◆ GenerationFree()

◆ GenerationGetChunkContext()

◆ GenerationGetChunkSpace()

◆ GenerationIsEmpty()

◆ GenerationRealloc()

◆ GenerationReset()

◆ GenerationStats()

◆ MemoryContextAllocationFailure()

◆ MemoryContextCheckSize()

◆ MemoryContextCreate()

◆ MemoryContextSizeFailure()

◆ SlabAlloc()

◆ SlabDelete()

◆ SlabFree()

◆ SlabGetChunkContext()

◆ SlabGetChunkSpace()

◆ SlabIsEmpty()

◆ SlabRealloc()

◆ SlabReset()

◆ SlabStats()