#include "postgres.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"

Include dependency graph for aset.c:

Data Structures
struct	AllocSetContext

struct	AllocBlockData

struct	AllocChunkData

Macros
#define	ALLOC_MINBITS 3 /* smallest chunk size is 8 bytes */

#define	ALLOCSET_NUM_FREELISTS 11

#define	ALLOC_CHUNK_LIMIT (1 << (ALLOCSET_NUM_FREELISTS-1+ALLOC_MINBITS))

#define	ALLOC_CHUNK_FRACTION 4

#define	ALLOC_BLOCKHDRSZ MAXALIGN(sizeof(AllocBlockData))

#define	ALLOC_CHUNKHDRSZ sizeof(struct AllocChunkData)

#define	AllocPointerIsValid(pointer) PointerIsValid(pointer)

#define	AllocSetIsValid(set) PointerIsValid(set)

#define	AllocPointerGetChunk(ptr) ((AllocChunk)(((char *)(ptr)) - ALLOC_CHUNKHDRSZ))

#define	AllocChunkGetPointer(chk) ((AllocPointer)(((char *)(chk)) + ALLOC_CHUNKHDRSZ))

#define	LT16(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n

#define	AllocFreeInfo(_cxt, _chunk)

#define	AllocAllocInfo(_cxt, _chunk)

Typedefs
typedef struct AllocBlockData *	AllocBlock

typedef struct AllocChunkData *	AllocChunk

typedef void *	AllocPointer

typedef struct AllocSetContext	AllocSetContext

typedef AllocSetContext *	AllocSet

typedef struct AllocBlockData	AllocBlockData

typedef struct AllocChunkData	AllocChunkData

Functions
static void *	AllocSetAlloc (MemoryContext context, Size size)

static void	AllocSetFree (MemoryContext context, void *pointer)

static void *	AllocSetRealloc (MemoryContext context, void *pointer, Size size)

static void	AllocSetInit (MemoryContext context)

static void	AllocSetReset (MemoryContext context)

static void	AllocSetDelete (MemoryContext context)

static Size	AllocSetGetChunkSpace (MemoryContext context, void *pointer)

static bool	AllocSetIsEmpty (MemoryContext context)

static void	AllocSetStats (MemoryContext context, int level, bool print, MemoryContextCounters *totals)

static int	AllocSetFreeIndex (Size size)

MemoryContext	AllocSetContextCreate (MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)

Variables
static MemoryContextMethods	AllocSetMethods

static const unsigned char	LogTable256 [256]

Macro Definition Documentation

#define ALLOC_BLOCKHDRSZ MAXALIGN(sizeof(AllocBlockData))

Definition at line 99 of file aset.c.

Referenced by AllocSetAlloc(), AllocSetContextCreate(), AllocSetFree(), AllocSetRealloc(), and AllocSetReset().

#define ALLOC_CHUNK_FRACTION 4

Definition at line 85 of file aset.c.

Referenced by AllocSetContextCreate().

#define ALLOC_CHUNK_LIMIT (1 << (ALLOCSET_NUM_FREELISTS-1+ALLOC_MINBITS))

Definition at line 83 of file aset.c.

Referenced by AllocSetContextCreate().

#define ALLOC_CHUNKHDRSZ sizeof(struct AllocChunkData)

Definition at line 100 of file aset.c.

Referenced by AllocSetAlloc(), AllocSetContextCreate(), AllocSetFree(), AllocSetGetChunkSpace(), AllocSetRealloc(), and AllocSetStats().

#define ALLOC_MINBITS 3 /* smallest chunk size is 8 bytes */

Definition at line 81 of file aset.c.

Referenced by AllocSetAlloc(), and AllocSetFreeIndex().

#define AllocAllocInfo	(	_cxt,
		_chunk
	)

Definition at line 259 of file aset.c.

Referenced by AllocSetAlloc().

#define AllocChunkGetPointer ( chk ) ((AllocPointer)(((char *)(chk)) + ALLOC_CHUNKHDRSZ))

Definition at line 195 of file aset.c.

Referenced by AllocSetAlloc(), and AllocSetRealloc().

#define AllocFreeInfo	(	_cxt,
		_chunk
	)

Definition at line 258 of file aset.c.

Referenced by AllocSetFree().

#define AllocPointerGetChunk ( ptr ) ((AllocChunk)(((char *)(ptr)) - ALLOC_CHUNKHDRSZ))

Definition at line 193 of file aset.c.

Referenced by AllocSetFree(), AllocSetGetChunkSpace(), and AllocSetRealloc().

#define AllocPointerIsValid ( pointer ) PointerIsValid(pointer)

Definition at line 185 of file aset.c.

