#include "nodes/memnodes.h"

Include dependency graph for memutils.h:

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

Macros
#define	MaxAllocSize ((Size) 0x3fffffff) /* 1 gigabyte - 1 */

#define	AllocSizeIsValid(size) ((Size) (size) <= MaxAllocSize)

#define	MaxAllocHugeSize (SIZE_MAX / 2)

#define	AllocHugeSizeIsValid(size) ((Size) (size) <= MaxAllocHugeSize)

#define	MemoryContextResetAndDeleteChildren(ctx) MemoryContextReset(ctx)

#define	MemoryContextCopyAndSetIdentifier(cxt, id) MemoryContextSetIdentifier(cxt, MemoryContextStrdup(cxt, id))

#define	AllocSetContextCreate AllocSetContextCreateInternal

#define	ALLOCSET_DEFAULT_MINSIZE 0

#define	ALLOCSET_DEFAULT_INITSIZE (8 * 1024)

#define	ALLOCSET_DEFAULT_MAXSIZE (8 * 1024 * 1024)

#define	ALLOCSET_DEFAULT_SIZES ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

#define	ALLOCSET_SMALL_MINSIZE 0

#define	ALLOCSET_SMALL_INITSIZE (1 * 1024)

#define	ALLOCSET_SMALL_MAXSIZE (8 * 1024)

#define	ALLOCSET_SMALL_SIZES ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE

#define	ALLOCSET_START_SMALL_SIZES ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

#define	ALLOCSET_SEPARATE_THRESHOLD 8192

#define	SLAB_DEFAULT_BLOCK_SIZE (8 * 1024)

#define	SLAB_LARGE_BLOCK_SIZE (8 * 1024 * 1024)

Functions
void	MemoryContextInit (void)

void	MemoryContextReset (MemoryContext context)

void	MemoryContextDelete (MemoryContext context)

void	MemoryContextResetOnly (MemoryContext context)

void	MemoryContextResetChildren (MemoryContext context)

void	MemoryContextDeleteChildren (MemoryContext context)

void	MemoryContextSetIdentifier (MemoryContext context, const char *id)

void	MemoryContextSetParent (MemoryContext context, MemoryContext new_parent)

Size	GetMemoryChunkSpace (void *pointer)

MemoryContext	MemoryContextGetParent (MemoryContext context)

bool	MemoryContextIsEmpty (MemoryContext context)

Size	MemoryContextMemAllocated (MemoryContext context, bool recurse)

void	MemoryContextStats (MemoryContext context)

void	MemoryContextStatsDetail (MemoryContext context, int max_children)

void	MemoryContextAllowInCriticalSection (MemoryContext context, bool allow)

bool	MemoryContextContains (MemoryContext context, void *pointer)

static MemoryContext	GetMemoryChunkContext (void *pointer)

void	MemoryContextCreate (MemoryContext node, NodeTag tag, const MemoryContextMethods methods, MemoryContext parent, const char name)

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

MemoryContext	SlabContextCreate (MemoryContext parent, const char *name, Size blockSize, Size chunkSize)

MemoryContext	GenerationContextCreate (MemoryContext parent, const char *name, Size blockSize)

Macro Definition Documentation

◆ AllocHugeSizeIsValid

#define AllocHugeSizeIsValid ( size ) ((Size) (size) <= MaxAllocHugeSize)

Definition at line 46 of file memutils.h.

Referenced by AllocSetContextCreateInternal(), dsa_allocate_extended(), GenerationContextCreate(), MemoryContextAllocExtended(), MemoryContextAllocHuge(), palloc_extended(), and repalloc_huge().

◆ ALLOCSET_DEFAULT_INITSIZE

#define ALLOCSET_DEFAULT_INITSIZE (8 * 1024)

Definition at line 190 of file memutils.h.

Referenced by AllocSetContextCreateInternal(), and get_agg_clause_costs_walker().

◆ ALLOCSET_DEFAULT_MAXSIZE

#define ALLOCSET_DEFAULT_MAXSIZE (8 * 1024 * 1024)

Definition at line 191 of file memutils.h.

◆ ALLOCSET_DEFAULT_MINSIZE

#define ALLOCSET_DEFAULT_MINSIZE 0

Definition at line 189 of file memutils.h.

Referenced by AllocSetContextCreateInternal().

◆ ALLOCSET_DEFAULT_SIZES

#define ALLOCSET_DEFAULT_SIZES ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 192 of file memutils.h.

Referenced by afterTriggerAddEvent(), afterTriggerInvokeEvents(), AllocateSnapshotBuilder(), ApplyLauncherMain(), ApplyWorkerMain(), AtStart_Memory(), AtSubStart_Memory(), AttachPartitionEnsureIndexes(), AutoVacLauncherMain(), BackgroundWriterMain(), begin_heap_rewrite(), BeginCopy(), blbuild(), blinsert(), brin_new_memtuple(), bringetbitmap(), brininsert(), bt_check_every_level(), btree_xlog_startup(), btvacuumscan(), BuildEventTriggerCache(), BuildParamLogString(), BuildRelationExtStatistics(), CheckpointerMain(), cluster(), compute_index_stats(), ComputeExtStatisticsRows(), CopyTo(), CreateCacheMemoryContext(), CreateExecutorState(), CreateExprContext(), CreateStandaloneExprContext(), createTempGistContext(), createTrgmNFA(), 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(), exec_simple_query(), ExecCreatePartitionPruneState(), ExecHashTableCreate(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitWindowAgg(), execute_sql_string(), file_acquire_sample_rows(), geqo_eval(), get_actual_variable_range(), get_stmt_mcontext(), GetLocalBufferStorage(), gin_xlog_startup(), ginbeginscan(), ginbuild(), ginbulkdelete(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gistrescan(), HandleParallelMessages(), hash_create(), index_register(), init_sql_fcache(), initArrayResult(), initArrayResultArr(), initGISTstate(), initialize_peragg(), InitSync(), InitXLogInsert(), inline_function(), inline_set_returning_function(), libpqrcv_processTuples(), logicalrep_relmap_init(), LogicalRepApplyLoop(), make_expanded_record_from_datum(), make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), mdinit(), MemoryContextInit(), NIStartBuild(), ParallelWorkerMain(), PerformAuthentication(), pg_decode_startup(), pgoutput_startup(), plperl_return_next_internal(), plperl_spi_prepare(), plpgsql_compile_inline(), plpgsql_estate_setup(), plpython_inline_handler(), PLy_cursor_plan(), PLy_cursor_query(), PLy_get_scratch_context(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), PortalCreateHoldStore(), postgresBeginForeignScan(), PostgresMain(), PostmasterMain(), printtup_startup(), publicationListToArray(), rebuild_database_list(), RelationBuildDesc(), ReorderBufferAllocate(), ResetUnloggedRelations(), sepgsql_avc_init(), spg_xlog_startup(), spgbeginscan(), spgbuild(), spginsert(), SPI_connect_ext(), spi_dest_startup(), StartupDecodingContext(), strlist_to_textarray(), tuplesort_begin_common(), union_tuples(), vacuum(), WalWriterMain(), XLOGShmemInit(), and xml_is_document().

◆ ALLOCSET_SEPARATE_THRESHOLD

#define ALLOCSET_SEPARATE_THRESHOLD 8192

Definition at line 219 of file memutils.h.

Referenced by AllocSetContextCreateInternal(), tuplesort_begin_common(), and tuplestore_begin_common().

◆ ALLOCSET_SMALL_INITSIZE

#define ALLOCSET_SMALL_INITSIZE (1 * 1024)

Definition at line 200 of file memutils.h.

Referenced by AllocSetContextCreateInternal(), and get_agg_clause_costs_walker().

◆ ALLOCSET_SMALL_MAXSIZE

#define ALLOCSET_SMALL_MAXSIZE (8 * 1024)

Definition at line 201 of file memutils.h.

◆ ALLOCSET_SMALL_MINSIZE

#define ALLOCSET_SMALL_MINSIZE 0

Definition at line 199 of file memutils.h.

Referenced by AllocSetContextCreateInternal().

◆ ALLOCSET_SMALL_SIZES

#define ALLOCSET_SMALL_SIZES ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE

Definition at line 202 of file memutils.h.

Referenced by _bt_preprocess_array_keys(), _SPI_make_plan_non_temp(), _SPI_save_plan(), brin_build_desc(), CloneRowTriggersToPartition(), compile_plperl_function(), compile_pltcl_function(), create_foreign_modify(), CreatePortal(), CreateTrigger(), DiscreteKnapsack(), ExecInitSubPlan(), fill_hba_view(), generate_partition_qual(), get_short_term_cxt(), GetCachedExpression(), init_MultiFuncCall(), load_domaintype_info(), load_hba(), load_ident(), load_relcache_init_file(), load_tzoffsets(), lookup_ts_dictionary_cache(), mXactCachePut(), pgstat_setup_memcxt(), plperl_spi_prepare(), pltcl_SPI_prepare(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignScan(), ReindexMultipleTables(), ReindexRelationConcurrently(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationInitIndexAccessInfo(), test_pattern(), tokenize_file(), and validateForeignKeyConstraint().

◆ ALLOCSET_START_SMALL_SIZES

#define ALLOCSET_START_SMALL_SIZES ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 209 of file memutils.h.

Referenced by BuildCachedPlan(), CompleteCachedPlan(), CopyCachedPlan(), CreateCachedPlan(), expand_array(), and RevalidateCachedQuery().

◆ AllocSetContextCreate

#define AllocSetContextCreate AllocSetContextCreateInternal

Definition at line 170 of file memutils.h.

Referenced by _bt_preprocess_array_keys(), _SPI_make_plan_non_temp(), _SPI_save_plan(), afterTriggerAddEvent(), afterTriggerInvokeEvents(), AllocateSnapshotBuilder(), ApplyLauncherMain(), ApplyWorkerMain(), AtStart_Memory(), AtSubStart_Memory(), AttachPartitionEnsureIndexes(), AutoVacLauncherMain(), BackgroundWriterMain(), begin_heap_rewrite(), BeginCopy(), blbuild(), blinsert(), brin_build_desc(), brin_new_memtuple(), bringetbitmap(), brininsert(), bt_check_every_level(), btree_xlog_startup(), btvacuumscan(), BuildCachedPlan(), BuildEventTriggerCache(), BuildParamLogString(), BuildRelationExtStatistics(), CheckpointerMain(), CloneRowTriggersToPartition(), cluster(), compile_plperl_function(), compile_pltcl_function(), CompleteCachedPlan(), compute_index_stats(), ComputeExtStatisticsRows(), CopyCachedPlan(), CopyTo(), create_foreign_modify(), CreateCachedPlan(), CreateCacheMemoryContext(), CreateExecutorState(), CreateExprContext(), CreatePortal(), CreateStandaloneExprContext(), createTempGistContext(), createTrgmNFA(), CreateTrigger(), 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(), exec_simple_query(), ExecCreatePartitionPruneState(), ExecHashTableCreate(), ExecInitAgg(), ExecInitFunctionScan(), ExecInitProjectSet(), ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitWindowAgg(), execute_sql_string(), expand_array(), file_acquire_sample_rows(), fill_hba_view(), generate_partition_qual(), geqo_eval(), get_actual_variable_range(), get_short_term_cxt(), get_stmt_mcontext(), GetCachedExpression(), 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(), InitSync(), 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(), make_expanded_record_from_datum(), make_expanded_record_from_exprecord(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), 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(), PortalCreateHoldStore(), postgresAcquireSampleRowsFunc(), postgresBeginDirectModify(), postgresBeginForeignScan(), PostgresMain(), PostmasterMain(), printtup_startup(), publicationListToArray(), rebuild_database_list(), ReindexMultipleTables(), ReindexRelationConcurrently(), RelationBuildDesc(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationInitIndexAccessInfo(), ReorderBufferAllocate(), ResetUnloggedRelations(), RevalidateCachedQuery(), sepgsql_avc_init(), spg_xlog_startup(), spgbeginscan(), spgbuild(), spginsert(), SPI_connect_ext(), spi_dest_startup(), StartupDecodingContext(), strlist_to_textarray(), test_pattern(), tokenize_file(), tuplesort_begin_common(), union_tuples(), vacuum(), validateForeignKeyConstraint(), WalWriterMain(), XLOGShmemInit(), and xml_is_document().

◆ AllocSizeIsValid

#define AllocSizeIsValid ( size ) ((Size) (size) <= MaxAllocSize)

Definition at line 42 of file memutils.h.

Referenced by allocate_recordbuf(), array_fill_internal(), array_map(), array_replace_internal(), construct_md_array(), dsa_allocate_extended(), EA_get_flat_size(), MemoryContextAlloc(), MemoryContextAllocExtended(), MemoryContextAllocZero(), MemoryContextAllocZeroAligned(), palloc(), palloc0(), palloc_extended(), ReadArrayBinary(), ReadArrayStr(), and repalloc().

◆ MaxAllocHugeSize

#define MaxAllocHugeSize (SIZE_MAX / 2)

Definition at line 44 of file memutils.h.

Referenced by grow_memtuples(), perform_default_encoding_conversion(), pg_do_encoding_conversion(), and qtext_load_file().

◆ MaxAllocSize

#define MaxAllocSize ((Size) 0x3fffffff) /* 1 gigabyte - 1 */

Definition at line 40 of file memutils.h.

Referenced by array_fill_internal(), array_map(), array_replace_internal(), AtSubCommit_childXids(), compute_max_dead_tuples(), construct_md_array(), EA_get_flat_size(), EndPrepare(), enlargeStringInfo(), ExecChooseHashTableSize(), ExecHashIncreaseNumBatches(), ExecHashTableInsert(), ExecParallelHashIncreaseNumBatches(), ExecParallelHashTupleAlloc(), GetLocalBufferStorage(), ginHeapTupleFastCollect(), hstore_from_array(), hstore_from_arrays(), hstore_recv(), hstoreArrayToPairs(), lo_get_fragment_internal(), LogicalOutputWrite(), ltsConcatWorkerTapes(), ltsInitTape(), ltsReleaseBlock(), perform_default_encoding_conversion(), pg_do_encoding_conversion(), PLySequence_ToArray(), protect_out_of_mem(), pvsnprintf(), read_binary_file(), read_whole_file(), ReadArrayBinary(), ReadArrayStr(), ReadTwoPhaseFile(), setup_regexp_matches(), test_rb_tree(), tsqueryrecv(), tsvectorrecv(), varstr_abbrev_convert(), and varstrfastcmp_locale().

◆ MemoryContextCopyAndSetIdentifier

#define MemoryContextCopyAndSetIdentifier	(	cxt,
		id
	)	MemoryContextSetIdentifier(cxt, MemoryContextStrdup(cxt, id))

Definition at line 97 of file memutils.h.

Referenced by BuildCachedPlan(), generate_partition_qual(), load_relcache_init_file(), lookup_ts_dictionary_cache(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), and RelationInitIndexAccessInfo().

◆ MemoryContextResetAndDeleteChildren

#define MemoryContextResetAndDeleteChildren ( ctx ) MemoryContextReset(ctx)

◆ SLAB_DEFAULT_BLOCK_SIZE

#define SLAB_DEFAULT_BLOCK_SIZE (8 * 1024)

Definition at line 221 of file memutils.h.

Referenced by ReorderBufferAllocate().

◆ SLAB_LARGE_BLOCK_SIZE

#define SLAB_LARGE_BLOCK_SIZE (8 * 1024 * 1024)

Definition at line 222 of file memutils.h.

Referenced by ReorderBufferAllocate().

Function Documentation

◆ AllocSetContextCreateInternal()

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

Definition at line 396 of file aset.c.

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNK_FRACTION, ALLOC_CHUNK_LIMIT, ALLOC_CHUNKHDRSZ, AllocHugeSizeIsValid, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_SEPARATE_THRESHOLD, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MINSIZE, AllocSetMethods, AllocBlockData::aset, Assert, AllocBlockData::endptr, ereport, errcode(), errdetail(), errmsg(), ERROR, AllocSetFreeList::first_free, AllocSetContext::freelist, AllocSetContext::freeListIndex, AllocBlockData::freeptr, AllocSetContext::header, AllocSetContext::initBlockSize, malloc, Max, MAXALIGN, AllocSetContext::maxBlockSize, MemoryContextCreate(), MemoryContextStats(), MemSetAligned, name, AllocBlockData::next, MemoryContextData::nextchild, AllocSetFreeList::num_free, offsetof, AllocBlockData::prev, StaticAssertStmt, T_AllocSetContext, TopMemoryContext, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by GetMemoryChunkContext().

 {
     int         freeListIndex;
     Size        firstBlockSize;
     AllocSet    set;
     AllocBlock  block;
 
     /* Assert we padded AllocChunkData properly */
     StaticAssertStmt(ALLOC_CHUNKHDRSZ == MAXALIGN(ALLOC_CHUNKHDRSZ),
                      "sizeof(AllocChunkData) is not maxaligned");
     StaticAssertStmt(offsetof(AllocChunkData, aset) + sizeof(MemoryContext) ==
                      ALLOC_CHUNKHDRSZ,
                      "padding calculation in AllocChunkData is wrong");
 
     /*
      * First, validate allocation parameters.  Once these were regular runtime
      * test and elog's, but in practice Asserts seem sufficient because nobody
      * varies their parameters at runtime.  We somewhat arbitrarily enforce a
      * minimum 1K block size.
      */
     Assert(initBlockSize == MAXALIGN(initBlockSize) &&
            initBlockSize >= 1024);
     Assert(maxBlockSize == MAXALIGN(maxBlockSize) &&
            maxBlockSize >= initBlockSize &&
            AllocHugeSizeIsValid(maxBlockSize)); /* must be safe to double */
     Assert(minContextSize == 0 ||
            (minContextSize == MAXALIGN(minContextSize) &&
             minContextSize >= 1024 &&
             minContextSize <= maxBlockSize));
 
     /*
      * Check whether the parameters match either available freelist.  We do
      * not need to demand a match of maxBlockSize.
      */
     if (minContextSize == ALLOCSET_DEFAULT_MINSIZE &&
         initBlockSize == ALLOCSET_DEFAULT_INITSIZE)
         freeListIndex = 0;
     else if (minContextSize == ALLOCSET_SMALL_MINSIZE &&
              initBlockSize == ALLOCSET_SMALL_INITSIZE)
         freeListIndex = 1;
     else
         freeListIndex = -1;
 
     /*
      * If a suitable freelist entry exists, just recycle that context.
      */
     if (freeListIndex >= 0)
     {
         AllocSetFreeList *freelist = &context_freelists[freeListIndex];
 
         if (freelist->first_free != NULL)
         {
             /* Remove entry from freelist */
             set = freelist->first_free;
             freelist->first_free = (AllocSet) set->header.nextchild;
             freelist->num_free--;
 
             /* Update its maxBlockSize; everything else should be OK */
             set->maxBlockSize = maxBlockSize;
 
             /* Reinitialize its header, installing correct name and parent */
             MemoryContextCreate((MemoryContext) set,
                                 T_AllocSetContext,
                                 &AllocSetMethods,
                                 parent,
                                 name);
 
             ((MemoryContext) set)->mem_allocated =
                 set->keeper->endptr - ((char *) set);
 
             return (MemoryContext) set;
         }
     }
 
     /* Determine size of initial block */
     firstBlockSize = MAXALIGN(sizeof(AllocSetContext)) +
         ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
     if (minContextSize != 0)
         firstBlockSize = Max(firstBlockSize, minContextSize);
     else
         firstBlockSize = Max(firstBlockSize, initBlockSize);
 
     /*
      * Allocate the initial block.  Unlike other aset.c blocks, it starts with
      * the context header and its block header follows that.
      */
     set = (AllocSet) malloc(firstBlockSize);
     if (set == NULL)
     {
         if (TopMemoryContext)
             MemoryContextStats(TopMemoryContext);
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while creating memory context \"%s\".",
                            name)));
     }
 
     /*
      * Avoid writing code that can fail between here and MemoryContextCreate;
      * we'd leak the header/initial block if we ereport in this stretch.
      */
 
     /* Fill in the initial block's block header */
     block = (AllocBlock) (((char *) set) + MAXALIGN(sizeof(AllocSetContext)));
     block->aset = set;
     block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
     block->endptr = ((char *) set) + firstBlockSize;
     block->prev = NULL;
     block->next = NULL;
 
     /* Mark unallocated space NOACCESS; leave the block header alone. */
     VALGRIND_MAKE_MEM_NOACCESS(block->freeptr, block->endptr - block->freeptr);
 
     /* Remember block as part of block list */
     set->blocks = block;
     /* Mark block as not to be released at reset time */
     set->keeper = block;
 
     /* Finish filling in aset-specific parts of the context header */
     MemSetAligned(set->freelist, 0, sizeof(set->freelist));
 
     set->initBlockSize = initBlockSize;
     set->maxBlockSize = maxBlockSize;
     set->nextBlockSize = initBlockSize;
     set->freeListIndex = freeListIndex;
 
     /*
      * 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;
 
     /* Finally, do the type-independent part of context creation */
     MemoryContextCreate((MemoryContext) set,
                         T_AllocSetContext,
                         &AllocSetMethods,
                         parent,
                         name);
 
     ((MemoryContext) set)->mem_allocated = firstBlockSize;
 
     return (MemoryContext) set;
 }

◆ GenerationContextCreate()

MemoryContext GenerationContextCreate	(	MemoryContext	parent,
		const char *	name,
		Size	blockSize
	)

Definition at line 212 of file generation.c.

References AllocHugeSizeIsValid, GenerationContext::blockSize, dlist_init(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, Generation_CHUNKHDRSZ, malloc, MAXALIGN, MemoryContextCreate(), MemoryContextStats(), offsetof, StaticAssertStmt, T_GenerationContext, and TopMemoryContext.

Referenced by gistvacuumscan(), and ReorderBufferAllocate().

 {
     GenerationContext *set;
 
     /* Assert we padded GenerationChunk properly */
     StaticAssertStmt(Generation_CHUNKHDRSZ == MAXALIGN(Generation_CHUNKHDRSZ),
                      "sizeof(GenerationChunk) is not maxaligned");
     StaticAssertStmt(offsetof(GenerationChunk, context) + sizeof(MemoryContext) ==
                      Generation_CHUNKHDRSZ,
                      "padding calculation in GenerationChunk 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, mostly because
      * that's what AllocSet does.
      */
     if (blockSize != MAXALIGN(blockSize) ||
         blockSize < 1024 ||
         !AllocHugeSizeIsValid(blockSize))
         elog(ERROR, "invalid blockSize for memory context: %zu",
              blockSize);
 
     /*
      * Allocate the context header.  Unlike aset.c, we never try to combine
      * this with the first regular block, since that would prevent us from
      * freeing the first generation of allocations.
      */
 
     set = (GenerationContext *) malloc(MAXALIGN(sizeof(GenerationContext)));
     if (set == NULL)
     {
         MemoryContextStats(TopMemoryContext);
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while creating memory context \"%s\".",
                            name)));
     }
 
     /*
      * Avoid writing code that can fail between here and MemoryContextCreate;
      * we'd leak the header if we ereport in this stretch.
      */
 
     /* Fill in GenerationContext-specific header fields */
     set->blockSize = blockSize;
     set->block = NULL;
     dlist_init(&set->blocks);
 
     /* Finally, do the type-independent part of context creation */
     MemoryContextCreate((MemoryContext) set,
                         T_GenerationContext,
                         &GenerationMethods,
                         parent,
                         name);
 
     return (MemoryContext) set;
 }

◆ GetMemoryChunkContext()

static MemoryContext GetMemoryChunkContext ( void * pointer )

inlinestatic

Definition at line 113 of file memutils.h.

References AllocSetContextCreateInternal(), Assert, AssertArg, MAXALIGN, MemoryContextCreate(), MemoryContextIsValid, and name.

Referenced by create_unique_path(), enlarge_list(), GetMemoryChunkSpace(), list_delete_nth_cell(), mark_dummy_rel(), pfree(), repalloc(), repalloc_huge(), and reparameterize_path_by_child().

 {
     MemoryContext context;
 
     /*
      * Try to detect bogus pointers handed to us, poorly though we can.
      * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
      * allocated chunk.
      */
     Assert(pointer != NULL);
     Assert(pointer == (void *) MAXALIGN(pointer));
 
     /*
      * OK, it's probably safe to look at the context.
      */
     context = *(MemoryContext *) (((char *) pointer) - sizeof(void *));
 
     AssertArg(MemoryContextIsValid(context));
 
     return context;
 }

◆ GetMemoryChunkSpace()

Size GetMemoryChunkSpace ( void * pointer )

Definition at line 427 of file mcxt.c.

References MemoryContextMethods::get_chunk_space, GetMemoryChunkContext(), and MemoryContextData::methods.

Referenced by copytup_cluster(), copytup_heap(), free_sort_tuple(), getDatumCopy(), ginAllocEntryAccumulator(), ginCombineData(), ginInsertBAEntry(), grow_memtuples(), inittapestate(), intset_create(), intset_new_internal_node(), intset_new_leaf_node(), mergeruns(), readtup_heap(), tuplesort_begin_common(), tuplesort_putdatum(), tuplesort_putindextuplevalues(), tuplestore_begin_common(), tuplestore_clear(), tuplestore_puttupleslot(), tuplestore_putvalues(), tuplestore_trim(), writetup_cluster(), writetup_datum(), writetup_heap(), and writetup_index().

 {
     MemoryContext context = GetMemoryChunkContext(pointer);
 
     return context->methods->get_chunk_space(context, pointer);
 }

◆ MemoryContextAllowInCriticalSection()

void MemoryContextAllowInCriticalSection	(	MemoryContext	context,
		bool	allow
	)

Definition at line 411 of file mcxt.c.

References MemoryContextData::allowInCritSection, AssertArg, and MemoryContextIsValid.

Referenced by InitSync(), MemoryContextInit(), and XLOGShmemInit().

 {
     AssertArg(MemoryContextIsValid(context));
 
     context->allowInCritSection = allow;
 }

◆ MemoryContextContains()

bool MemoryContextContains	(	MemoryContext	context,
		void *	pointer
	)

Definition at line 691 of file mcxt.c.

References MAXALIGN.

Referenced by eval_windowfunction(), finalize_aggregate(), finalize_partialaggregate(), and finalize_windowaggregate().

 {
     MemoryContext ptr_context;
 
     /*
      * NB: Can't use GetMemoryChunkContext() here - that performs assertions
      * that aren't acceptable here since we might be passed memory not
      * allocated by any memory context.
      *
      * Try to detect bogus pointers handed to us, poorly though we can.
      * Presumably, a pointer that isn't MAXALIGNED isn't pointing at an
      * allocated chunk.
      */
     if (pointer == NULL || pointer != (void *) MAXALIGN(pointer))
         return false;
 
     /*
      * OK, it's probably safe to look at the context.
      */
     ptr_context = *(MemoryContext *) (((char *) pointer) - sizeof(void *));
 
     return ptr_context == context;
 }

◆ MemoryContextCreate()

void MemoryContextCreate	(	MemoryContext	node,
		NodeTag	tag,
		const MemoryContextMethods *	methods,
		MemoryContext	parent,
		const char *	name
	)

Definition at line 748 of file mcxt.c.

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

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

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

◆ MemoryContextDelete()

void MemoryContextDelete ( MemoryContext context )

Definition at line 211 of file mcxt.c.

References Assert, AssertArg, MemoryContextMethods::delete_context, MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextCallResetCallbacks(), MemoryContextDeleteChildren(), MemoryContextIsValid, MemoryContextSetParent(), MemoryContextData::methods, and VALGRIND_DESTROY_MEMPOOL.

Referenced by AfterTriggerEndXact(), afterTriggerInvokeEvents(), ApplyLauncherMain(), AtCleanup_Memory(), AtCommit_Memory(), AtEOSubXact_SPI(), AtEOXact_LargeObject(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AttachPartitionEnsureIndexes(), blbuild(), blinsert(), brin_free_desc(), bringetbitmap(), brininsert(), bt_check_every_level(), btendscan(), btree_xlog_cleanup(), btvacuumscan(), BuildParamLogString(), BuildRelationExtStatistics(), CloneRowTriggersToPartition(), cluster(), compile_plperl_function(), compile_pltcl_function(), compute_index_stats(), ComputeExtStatisticsRows(), CopyTo(), createTrgmNFA(), CreateTrigger(), decr_dcc_refcount(), DeleteExpandedObject(), DiscreteKnapsack(), do_analyze_rel(), do_start_bgworker(), do_start_worker(), DropCachedPlan(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), end_heap_rewrite(), EndCopy(), EventTriggerEndCompleteQuery(), EventTriggerInvoke(), exec_replication_command(), exec_simple_query(), ExecEndAgg(), ExecEndRecursiveUnion(), ExecEndSetOp(), ExecEndWindowAgg(), ExecHashTableDestroy(), execute_sql_string(), file_acquire_sample_rows(), fill_hba_view(), fmgr_sql(), free_plperl_function(), FreeCachedExpression(), FreeDecodingContext(), FreeExecutorState(), FreeExprContext(), freeGISTstate(), FreeSnapshotBuilder(), geqo_eval(), get_actual_variable_range(), gin_xlog_cleanup(), ginbuild(), ginbulkdelete(), ginendscan(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gist_xlog_cleanup(), gistbuild(), gistvacuumscan(), hash_destroy(), inline_function(), inline_set_returning_function(), libpqrcv_processTuples(), load_hba(), load_ident(), load_tzoffsets(), makeArrayResultArr(), makeMdArrayResult(), MemoryContextDeleteChildren(), mergeruns(), NIFinishBuild(), pg_decode_shutdown(), pgstat_clear_snapshot(), plperl_spi_freeplan(), plperl_spi_prepare(), plpgsql_free_function_memory(), pltcl_handler(), pltcl_SPI_prepare(), PLy_cursor_dealloc(), PLy_plan_dealloc(), PLy_pop_execution_context(), PLy_procedure_delete(), PLy_spi_execute_fetch_result(), PortalDrop(), PostgresMain(), printtup_shutdown(), publicationListToArray(), rebuild_database_list(), ReindexMultipleTables(), ReindexRelationConcurrently(), RelationBuildDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationDestroyRelation(), ReleaseCachedPlan(), ReorderBufferFree(), ResetUnloggedRelations(), RevalidateCachedQuery(), shutdown_MultiFuncCall(), spg_xlog_cleanup(), spgbuild(), spgendscan(), spginsert(), SPI_finish(), SPI_freeplan(), SPI_freetuptable(), StartChildProcess(), strlist_to_textarray(), test_pattern(), tokenize_inc_file(), tuplesort_end(), union_tuples(), vacuum(), and validateForeignKeyConstraint().

 {
     AssertArg(MemoryContextIsValid(context));
     /* We had better not be deleting TopMemoryContext ... */
     Assert(context != TopMemoryContext);
     /* And not CurrentMemoryContext, either */
     Assert(context != CurrentMemoryContext);
 
     /* save a function call in common case where there are no children */
     if (context->firstchild != NULL)
         MemoryContextDeleteChildren(context);
 
     /*
      * It's not entirely clear whether 'tis better to do this before or after
      * delinking the context; but an error in a callback will likely result in
      * leaking the whole context (if it's not a root context) if we do it
      * after, so let's do it before.
      */
     MemoryContextCallResetCallbacks(context);
 
     /*
      * We delink the context from its parent before deleting it, so that if
      * there's an error we won't have deleted/busted contexts still attached
      * to the context tree.  Better a leak than a crash.
      */
     MemoryContextSetParent(context, NULL);
 
     /*
      * Also reset the context's ident pointer, in case it points into the
      * context.  This would only matter if someone tries to get stats on the
      * (already unlinked) context, which is unlikely, but let's be safe.
      */
     context->ident = NULL;
 
     context->methods->delete_context(context);
 
     VALGRIND_DESTROY_MEMPOOL(context);
 }

◆ MemoryContextDeleteChildren()

void MemoryContextDeleteChildren ( MemoryContext context )

Definition at line 256 of file mcxt.c.

References AssertArg, MemoryContextData::firstchild, MemoryContextDelete(), and MemoryContextIsValid.

Referenced by AtAbort_Portals(), AtSubAbort_Portals(), exec_stmt_block(), MemoryContextDelete(), MemoryContextReset(), PersistHoldablePortal(), PortalRunMulti(), and RelationClose().

 {
     AssertArg(MemoryContextIsValid(context));
 
     /*
      * MemoryContextDelete will delink the child from me, so just iterate as
      * long as there is a child.
      */
     while (context->firstchild != NULL)
         MemoryContextDelete(context->firstchild);
 }

◆ MemoryContextGetParent()

MemoryContext MemoryContextGetParent ( MemoryContext context )

Definition at line 439 of file mcxt.c.

References AssertArg, MemoryContextIsValid, and MemoryContextData::parent.

Referenced by advance_windowaggregate(), advance_windowaggregate_base(), ExecAggTransReparent(), GetCachedPlan(), pop_stmt_mcontext(), and push_stmt_mcontext().

 {
     AssertArg(MemoryContextIsValid(context));
 
     return context->parent;
 }

◆ MemoryContextInit()

void MemoryContextInit ( void )

Definition at line 92 of file mcxt.c.

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, AssertState, MemoryContextAllowInCriticalSection(), and TopMemoryContext.

Referenced by main().

 {
     AssertState(TopMemoryContext == NULL);
 
     /*
      * First, initialize TopMemoryContext, which is the parent of all others.
      */
     TopMemoryContext = AllocSetContextCreate((MemoryContext) NULL,
                                              "TopMemoryContext",
                                              ALLOCSET_DEFAULT_SIZES);
 
     /*
      * Not having any other place to point CurrentMemoryContext, make it point
      * to TopMemoryContext.  Caller should change this soon!
      */
     CurrentMemoryContext = TopMemoryContext;
 
     /*
      * Initialize ErrorContext as an AllocSetContext with slow growth rate ---
      * we don't really expect much to be allocated in it. More to the point,
      * require it to contain at least 8K at all times. This is the only case
      * where retained memory in a context is *essential* --- we want to be
      * sure ErrorContext still has some memory even if we've run out
      * elsewhere! Also, allow allocations in ErrorContext within a critical
      * section. Otherwise a PANIC will cause an assertion failure in the error
      * reporting code, before printing out the real cause of the failure.
      *
      * This should be the last step in this function, as elog.c assumes memory
      * management works once ErrorContext is non-null.
      */
     ErrorContext = AllocSetContextCreate(TopMemoryContext,
                                          "ErrorContext",
                                          8 * 1024,
                                          8 * 1024,
                                          8 * 1024);
     MemoryContextAllowInCriticalSection(ErrorContext, true);
 }

◆ MemoryContextIsEmpty()

bool MemoryContextIsEmpty ( MemoryContext context )

Definition at line 451 of file mcxt.c.

References AssertArg, MemoryContextData::firstchild, MemoryContextMethods::is_empty, MemoryContextIsValid, and MemoryContextData::methods.

Referenced by AtSubCommit_Memory().

 {
     AssertArg(MemoryContextIsValid(context));
 
     /*
      * For now, we consider a memory context nonempty if it has any children;
      * perhaps this should be changed later.
      */
     if (context->firstchild != NULL)
         return false;
     /* Otherwise use the type-specific inquiry */
     return context->methods->is_empty(context);
 }

◆ MemoryContextMemAllocated()

Size MemoryContextMemAllocated	(	MemoryContext	context,
		bool	recurse
	)

Definition at line 470 of file mcxt.c.

References AssertArg, MemoryContextData::firstchild, MemoryContextData::mem_allocated, MemoryContextIsValid, MemoryContextMemAllocated(), and MemoryContextData::nextchild.

Referenced by hash_agg_check_limits(), hash_agg_update_metrics(), and MemoryContextMemAllocated().

 {
     Size    total = context->mem_allocated;
 
     AssertArg(MemoryContextIsValid(context));
 
     if (recurse)
     {
         MemoryContext child = context->firstchild;
 
         for (child = context->firstchild;
              child != NULL;
              child = child->nextchild)
             total += MemoryContextMemAllocated(child, true);
     }
 
     return total;
 }

◆ MemoryContextReset()

void MemoryContextReset ( MemoryContext context )

Definition at line 136 of file mcxt.c.

References AssertArg, MemoryContextData::firstchild, MemoryContextData::isReset, MemoryContextDeleteChildren(), MemoryContextIsValid, and MemoryContextResetOnly().

Referenced by _bt_preprocess_array_keys(), AfterTriggerExecute(), bloomBuildCallback(), brin_memtuple_initialize(), bt_check_level_from_leftmost(), btree_redo(), btvacuumpage(), buildSubPlanHash(), check_domain_for_new_field(), check_domain_for_new_tuple(), CloneRowTriggersToPartition(), CopyOneRowTo(), CreateTrigger(), dumptuples(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), elements_worker_jsonb(), errstart(), EventTriggerInvoke(), exec_dynquery_with_params(), exec_stmt_block(), exec_stmt_dynexecute(), exec_stmt_forc(), exec_stmt_foreach_a(), exec_stmt_open(), exec_stmt_raise(), ExecFindInitialMatchingSubPlans(), ExecFindMatchingSubPlans(), ExecHashTableReset(), ExecMakeTableFunctionResult(), ExecProjectSet(), ExecQualAndReset(), ExecRecursiveUnion(), execTuplesUnequal(), execute_foreign_modify(), expanded_record_set_field_internal(), expanded_record_set_tuple(), fetch_more_data(), file_acquire_sample_rows(), get_short_term_cxt(), gin_redo(), ginBuildCallback(), ginHeapTupleBulkInsert(), ginInsertCleanup(), ginVacuumPostingTreeLeaves(), gist_redo(), gistBuildCallback(), gistgetbitmap(), gistgettuple(), gistinsert(), gistProcessEmptyingQueue(), gistrescan(), gistScanPage(), HandleParallelMessages(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), keyGetItem(), libpqrcv_processTuples(), LogicalRepApplyLoop(), lookup_ts_dictionary_cache(), make_tuple_from_result_row(), pg_decode_change(), pg_decode_truncate(), pgoutput_change(), pgoutput_truncate(), plperl_return_next_internal(), PLy_input_convert(), PLy_input_from_tuple(), printtup(), printtup_20(), printtup_internal_20(), process_ordered_aggregate_single(), ReScanExprContext(), resetSpGistScanOpaque(), scanPendingInsert(), sepgsql_avc_reset(), spg_redo(), spginsert(), spgistBuildCallback(), spgWalk(), startScanKey(), storeRow(), tfuncFetchRows(), tfuncLoadRows(), and validateForeignKeyConstraint().

 {
     AssertArg(MemoryContextIsValid(context));
 
     /* save a function call in common case where there are no children */
     if (context->firstchild != NULL)
         MemoryContextDeleteChildren(context);
 
     /* save a function call if no pallocs since startup or last reset */
     if (!context->isReset)
         MemoryContextResetOnly(context);
 }

◆ MemoryContextResetChildren()

void MemoryContextResetChildren ( MemoryContext context )

Definition at line 188 of file mcxt.c.

References AssertArg, MemoryContextData::firstchild, MemoryContextIsValid, MemoryContextResetChildren(), MemoryContextResetOnly(), and MemoryContextData::nextchild.

Referenced by MemoryContextResetChildren().

 {
     MemoryContext child;
 
     AssertArg(MemoryContextIsValid(context));
 
     for (child = context->firstchild; child != NULL; child = child->nextchild)
     {
         MemoryContextResetChildren(child);
         MemoryContextResetOnly(child);
     }
 }

◆ MemoryContextResetOnly()

void MemoryContextResetOnly ( MemoryContext context )

Definition at line 155 of file mcxt.c.

References AssertArg, MemoryContextData::isReset, MemoryContextCallResetCallbacks(), MemoryContextIsValid, MemoryContextData::methods, MemoryContextMethods::reset, VALGRIND_CREATE_MEMPOOL, and VALGRIND_DESTROY_MEMPOOL.

Referenced by AllocSetDelete(), MemoryContextReset(), and MemoryContextResetChildren().

 {
     AssertArg(MemoryContextIsValid(context));
 
     /* Nothing to do if no pallocs since startup or last reset */
     if (!context->isReset)
     {
         MemoryContextCallResetCallbacks(context);
 
         /*
          * If context->ident points into the context's memory, it will become
          * a dangling pointer.  We could prevent that by setting it to NULL
          * here, but that would break valid coding patterns that keep the
          * ident elsewhere, e.g. in a parent context.  Another idea is to use
          * MemoryContextContains(), but we don't require ident strings to be
          * in separately-palloc'd chunks, so that risks false positives.  So
          * for now we assume the programmer got it right.
          */
 
         context->methods->reset(context);
         context->isReset = true;
         VALGRIND_DESTROY_MEMPOOL(context);
         VALGRIND_CREATE_MEMPOOL(context, 0, false);
     }
 }

◆ MemoryContextSetIdentifier()

void MemoryContextSetIdentifier	(	MemoryContext	context,
		const char *	id
	)

Definition at line 329 of file mcxt.c.

References AssertArg, MemoryContextData::ident, and MemoryContextIsValid.

Referenced by compile_plperl_function(), compile_pltcl_function(), CopyCachedPlan(), CreateCachedPlan(), CreatePortal(), do_compile(), hash_create(), init_sql_fcache(), lookup_ts_dictionary_cache(), PLy_procedure_create(), and test_pattern().

 {
     AssertArg(MemoryContextIsValid(context));
     context->ident = id;
 }

◆ MemoryContextSetParent()

void MemoryContextSetParent	(	MemoryContext	context,
		MemoryContext	new_parent
	)

Definition at line 354 of file mcxt.c.

References Assert, AssertArg, MemoryContextData::firstchild, MemoryContextIsValid, MemoryContextData::nextchild, MemoryContextData::parent, and MemoryContextData::prevchild.

Referenced by _SPI_save_plan(), CachedPlanSetParentContext(), CompleteCachedPlan(), exec_parse_message(), GetCachedExpression(), GetCachedPlan(), load_domaintype_info(), MemoryContextDelete(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationClearRelation(), RevalidateCachedQuery(), SaveCachedPlan(), SPI_keepplan(), and TransferExpandedObject().

 {
     AssertArg(MemoryContextIsValid(context));
     AssertArg(context != new_parent);
 
     /* Fast path if it's got correct parent already */
     if (new_parent == context->parent)
         return;
 
     /* Delink from existing parent, if any */
     if (context->parent)
     {
         MemoryContext parent = context->parent;
 
         if (context->prevchild != NULL)
             context->prevchild->nextchild = context->nextchild;
         else
         {
             Assert(parent->firstchild == context);
             parent->firstchild = context->nextchild;
         }
 
         if (context->nextchild != NULL)
             context->nextchild->prevchild = context->prevchild;
     }
 
     /* And relink */
     if (new_parent)
     {
         AssertArg(MemoryContextIsValid(new_parent));
         context->parent = new_parent;
         context->prevchild = NULL;
         context->nextchild = new_parent->firstchild;
         if (new_parent->firstchild != NULL)
             new_parent->firstchild->prevchild = context;
         new_parent->firstchild = context;
     }
     else
     {
         context->parent = NULL;
         context->prevchild = NULL;
         context->nextchild = NULL;
     }
 }

◆ MemoryContextStats()

void MemoryContextStats ( MemoryContext context )

Definition at line 498 of file mcxt.c.

References MemoryContextStatsDetail().

Referenced by AllocSetContextCreateInternal(), finish_xact_command(), GenerationContextCreate(), MemoryContextAlloc(), MemoryContextAllocExtended(), MemoryContextAllocHuge(), MemoryContextAllocZero(), MemoryContextAllocZeroAligned(), palloc(), palloc0(), palloc_extended(), repalloc(), repalloc_huge(), SlabContextCreate(), and test_pattern().

 {
     /* A hard-wired limit on the number of children is usually good enough */
     MemoryContextStatsDetail(context, 100);
 }

◆ MemoryContextStatsDetail()

void MemoryContextStatsDetail	(	MemoryContext	context,
		int	max_children
	)

Definition at line 510 of file mcxt.c.

References fprintf, MemoryContextCounters::freechunks, MemoryContextCounters::freespace, MemoryContextStatsInternal(), MemoryContextCounters::nblocks, and MemoryContextCounters::totalspace.

Referenced by MemoryContextStats().

 {
     MemoryContextCounters grand_totals;
 
     memset(&grand_totals, 0, sizeof(grand_totals));
 
     MemoryContextStatsInternal(context, 0, true, max_children, &grand_totals);
 
     fprintf(stderr,
             "Grand total: %zu bytes in %zd blocks; %zu free (%zd chunks); %zu used\n",
             grand_totals.totalspace, grand_totals.nblocks,
             grand_totals.freespace, grand_totals.freechunks,
             grand_totals.totalspace - grand_totals.freespace);
 }

◆ SlabContextCreate()

MemoryContext SlabContextCreate	(	MemoryContext	parent,
		const char *	name,
		Size	blockSize,
		Size	chunkSize
	)

Definition at line 190 of file slab.c.

References SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, dlist_init(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, SlabContext::freelist, SlabContext::fullChunkSize, SlabContext::headerSize, i, malloc, MAXALIGN, MemoryContextCreate(), MemoryContextStats(), offsetof, StaticAssertStmt, T_SlabContext, and TopMemoryContext.

Referenced by ReorderBufferAllocate().

 {
     int         chunksPerBlock;
     Size        fullChunkSize;
     Size        freelistSize;
     Size        headerSize;
     SlabContext *slab;
     int         i;
 
     /* Assert we padded SlabChunk properly */
     StaticAssertStmt(sizeof(SlabChunk) == MAXALIGN(sizeof(SlabChunk)),
                      "sizeof(SlabChunk) is not maxaligned");
     StaticAssertStmt(offsetof(SlabChunk, slab) + sizeof(MemoryContext) ==
                      sizeof(SlabChunk),
                      "padding calculation in SlabChunk is wrong");
 
     /* Make sure the linked list node fits inside a freed chunk */
     if (chunkSize < sizeof(int))
         chunkSize = sizeof(int);
 
     /* chunk, including SLAB header (both addresses nicely aligned) */
     fullChunkSize = sizeof(SlabChunk) + MAXALIGN(chunkSize);
 
     /* Make sure the block can store at least one chunk. */
     if (blockSize < fullChunkSize + sizeof(SlabBlock))
         elog(ERROR, "block size %zu for slab is too small for %zu chunks",
              blockSize, chunkSize);
 
     /* Compute maximum number of chunks per block */
     chunksPerBlock = (blockSize - sizeof(SlabBlock)) / fullChunkSize;
 
     /* The freelist starts with 0, ends with chunksPerBlock. */
     freelistSize = sizeof(dlist_head) * (chunksPerBlock + 1);
 
     /*
      * Allocate the context header.  Unlike aset.c, we never try to combine
      * this with the first regular block; not worth the extra complication.
      */
 
     /* Size of the memory context header */
     headerSize = offsetof(SlabContext, freelist) + freelistSize;
 
 #ifdef MEMORY_CONTEXT_CHECKING
     /*
      * With memory checking, we need to allocate extra space for the bitmap
      * of free chunks. The bitmap is an array of bools, so we don't need to
      * worry about alignment.
      */
     headerSize += chunksPerBlock * sizeof(bool);
 #endif
 
     slab = (SlabContext *) malloc(headerSize);
     if (slab == NULL)
     {
         MemoryContextStats(TopMemoryContext);
         ereport(ERROR,
                 (errcode(ERRCODE_OUT_OF_MEMORY),
                  errmsg("out of memory"),
                  errdetail("Failed while creating memory context \"%s\".",
                            name)));
     }
 
     /*
      * Avoid writing code that can fail between here and MemoryContextCreate;
      * we'd leak the header if we ereport in this stretch.
      */
 
     /* Fill in SlabContext-specific header fields */
     slab->chunkSize = chunkSize;
     slab->fullChunkSize = fullChunkSize;
     slab->blockSize = blockSize;
     slab->headerSize = headerSize;
     slab->chunksPerBlock = chunksPerBlock;
     slab->minFreeChunks = 0;
     slab->nblocks = 0;
 
     /* initialize the freelist slots */
     for (i = 0; i < (slab->chunksPerBlock + 1); i++)
         dlist_init(&slab->freelist[i]);
 
 #ifdef MEMORY_CONTEXT_CHECKING
     /* set the freechunks pointer right after the freelists array */
     slab->freechunks
         = (bool *) slab + offsetof(SlabContext, freelist) + freelistSize;
 #endif
 
     /* Finally, do the type-independent part of context creation */
     MemoryContextCreate((MemoryContext) slab,
                         T_SlabContext,
                         &SlabMethods,
                         parent,
                         name);
 
     return (MemoryContext) slab;
 }

Variable Documentation

◆ CacheMemoryContext

PGDLLIMPORT MemoryContext CacheMemoryContext

Definition at line 47 of file mcxt.c.

Referenced by _SPI_save_plan(), AllocateRelationDesc(), assign_record_type_typmod(), AttrDefaultFetch(), BuildEventTriggerCache(), BuildHardcodedDescriptor(), CatalogCacheCreateEntry(), CatalogCacheInitializeCache(), CheckConstraintFetch(), CreateCacheMemoryContext(), ensure_record_cache_typmod_slot_exists(), generate_partition_qual(), get_attribute_options(), get_rel_sync_entry(), get_tablespace(), GetCachedExpression(), GetCachedPlan(), GetConnection(), GetFdwRoutineForRelation(), GetRelationPublicationActions(), init_ts_config_cache(), InitCatCache(), InitializeAttoptCache(), InitializeRelfilenodeMap(), InitializeTableSpaceCache(), load_domaintype_info(), load_enum_cache_data(), load_rangetype_info(), load_relcache_init_file(), logicalrep_relmap_init(), lookup_ts_config_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), pgoutput_startup(), process_syncing_tables_for_apply(), register_on_commit_action(), RehashCatCache(), RelationBuildLocalRelation(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), RelationGetFKeyList(), RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetStatExtList(), RelationInitIndexAccessInfo(), RelationParseRelOptions(), RememberToFreeTupleDescAtEOX(), SaveCachedPlan(), SearchCatCacheList(), and SPI_keepplan().

◆ CurTransactionContext

◆ ErrorContext

PGDLLIMPORT MemoryContext ErrorContext

Definition at line 45 of file mcxt.c.

Referenced by CopyErrorData(), errfinish(), errstart(), FlushErrorState(), format_elog_string(), and ReThrowError().

◆ MessageContext

PGDLLIMPORT MemoryContext MessageContext

Definition at line 48 of file mcxt.c.

Referenced by exec_bind_message(), exec_describe_portal_message(), exec_describe_statement_message(), exec_parse_message(), exec_simple_query(), and PostgresMain().

◆ PortalContext

PGDLLIMPORT MemoryContext PortalContext

Definition at line 53 of file mcxt.c.

Referenced by cluster(), do_autovacuum(), perform_work_item(), PersistHoldablePortal(), PLy_push_execution_context(), PortalRun(), PortalRunFetch(), PortalStart(), ReindexMultipleTables(), ReindexRelationConcurrently(), SPI_connect_ext(), and vacuum().

◆ PostmasterContext

PGDLLIMPORT MemoryContext PostmasterContext

Definition at line 46 of file mcxt.c.

Referenced by do_start_bgworker(), load_hba(), load_ident(), PerformAuthentication(), PostgresMain(), PostmasterMain(), and StartChildProcess().

◆ TopMemoryContext

PGDLLIMPORT MemoryContext TopMemoryContext

Definition at line 44 of file mcxt.c.

Referenced by _PG_init(), add_reloption(), add_string_reloption(), allocate_reloption(), AllocateAttribute(), AllocSetContextCreateInternal(), ApplyLauncherMain(), ApplyWorkerMain(), AtAbort_Memory(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AttachSession(), AutoVacLauncherMain(), BackendRun(), BackgroundWriterMain(), be_tls_open_server(), cache_single_string(), check_foreign_key(), check_primary_key(), CheckpointerMain(), CheckSCRAMAuth(), compile_plperl_function(), compile_pltcl_function(), ConditionVariablePrepareToSleep(), CreateCacheMemoryContext(), dblink_connect(), dblink_init(), DCH_cache_getnew(), do_autovacuum(), do_compile(), do_start_bgworker(), dsm_create_descriptor(), dsm_impl_sysv(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), Exec_ListenCommit(), executeDateTimeMethod(), find_plan(), finish_xact_command(), GenerationContextCreate(), get_tabstat_entry(), GetLocalBufferStorage(), GetLockConflicts(), GetSessionDsmHandle(), HandleParallelMessages(), hash_create(), InitDeadLockChecking(), initialize_reloptions(), InitializeClientEncoding(), InitializeParallelDSM(), InitializeSearchPath(), InitializeSession(), InitSync(), InitXLogInsert(), llvm_compile_module(), llvm_create_context(), llvm_session_initialize(), LockAcquireExtended(), LogicalRepApplyLoop(), mdinit(), MemoryContextInit(), mxid_to_string(), NUM_cache_getnew(), on_dsm_detach(), PageSetChecksumCopy(), ParallelWorkerMain(), PerformAuthentication(), pg_newlocale_from_collation(), pg_start_backup(), pgstat_setup_memcxt(), plperl_spi_prepare(), plpgsql_estate_setup(), plpython_inline_handler(), pltcl_SPI_prepare(), PLy_cursor_plan(), PLy_cursor_query(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), PostgresMain(), PostmasterMain(), pq_init(), PrepareClientEncoding(), ProcessStartupPacket(), PushOverrideSearchPath(), px_find_cipher(), px_find_digest(), recomputeNamespacePath(), register_label_provider(), RegisterLWLockTranches(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), regress_putenv(), RelationCreateStorage(), RelationDropStorage(), RequestNamedLWLockTranche(), ResourceArrayEnlarge(), ResourceOwnerCreate(), RestoreReindexState(), ri_HashCompareOp(), roles_has_privs_of(), roles_is_member_of(), sepgsql_avc_init(), sepgsql_xact_callback(), SetDatabasePath(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), SlabContextCreate(), SPI_connect_ext(), StartChildProcess(), WalWriterMain(), XLOGShmemInit(), and xml_is_document().

◆ TopTransactionContext

PGDLLIMPORT MemoryContext TopTransactionContext

Definition at line 49 of file mcxt.c.

Referenced by add_tabstat_xact_level(), afterTriggerAddEvent(), AfterTriggerBeginSubXact(), AfterTriggerEnlargeQueryState(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCommit_childXids(), BeginInternalSubTransaction(), CopySnapshot(), CreateParallelContext(), DefineSavepoint(), ExportSnapshot(), get_tabstat_stack_level(), GetComboCommandId(), init_enum_blacklist(), InitializeParallelDSM(), LaunchParallelWorkers(), logicalrep_worker_stop_at_commit(), make_tuple_indirect(), mXactCachePut(), plpgsql_create_econtext(), PLy_get_scratch_context(), PLy_push_execution_context(), PLy_subtransaction_enter(), PortalRun(), PrepareInvalidationState(), PrepareTempTablespaces(), PrepareTransactionBlock(), push_old_value(), PushActiveSnapshot(), PushTransaction(), queue_listen(), RestoreSnapshot(), SetConstraintStateCreate(), setup_background_workers(), and SPI_connect_ext().

Variables
PGDLLIMPORT MemoryContext	TopMemoryContext

PGDLLIMPORT MemoryContext	ErrorContext

PGDLLIMPORT MemoryContext	PostmasterContext

PGDLLIMPORT MemoryContext	CacheMemoryContext

PGDLLIMPORT MemoryContext	MessageContext

PGDLLIMPORT MemoryContext	TopTransactionContext

PGDLLIMPORT MemoryContext	CurTransactionContext

PGDLLIMPORT MemoryContext	PortalContext

Macros

Functions

Variables

Macro Definition Documentation

◆ AllocHugeSizeIsValid

◆ ALLOCSET_DEFAULT_INITSIZE

◆ ALLOCSET_DEFAULT_MAXSIZE

◆ ALLOCSET_DEFAULT_MINSIZE

◆ ALLOCSET_DEFAULT_SIZES

◆ ALLOCSET_SEPARATE_THRESHOLD

◆ ALLOCSET_SMALL_INITSIZE

◆ ALLOCSET_SMALL_MAXSIZE

◆ ALLOCSET_SMALL_MINSIZE

◆ ALLOCSET_SMALL_SIZES

◆ ALLOCSET_START_SMALL_SIZES

◆ AllocSetContextCreate

◆ AllocSizeIsValid

◆ MaxAllocHugeSize

◆ MaxAllocSize

◆ MemoryContextCopyAndSetIdentifier

◆ MemoryContextResetAndDeleteChildren

◆ SLAB_DEFAULT_BLOCK_SIZE

◆ SLAB_LARGE_BLOCK_SIZE

Function Documentation

◆ AllocSetContextCreateInternal()

◆ GenerationContextCreate()

◆ GetMemoryChunkContext()

◆ GetMemoryChunkSpace()

◆ MemoryContextAllowInCriticalSection()

◆ MemoryContextContains()

◆ MemoryContextCreate()

◆ MemoryContextDelete()

◆ MemoryContextDeleteChildren()

◆ MemoryContextGetParent()

◆ MemoryContextInit()

◆ MemoryContextIsEmpty()

◆ MemoryContextMemAllocated()

◆ MemoryContextReset()

◆ MemoryContextResetChildren()

◆ MemoryContextResetOnly()

◆ MemoryContextSetIdentifier()

◆ MemoryContextSetParent()

◆ MemoryContextStats()

◆ MemoryContextStatsDetail()

◆ SlabContextCreate()

Variable Documentation

◆ CacheMemoryContext

◆ CurTransactionContext

◆ ErrorContext

◆ MessageContext

◆ PortalContext

◆ PostmasterContext

◆ TopMemoryContext

◆ TopTransactionContext