#define ALLOCSET_NUM_FREELISTS 11

Definition at line 82 of file aset.c.

Referenced by AllocSetFreeIndex(), and AllocSetStats().

#define AllocSetIsValid ( set ) PointerIsValid(set)

Definition at line 191 of file aset.c.

Referenced by AllocSetAlloc(), AllocSetDelete(), and AllocSetReset().

#define LT16 ( n ) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n

Definition at line 237 of file aset.c.

Typedef Documentation

typedef struct AllocBlockData* AllocBlock

Definition at line 102 of file aset.c.

typedef struct AllocBlockData AllocBlockData

typedef struct AllocChunkData* AllocChunk

Definition at line 103 of file aset.c.

typedef struct AllocChunkData AllocChunkData

typedef void* AllocPointer

Definition at line 109 of file aset.c.

typedef AllocSetContext* AllocSet

Definition at line 134 of file aset.c.

typedef struct AllocSetContext AllocSetContext

Function Documentation

static void * AllocSetAlloc	(	MemoryContext	context,
		Size	size
	)

static

Definition at line 562 of file aset.c.

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, ALLOC_MINBITS, AllocAllocInfo, AllocChunkGetPointer, AllocSetContext::allocChunkLimit, AllocSetFreeIndex(), AllocSetIsValid, AllocBlockData::aset, AllocChunkData::aset, Assert, AssertArg, AllocSetContext::blocks, AllocBlockData::endptr, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::initBlockSize, AllocSetContext::keeper, malloc, MAXALIGN, AllocSetContext::maxBlockSize, AllocBlockData::next, AllocSetContext::nextBlockSize, AllocBlockData::prev, AllocChunkData::size, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by AllocSetRealloc().

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block;
     AllocChunk  chunk;
     int         fidx;
     Size        chunk_size;
     Size        blksize;
 
     AssertArg(AllocSetIsValid(set));
 
     /*
      * If requested size exceeds maximum for chunks, allocate an entire block
      * for this request.
      */
     if (size > set->allocChunkLimit)
     {
         chunk_size = MAXALIGN(size);
         blksize = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
         block = (AllocBlock) malloc(blksize);
         if (block == NULL)
             return NULL;
         block->aset = set;
         block->freeptr = block->endptr = ((char *) block) + blksize;
 
         chunk = (AllocChunk) (((char *) block) + ALLOC_BLOCKHDRSZ);
         chunk->aset = set;
         chunk->size = chunk_size;
 #ifdef MEMORY_CONTEXT_CHECKING
         /* Valgrind: Will be made NOACCESS below. */
         chunk->requested_size = size;
         /* set mark to catch clobber of "unused" space */
         if (size < chunk_size)
             set_sentinel(AllocChunkGetPointer(chunk), size);
 #endif
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* fill the allocated space with junk */
         randomize_mem((char *) AllocChunkGetPointer(chunk), size);
 #endif
 
         /*
          * Stick the new block underneath the active allocation block, if any,
          * so that we don't lose the use of the space remaining therein.
          */
         if (set->blocks != NULL)
         {
             block->prev = set->blocks;
             block->next = set->blocks->next;
             if (block->next)
                 block->next->prev = block;
             set->blocks->next = block;
         }
         else
         {
             block->prev = NULL;
             block->next = NULL;
             set->blocks = block;
         }
 
         AllocAllocInfo(set, chunk);
 
         /*
          * Chunk's metadata fields remain DEFINED.  The requested allocation
          * itself can be NOACCESS or UNDEFINED; our caller will soon make it
          * UNDEFINED.  Make extra space at the end of the chunk, if any,
          * NOACCESS.
          */
         VALGRIND_MAKE_MEM_NOACCESS((char *) chunk + ALLOC_CHUNKHDRSZ,
                                    chunk_size - ALLOC_CHUNKHDRSZ);
 
         return AllocChunkGetPointer(chunk);
     }
 
     /*
      * 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.
      */
     fidx = AllocSetFreeIndex(size);
     chunk = set->freelist[fidx];
     if (chunk != NULL)
     {
         Assert(chunk->size >= size);
 
         set->freelist[fidx] = (AllocChunk) chunk->aset;
 
         chunk->aset = (void *) set;
 
 #ifdef MEMORY_CONTEXT_CHECKING
         /* Valgrind: Free list requested_size should be DEFINED. */
         chunk->requested_size = size;
         VALGRIND_MAKE_MEM_NOACCESS(&chunk->requested_size,
                                    sizeof(chunk->requested_size));
         /* set mark to catch clobber of "unused" space */
         if (size < chunk->size)
             set_sentinel(AllocChunkGetPointer(chunk), size);
 #endif
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* fill the allocated space with junk */
         randomize_mem((char *) AllocChunkGetPointer(chunk), size);
 #endif
 
         AllocAllocInfo(set, chunk);
         return AllocChunkGetPointer(chunk);
     }
 
     /*
      * Choose the actual chunk size to allocate.
      */
     chunk_size = (1 << ALLOC_MINBITS) << fidx;
     Assert(chunk_size >= size);
 
     /*
      * 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 ((block = set->blocks) != NULL)
     {
         Size        availspace = block->endptr - block->freeptr;
 
         if (availspace < (chunk_size + ALLOC_CHUNKHDRSZ))
         {
             /*
              * The existing active (top) block does not have enough room for
              * the requested allocation, but it might still have a useful
              * amount of space in it.  Once we push it down in the block list,
              * we'll never try to allocate more space from it. So, before we
              * do that, carve up its free space into chunks that we can put on
              * the set's freelists.
              *
              * Because we can only get here when there's less than
              * ALLOC_CHUNK_LIMIT left in the block, this loop cannot iterate
              * more than ALLOCSET_NUM_FREELISTS-1 times.
              */
             while (availspace >= ((1 << ALLOC_MINBITS) + ALLOC_CHUNKHDRSZ))
             {
                 Size        availchunk = availspace - ALLOC_CHUNKHDRSZ;
                 int         a_fidx = AllocSetFreeIndex(availchunk);
 
                 /*
                  * In most cases, we'll get back the index of the next larger
                  * freelist than the one we need to put this chunk on.  The
                  * exception is when availchunk is exactly a power of 2.
                  */
                 if (availchunk != ((Size) 1 << (a_fidx + ALLOC_MINBITS)))
                 {
                     a_fidx--;
                     Assert(a_fidx >= 0);
                     availchunk = ((Size) 1 << (a_fidx + ALLOC_MINBITS));
                 }
 
                 chunk = (AllocChunk) (block->freeptr);
 
                 /* Prepare to initialize the chunk header. */
                 VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
                 block->freeptr += (availchunk + ALLOC_CHUNKHDRSZ);
                 availspace -= (availchunk + ALLOC_CHUNKHDRSZ);
 
                 chunk->size = availchunk;
 #ifdef MEMORY_CONTEXT_CHECKING
                 chunk->requested_size = 0;  /* mark it free */
 #endif
                 chunk->aset = (void *) set->freelist[a_fidx];
                 set->freelist[a_fidx] = chunk;
             }
 
             /* Mark that we need to create a new block */
             block = NULL;
         }
     }
 
     /*
      * Time to create a new regular (multi-chunk) block?
      */
     if (block == NULL)
     {
         Size        required_size;
 
         /*
          * The first such block has size initBlockSize, and we double the
          * space in each succeeding block, but not more than maxBlockSize.
          */
         blksize = set->nextBlockSize;
         set->nextBlockSize <<= 1;
         if (set->nextBlockSize > set->maxBlockSize)
             set->nextBlockSize = set->maxBlockSize;
 
         /*
          * If initBlockSize is less than ALLOC_CHUNK_LIMIT, we could need more
          * space... but try to keep it a power of 2.
          */
         required_size = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
         while (blksize < required_size)
             blksize <<= 1;
 
         /* Try to allocate it */
         block = (AllocBlock) malloc(blksize);
 
         /*
          * We could be asking for pretty big blocks here, so cope if malloc
          * fails.  But give up if there's less than a meg or so available...
          */
         while (block == NULL && blksize > 1024 * 1024)
         {
             blksize >>= 1;
             if (blksize < required_size)
                 break;
             block = (AllocBlock) malloc(blksize);
         }
 
         if (block == NULL)
             return NULL;
 
         block->aset = set;
         block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
         block->endptr = ((char *) block) + blksize;
 
         /*
          * If this is the first block of the set, make it the "keeper" block.
          * Formerly, a keeper block could only be created during context
          * creation, but allowing it to happen here lets us have fast reset
          * cycling even for contexts created with minContextSize = 0; that way
          * we don't have to force space to be allocated in contexts that might
          * never need any space.  Don't mark an oversize block as a keeper,
          * however.
          */
         if (set->keeper == NULL && blksize == set->initBlockSize)
             set->keeper = block;
 
         /* Mark unallocated space NOACCESS. */
         VALGRIND_MAKE_MEM_NOACCESS(block->freeptr,
                                    blksize - ALLOC_BLOCKHDRSZ);
 
         block->prev = NULL;
         block->next = set->blocks;
         if (block->next)
             block->next->prev = block;
         set->blocks = block;
     }
 
     /*
      * OK, do the allocation
      */
     chunk = (AllocChunk) (block->freeptr);
 
     /* Prepare to initialize the chunk header. */
     VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
     block->freeptr += (chunk_size + ALLOC_CHUNKHDRSZ);
     Assert(block->freeptr <= block->endptr);
 
     chunk->aset = (void *) set;
     chunk->size = chunk_size;
 #ifdef MEMORY_CONTEXT_CHECKING
     chunk->requested_size = size;
     VALGRIND_MAKE_MEM_NOACCESS(&chunk->requested_size,
                                sizeof(chunk->requested_size));
     /* set mark to catch clobber of "unused" space */
     if (size < chunk->size)
         set_sentinel(AllocChunkGetPointer(chunk), size);
 #endif
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
     /* fill the allocated space with junk */
     randomize_mem((char *) AllocChunkGetPointer(chunk), size);
 #endif
 
     AllocAllocInfo(set, chunk);
     return AllocChunkGetPointer(chunk);
 }

MemoryContext AllocSetContextCreate	(	MemoryContext	parent,
		const char *	name,
		Size	minContextSize,
		Size	initBlockSize,
		Size	maxBlockSize
	)

Definition at line 322 of file aset.c.

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNK_FRACTION, ALLOC_CHUNK_LIMIT, ALLOC_CHUNKHDRSZ, AllocSetContext::allocChunkLimit, AllocHugeSizeIsValid, ALLOCSET_SEPARATE_THRESHOLD, AllocSetMethods, AllocBlockData::aset, AllocSetContext::blocks, elog, AllocBlockData::endptr, ereport, errcode(), errdetail(), errmsg(), ERROR, AllocBlockData::freeptr, AllocSetContext::initBlockSize, AllocSetContext::keeper, malloc, MAXALIGN, AllocSetContext::maxBlockSize, MemoryContextCreate(), MemoryContextStats(), name, AllocBlockData::next, AllocSetContext::nextBlockSize, offsetof, AllocBlockData::prev, StaticAssertStmt, T_AllocSetContext, TopMemoryContext, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by _bt_preprocess_array_keys(), _SPI_make_plan_non_temp(), _SPI_save_plan(), afterTriggerAddEvent(), afterTriggerInvokeEvents(), AllocateSnapshotBuilder(), ApplyLauncherMain(), ApplyWorkerMain(), AtStart_Memory(), AtSubStart_Memory(), AutoVacLauncherMain(), BackgroundWriterMain(), begin_heap_rewrite(), BeginCopy(), blbuild(), blinsert(), brin_build_desc(), brin_new_memtuple(), bringetbitmap(), brininsert(), bt_check_every_level(), btvacuumscan(), BuildCachedPlan(), BuildEventTriggerCache(), BuildRelationExtStatistics(), CheckpointerMain(), cluster(), compile_plperl_function(), compile_pltcl_function(), CompleteCachedPlan(), compute_index_stats(), CopyCachedPlan(), CopyTo(), CreateCachedPlan(), CreateCacheMemoryContext(), CreateExecutorState(), CreateExprContext(), CreatePortal(), CreateStandaloneExprContext(), createTempGistContext(), createTrgmNFA(), DiscreteKnapsack(), do_analyze_rel(), do_autovacuum(), do_compile(), do_start_worker(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), EventTriggerInvoke(), exec_parse_message(), exec_replication_command(), ExecHashTableCreate(), ExecInitFunctionScan(), ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), expand_array(), file_acquire_sample_rows(), fill_hba_view(), geqo_eval(), get_stmt_mcontext(), GetLocalBufferStorage(), gin_xlog_startup(), ginbeginscan(), ginbuild(), ginbulkdelete(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gistrescan(), HandleParallelMessages(), hash_create(), index_register(), init_MultiFuncCall(), init_sql_fcache(), initArrayResult(), initArrayResultArr(), initGISTstate(), initialize_peragg(), InitXLogInsert(), inline_function(), inline_set_returning_function(), libpqrcv_processTuples(), load_domaintype_info(), load_hba(), load_ident(), load_relcache_init_file(), load_tzoffsets(), logicalrep_relmap_init(), LogicalRepApplyLoop(), lookup_ts_dictionary_cache(), materializeQueryResult(), mdinit(), MemoryContextInit(), mXactCachePut(), NIStartBuild(), ParallelWorkerMain(), PerformAuthentication(), pg_decode_startup(), pgoutput_startup(), pgstat_setup_memcxt(), plperl_return_next_internal(), plperl_spi_prepare(), plpgsql_compile_inline(), plpgsql_estate_setup(), plpython_inline_handler(), pltcl_SPI_prepare(), PLy_cursor_plan(), PLy_cursor_query(), PLy_get_scratch_context(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), PLyObject_ToComposite(), PLyString_ToComposite(), PortalCreateHoldStore(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignModify(), postgresBeginForeignScan(), PostgresMain(), PostmasterMain(), printtup_startup(), publicationListToArray(), rebuild_database_list(), ReindexMultipleTables(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationInitIndexAccessInfo(), ReorderBufferAllocate(), ResetUnloggedRelations(), RevalidateCachedQuery(), sepgsql_avc_init(), spg_xlog_startup(), spgbeginscan(), spgbuild(), spginsert(), SPI_connect(), spi_dest_startup(), StartupDecodingContext(), strlist_to_textarray(), tokenize_file(), tuplesort_begin_common(), union_tuples(), vacuum(), WalWriterMain(), and XLOGShmemInit().

 {
     AllocSet    set;
 
     StaticAssertStmt(offsetof(AllocChunkData, aset) + sizeof(MemoryContext) ==
                      MAXALIGN(sizeof(AllocChunkData)),
                      "padding calculation in AllocChunkData is wrong");
 
     /*
      * First, validate allocation parameters.  (If we're going to throw an
      * error, we should do so before the context is created, not after.)  We
      * somewhat arbitrarily enforce a minimum 1K block size.
      */
     if (initBlockSize != MAXALIGN(initBlockSize) ||
         initBlockSize < 1024)
         elog(ERROR, "invalid initBlockSize for memory context: %zu",
              initBlockSize);
     if (maxBlockSize != MAXALIGN(maxBlockSize) ||
         maxBlockSize < initBlockSize ||
         !AllocHugeSizeIsValid(maxBlockSize))    /* must be safe to double */
         elog(ERROR, "invalid maxBlockSize for memory context: %zu",
              maxBlockSize);
     if (minContextSize != 0 &&
         (minContextSize != MAXALIGN(minContextSize) ||
          minContextSize <= ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ))
         elog(ERROR, "invalid minContextSize for memory context: %zu",
              minContextSize);
 
     /* Do the type-independent part of context creation */
     set = (AllocSet) MemoryContextCreate(T_AllocSetContext,
                                          sizeof(AllocSetContext),
                                          &AllocSetMethods,
                                          parent,
                                          name);
 
     /* Save allocation parameters */
     set->initBlockSize = initBlockSize;
     set->maxBlockSize = maxBlockSize;
     set->nextBlockSize = initBlockSize;
 
     /*
      * Compute the allocation chunk size limit for this context.  It can't be
      * more than ALLOC_CHUNK_LIMIT because of the fixed number of freelists.
      * If maxBlockSize is small then requests exceeding the maxBlockSize, or
      * even a significant fraction of it, should be treated as large chunks
      * too.  For the typical case of maxBlockSize a power of 2, the chunk size
      * limit will be at most 1/8th maxBlockSize, so that given a stream of
      * requests that are all the maximum chunk size we will waste at most
      * 1/8th of the allocated space.
      *
      * We have to have allocChunkLimit a power of two, because the requested
      * and actually-allocated sizes of any chunk must be on the same side of
      * the limit, else we get confused about whether the chunk is "big".
      *
      * Also, allocChunkLimit must not exceed ALLOCSET_SEPARATE_THRESHOLD.
      */
     StaticAssertStmt(ALLOC_CHUNK_LIMIT == ALLOCSET_SEPARATE_THRESHOLD,
                      "ALLOC_CHUNK_LIMIT != ALLOCSET_SEPARATE_THRESHOLD");
 
     set->allocChunkLimit = ALLOC_CHUNK_LIMIT;
     while ((Size) (set->allocChunkLimit + ALLOC_CHUNKHDRSZ) >
            (Size) ((maxBlockSize - ALLOC_BLOCKHDRSZ) / ALLOC_CHUNK_FRACTION))
         set->allocChunkLimit >>= 1;
 
     /*
      * Grab always-allocated space, if requested
      */
     if (minContextSize > 0)
     {
         Size        blksize = minContextSize;
         AllocBlock  block;
 
         block = (AllocBlock) malloc(blksize);
         if (block == NULL)
         {
             MemoryContextStats(TopMemoryContext);
             ereport(ERROR,
                     (errcode(ERRCODE_OUT_OF_MEMORY),
                      errmsg("out of memory"),
                      errdetail("Failed while creating memory context \"%s\".",
                                name)));
         }
         block->aset = set;
         block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
         block->endptr = ((char *) block) + blksize;
         block->prev = NULL;
         block->next = set->blocks;
         if (block->next)
             block->next->prev = block;
         set->blocks = block;
         /* Mark block as not to be released at reset time */
         set->keeper = block;
 
         /* Mark unallocated space NOACCESS; leave the block header alone. */
         VALGRIND_MAKE_MEM_NOACCESS(block->freeptr,
                                    blksize - ALLOC_BLOCKHDRSZ);
     }
 
     return (MemoryContext) set;
 }

static void AllocSetDelete ( MemoryContext context )

static

Definition at line 523 of file aset.c.

References AllocSetIsValid, AssertArg, AllocSetContext::blocks, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::keeper, MemSetAligned, AllocBlockData::next, and next.

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block = set->blocks;
 
     AssertArg(AllocSetIsValid(set));
 
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     AllocSetCheck(context);
 #endif
 
     /* Make it look empty, just in case... */
     MemSetAligned(set->freelist, 0, sizeof(set->freelist));
     set->blocks = NULL;
     set->keeper = NULL;
 
     while (block != NULL)
     {
         AllocBlock  next = block->next;
 
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(block, block->freeptr - ((char *) block));
 #endif
         free(block);
         block = next;
     }
 }

static void AllocSetFree	(	MemoryContext	context,
		void *	pointer
	)

static

Definition at line 839 of file aset.c.

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, AllocSetContext::allocChunkLimit, AllocFreeInfo, AllocPointerGetChunk, AllocSetFreeIndex(), AllocBlockData::aset, AllocChunkData::aset, AllocSetContext::blocks, elog, AllocBlockData::endptr, ERROR, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::header, MemoryContextData::name, AllocBlockData::next, AllocBlockData::prev, AllocChunkData::size, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

Referenced by AllocSetRealloc().

 {
     AllocSet    set = (AllocSet) context;
     AllocChunk  chunk = AllocPointerGetChunk(pointer);
 
     AllocFreeInfo(set, chunk);
 
 #ifdef MEMORY_CONTEXT_CHECKING
     VALGRIND_MAKE_MEM_DEFINED(&chunk->requested_size,
                               sizeof(chunk->requested_size));
     /* Test for someone scribbling on unused space in chunk */
     if (chunk->requested_size < chunk->size)
         if (!sentinel_ok(pointer, chunk->requested_size))
             elog(WARNING, "detected write past chunk end in %s %p",
                  set->header.name, chunk);
 #endif
 
     if (chunk->size > set->allocChunkLimit)
     {
         /*
          * Big chunks are certain to have been allocated as single-chunk
          * blocks.  Just unlink that block and return it to malloc().
          */
         AllocBlock  block = (AllocBlock) (((char *) chunk) - ALLOC_BLOCKHDRSZ);
 
         /*
          * Try to verify that we have a sane block pointer: it should
          * reference the correct aset, and freeptr and endptr should point
          * just past the chunk.
          */
         if (block->aset != set ||
             block->freeptr != block->endptr ||
             block->freeptr != ((char *) block) +
             (chunk->size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ))
             elog(ERROR, "could not find block containing chunk %p", chunk);
 
         /* 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;
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(block, block->freeptr - ((char *) block));
 #endif
         free(block);
     }
     else
     {
         /* Normal case, put the chunk into appropriate freelist */
         int         fidx = AllocSetFreeIndex(chunk->size);
 
         chunk->aset = (void *) set->freelist[fidx];
 
 #ifdef CLOBBER_FREED_MEMORY
         wipe_mem(pointer, chunk->size);
 #endif
 
 #ifdef MEMORY_CONTEXT_CHECKING
         /* Reset requested_size to 0 in chunks that are on freelist */
         chunk->requested_size = 0;
 #endif
         set->freelist[fidx] = chunk;
     }
 }

static int AllocSetFreeIndex ( Size size )

inlinestatic

Definition at line 271 of file aset.c.

References ALLOC_MINBITS, ALLOCSET_NUM_FREELISTS, Assert, idx(), and LogTable256.

Referenced by AllocSetAlloc(), and AllocSetFree().

 {
     int         idx;
     unsigned int t,
                 tsize;
 
     if (size > (1 << ALLOC_MINBITS))
     {
         tsize = (size - 1) >> ALLOC_MINBITS;
 
         /*
          * At this point we need to obtain log2(tsize)+1, ie, the number of
          * not-all-zero bits at the right.  We used to do this with a
          * shift-and-count loop, but this function is enough of a hotspot to
          * justify micro-optimization effort.  The best approach seems to be
          * to use a lookup table.  Note that this code assumes that
          * ALLOCSET_NUM_FREELISTS <= 17, since we only cope with two bytes of
          * the tsize value.
          */
         t = tsize >> 8;
         idx = t ? LogTable256[t] + 8 : LogTable256[tsize];
 
         Assert(idx < ALLOCSET_NUM_FREELISTS);
     }
     else
         idx = 0;
 
     return idx;
 }

static Size AllocSetGetChunkSpace	(	MemoryContext	context,
		void *	pointer
	)

static

Definition at line 1114 of file aset.c.

References ALLOC_CHUNKHDRSZ, AllocPointerGetChunk, and AllocChunkData::size.

 {
     AllocChunk  chunk = AllocPointerGetChunk(pointer);
 
     return chunk->size + ALLOC_CHUNKHDRSZ;
 }

static void AllocSetInit ( MemoryContext context )

static

Definition at line 440 of file aset.c.

 {
     /*
      * Since MemoryContextCreate already zeroed the context node, we don't
      * have to do anything here: it's already OK.
      */
 }

static bool AllocSetIsEmpty ( MemoryContext context )

static

Definition at line 1126 of file aset.c.

References MemoryContextData::isReset.

 {
     /*
      * 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;
 }

static void * AllocSetRealloc	(	MemoryContext	context,
		void *	pointer,
		Size	size
	)

static

Definition at line 919 of file aset.c.

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, AllocChunkGetPointer, AllocSetContext::allocChunkLimit, AllocPointerGetChunk, AllocSetAlloc(), AllocSetFree(), AllocBlockData::aset, AllocSetContext::blocks, elog, AllocBlockData::endptr, ERROR, AllocBlockData::freeptr, AllocSetContext::header, MAXALIGN, MemoryContextData::name, AllocBlockData::next, AllocBlockData::prev, realloc, AllocChunkData::size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

 {
     AllocSet    set = (AllocSet) context;
     AllocChunk  chunk = AllocPointerGetChunk(pointer);
     Size        oldsize = chunk->size;
 
 #ifdef MEMORY_CONTEXT_CHECKING
     VALGRIND_MAKE_MEM_DEFINED(&chunk->requested_size,
                               sizeof(chunk->requested_size));
     /* Test for someone scribbling on unused space in chunk */
     if (chunk->requested_size < oldsize)
         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 always
      * fall out here if the requested size is a decrease.)
      */
     if (oldsize >= 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;
         VALGRIND_MAKE_MEM_NOACCESS(&chunk->requested_size,
                                    sizeof(chunk->requested_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 */
         if (size < oldsize)
             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
 
         return pointer;
     }
 
     if (oldsize > set->allocChunkLimit)
     {
         /*
          * The chunk must have been allocated as a single-chunk block.  Use
          * realloc() to make the containing block bigger with minimum space
          * wastage.
          */
         AllocBlock  block = (AllocBlock) (((char *) chunk) - ALLOC_BLOCKHDRSZ);
         Size        chksize;
         Size        blksize;
 
         /*
          * Try to verify that we have a sane block pointer: it should
          * reference the correct aset, and freeptr and endptr should point
          * just past the chunk.
          */
         if (block->aset != set ||
             block->freeptr != block->endptr ||
             block->freeptr != ((char *) block) +
             (chunk->size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ))
             elog(ERROR, "could not find block containing chunk %p", chunk);
 
         /* Do the realloc */
         chksize = MAXALIGN(size);
         blksize = chksize + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
         block = (AllocBlock) realloc(block, blksize);
         if (block == NULL)
             return NULL;
         block->freeptr = block->endptr = ((char *) block) + blksize;
 
         /* Update pointers since block has likely been moved */
         chunk = (AllocChunk) (((char *) block) + ALLOC_BLOCKHDRSZ);
         pointer = AllocChunkGetPointer(chunk);
         if (block->prev)
             block->prev->next = block;
         else
             set->blocks = block;
         if (block->next)
             block->next->prev = block;
         chunk->size = chksize;
 
 #ifdef MEMORY_CONTEXT_CHECKING
 #ifdef RANDOMIZE_ALLOCATED_MEMORY
         /* We can only fill the extra space if we know the prior request */
         randomize_mem((char *) pointer + chunk->requested_size,
                       size - chunk->requested_size);
 #endif
 
         /*
          * realloc() (or randomize_mem()) will have left the newly-allocated
          * part UNDEFINED, but we may need to adjust trailing bytes from the
          * old allocation.
          */
         VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + chunk->requested_size,
                                     oldsize - chunk->requested_size);
 
         chunk->requested_size = size;
         VALGRIND_MAKE_MEM_NOACCESS(&chunk->requested_size,
                                    sizeof(chunk->requested_size));
 
         /* set mark to catch clobber of "unused" space */
         if (size < chunk->size)
             set_sentinel(pointer, size);
 #else                           /* !MEMORY_CONTEXT_CHECKING */
 
         /*
          * We don't know how much of the old chunk size was the actual
          * allocation; it could have been as small as one byte.  We have to be
          * conservative and just mark the entire old portion DEFINED.
          */
         VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
 #endif
 
         /* Make any trailing alignment padding NOACCESS. */
         VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size, chksize - size);
 
         return pointer;
     }
     else
     {
         /*
          * 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;
 
         /* allocate new chunk */
         newPointer = AllocSetAlloc((MemoryContext) set, size);
 
         /* leave immediately if request was not completed */
         if (newPointer == NULL)
             return NULL;
 
         /*
          * AllocSetAlloc() just made the region 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 */
         AllocSetFree((MemoryContext) set, pointer);
 
         return newPointer;
     }
 }

static void AllocSetReset ( MemoryContext context )

static

Definition at line 460 of file aset.c.

References ALLOC_BLOCKHDRSZ, AllocSetIsValid, AssertArg, AllocSetContext::blocks, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::initBlockSize, AllocSetContext::keeper, MemSetAligned, AllocBlockData::next, next, AllocSetContext::nextBlockSize, AllocBlockData::prev, and VALGRIND_MAKE_MEM_NOACCESS.

 {
     AllocSet    set = (AllocSet) context;
     AllocBlock  block;
 
     AssertArg(AllocSetIsValid(set));
 
 #ifdef MEMORY_CONTEXT_CHECKING
     /* Check for corruption and leaks before freeing */
     AllocSetCheck(context);
 #endif
 
     /* Clear chunk freelists */
     MemSetAligned(set->freelist, 0, sizeof(set->freelist));
 
     block = set->blocks;
 
     /* New blocks list is either empty or just the keeper block */
     set->blocks = set->keeper;
 
     while (block != NULL)
     {
         AllocBlock  next = block->next;
 
         if (block == set->keeper)
         {
             /* 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 */
 #ifdef CLOBBER_FREED_MEMORY
             wipe_mem(block, block->freeptr - ((char *) block));
 #endif
             free(block);
         }
         block = next;
     }
 
     /* Reset block size allocation sequence, too */
     set->nextBlockSize = set->initBlockSize;
 }

static void AllocSetStats	(	MemoryContext	context,
		int	level,
		bool	print,
		MemoryContextCounters *	totals
	)

static

Definition at line 1148 of file aset.c.

References ALLOC_CHUNKHDRSZ, ALLOCSET_NUM_FREELISTS, AllocChunkData::aset, AllocSetContext::blocks, AllocBlockData::endptr, MemoryContextCounters::freechunks, AllocSetContext::freelist, AllocBlockData::freeptr, MemoryContextCounters::freespace, AllocSetContext::header, i, MemoryContextData::name, MemoryContextCounters::nblocks, AllocBlockData::next, AllocChunkData::size, and MemoryContextCounters::totalspace.

 {
     AllocSet    set = (AllocSet) context;
     Size        nblocks = 0;
     Size        freechunks = 0;
     Size        totalspace = 0;
     Size        freespace = 0;
     AllocBlock  block;
     int         fidx;
 
     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++)
     {
         AllocChunk  chunk;
 
         for (chunk = set->freelist[fidx]; chunk != NULL;
              chunk = (AllocChunk) chunk->aset)
         {
             freechunks++;
             freespace += chunk->size + ALLOC_CHUNKHDRSZ;
         }
     }
 
     if (print)
     {
         int         i;
 
         for (i = 0; i < level; i++)
             fprintf(stderr, "  ");
         fprintf(stderr,
                 "%s: %zu total in %zd blocks; %zu free (%zd chunks); %zu used\n",
                 set->header.name, totalspace, nblocks, freespace, freechunks,
                 totalspace - freespace);
     }
 
     if (totals)
     {
         totals->nblocks += nblocks;
         totals->freechunks += freechunks;
         totals->totalspace += totalspace;
         totals->freespace += freespace;
     }
 }

Variable Documentation

MemoryContextMethods AllocSetMethods

static

Initial value:

= {
    AllocSetAlloc,
    AllocSetFree,
    AllocSetRealloc,
    AllocSetInit,
    AllocSetReset,
    AllocSetDelete,
    AllocSetGetChunkSpace,
    AllocSetIsEmpty,
    AllocSetStats
}

Definition at line 219 of file aset.c.

Referenced by AllocSetContextCreate().

const unsigned char LogTable256[256]

static

Initial value:

=
{
    0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
    LT16(5), LT16(6), LT16(6), LT16(7), LT16(7), LT16(7), LT16(7),
    LT16(8), LT16(8), LT16(8), LT16(8), LT16(8), LT16(8), LT16(8), LT16(8)
}

Definition at line 239 of file aset.c.

Referenced by AllocSetFreeIndex().

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation