#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) -1 >> 1) /* SIZE_MAX / 2 */

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

#define	MemoryContextResetAndDeleteChildren(ctx) MemoryContextReset(ctx)

#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	MemoryContextSetParent (MemoryContext context, MemoryContext new_parent)

Size	GetMemoryChunkSpace (void *pointer)

MemoryContext	MemoryContextGetParent (MemoryContext context)

bool	MemoryContextIsEmpty (MemoryContext context)

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)

MemoryContext	MemoryContextCreate (NodeTag tag, Size size, MemoryContextMethods methods, MemoryContext parent, const char name)

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

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

Macro Definition Documentation

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

Definition at line 46 of file memutils.h.

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

#define ALLOCSET_DEFAULT_INITSIZE (8 * 1024)

Definition at line 163 of file memutils.h.

Referenced by ApplyLauncherMain(), bt_check_every_level(), get_agg_clause_costs_walker(), pgoutput_startup(), and publicationListToArray().

#define ALLOCSET_DEFAULT_MAXSIZE (8 * 1024 * 1024)

Definition at line 164 of file memutils.h.

Referenced by ApplyLauncherMain(), bt_check_every_level(), pgoutput_startup(), and publicationListToArray().

#define ALLOCSET_DEFAULT_MINSIZE 0

Definition at line 162 of file memutils.h.

Referenced by ApplyLauncherMain(), bt_check_every_level(), pgoutput_startup(), and publicationListToArray().

#define ALLOCSET_DEFAULT_SIZES ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 165 of file memutils.h.

Referenced by afterTriggerAddEvent(), afterTriggerInvokeEvents(), AllocateSnapshotBuilder(), ApplyWorkerMain(), AtStart_Memory(), AtSubStart_Memory(), AutoVacLauncherMain(), BackgroundWriterMain(), begin_heap_rewrite(), BeginCopy(), blbuild(), blinsert(), brin_new_memtuple(), bringetbitmap(), brininsert(), btvacuumscan(), BuildEventTriggerCache(), BuildRelationExtStatistics(), CheckpointerMain(), cluster(), compute_index_stats(), 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(), ExecHashTableCreate(), ExecInitFunctionScan(), ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), ExecInitTableFuncScan(), ExecInitUnique(), ExecInitWindowAgg(), file_acquire_sample_rows(), geqo_eval(), 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(), InitXLogInsert(), inline_function(), inline_set_returning_function(), libpqrcv_processTuples(), logicalrep_relmap_init(), LogicalRepApplyLoop(), materializeQueryResult(), mdinit(), MemoryContextInit(), NIStartBuild(), ParallelWorkerMain(), PerformAuthentication(), pg_decode_startup(), plperl_return_next(), 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(), PLyObject_ToComposite(), PLyString_ToComposite(), PortalCreateHoldStore(), postgresBeginForeignScan(), PostgresMain(), PostmasterMain(), printtup_startup(), rebuild_database_list(), RelationBuildPartitionDesc(), ReorderBufferAllocate(), ResetUnloggedRelations(), sepgsql_avc_init(), spg_xlog_startup(), spgbeginscan(), spgbuild(), spginsert(), SPI_connect(), spi_dest_startup(), StartupDecodingContext(), strlist_to_textarray(), tqueueReceiveSlot(), tuplesort_begin_common(), union_tuples(), vacuum(), WalWriterMain(), and XLOGShmemInit().

#define ALLOCSET_SEPARATE_THRESHOLD 8192

Definition at line 192 of file memutils.h.

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

#define ALLOCSET_SMALL_INITSIZE (1 * 1024)

Definition at line 173 of file memutils.h.

Referenced by DiscreteKnapsack(), and get_agg_clause_costs_walker().

#define ALLOCSET_SMALL_MAXSIZE (8 * 1024)

Definition at line 174 of file memutils.h.

Referenced by DiscreteKnapsack().

#define ALLOCSET_SMALL_MINSIZE 0

Definition at line 172 of file memutils.h.

Referenced by DiscreteKnapsack().

#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

Definition at line 182 of file memutils.h.

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

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

Definition at line 42 of file memutils.h.

Referenced by 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().

#define MaxAllocHugeSize ((Size) -1 >> 1) /* SIZE_MAX / 2 */

Definition at line 44 of file memutils.h.

Referenced by grow_memtuples(), and qtext_load_file().

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

#define MemoryContextResetAndDeleteChildren ( ctx ) MemoryContextReset(ctx)

#define SLAB_DEFAULT_BLOCK_SIZE (8 * 1024)

Definition at line 194 of file memutils.h.

Referenced by ReorderBufferAllocate().

#define SLAB_LARGE_BLOCK_SIZE (8 * 1024 * 1024)

Definition at line 195 of file memutils.h.

Function Documentation

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, NULL, 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(), 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(), tqueueReceiveSlot(), 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 MemoryContext GetMemoryChunkContext ( void * pointer )

inlinestatic

Definition at line 107 of file memutils.h.

References Assert, AssertArg, MAXALIGN, MemoryContextIsValid, and NULL.

Referenced by GetMemoryChunkSpace(), mark_dummy_rel(), pfree(), repalloc(), and repalloc_huge().

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

Size GetMemoryChunkSpace ( void * pointer )

Definition at line 390 of file mcxt.c.

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

Referenced by copytup_cluster(), copytup_heap(), copytup_index(), free_sort_tuple(), getDatumCopy(), ginAllocEntryAccumulator(), ginCombineData(), ginInsertBAEntry(), grow_memtuples(), inittapes(), 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);
 }

void MemoryContextAllowInCriticalSection	(	MemoryContext	context,
		bool	allow
	)

Definition at line 374 of file mcxt.c.

References MemoryContextData::allowInCritSection, AssertArg, and MemoryContextIsValid.

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

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

bool MemoryContextContains	(	MemoryContext	context,
		void *	pointer
	)

Definition at line 567 of file mcxt.c.

References MAXALIGN, and NULL.

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;
 }

MemoryContext MemoryContextCreate	(	NodeTag	tag,
		Size	size,
		MemoryContextMethods *	methods,
		MemoryContext	parent,
		const char *	name
	)

Definition at line 640 of file mcxt.c.

References MemoryContextData::allowInCritSection, Assert, CritSectionCount, MemoryContextData::firstchild, MemoryContextMethods::init, MemoryContextData::isReset, malloc, MemoryContextAlloc(), MemSet, MemoryContextData::methods, MemoryContextData::name, MemoryContextData::nextchild, NULL, MemoryContextData::parent, MemoryContextData::prevchild, MemoryContextData::type, and VALGRIND_CREATE_MEMPOOL.

Referenced by AllocSetContextCreate(), and SlabContextCreate().

 {
     MemoryContext node;
     Size        needed = size + strlen(name) + 1;
 
     /* creating new memory contexts is not allowed in a critical section */
     Assert(CritSectionCount == 0);
 
     /* Get space for node and name */
     if (TopMemoryContext != NULL)
     {
         /* Normal case: allocate the node in TopMemoryContext */
         node = (MemoryContext) MemoryContextAlloc(TopMemoryContext,
                                                   needed);
     }
     else
     {
         /* Special case for startup: use good ol' malloc */
         node = (MemoryContext) malloc(needed);
         Assert(node != NULL);
     }
 
     /* Initialize the node as best we can */
     MemSet(node, 0, size);
     node->type = tag;
     node->methods = methods;
     node->parent = NULL;        /* for the moment */
     node->firstchild = NULL;
     node->prevchild = NULL;
     node->nextchild = NULL;
     node->isReset = true;
     node->name = ((char *) node) + size;
     strcpy(node->name, name);
 
     /* Type-specific routine finishes any other essential initialization */
     (*node->methods->init) (node);
 
     /* OK to link node to parent (if any) */
     /* Could use MemoryContextSetParent here, but doesn't seem worthwhile */
     if (parent)
     {
         node->parent = 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;
     }
 
     VALGRIND_CREATE_MEMPOOL(node, 0, false);
 
     /* Return to type-specific creation routine to finish up */
     return node;
 }

void MemoryContextDelete ( MemoryContext context )

Definition at line 200 of file mcxt.c.

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

Referenced by AfterTriggerEndXact(), afterTriggerInvokeEvents(), ApplyLauncherMain(), AtCleanup_Memory(), AtCommit_Memory(), AtEOSubXact_SPI(), AtEOXact_LargeObject(), AtSubCleanup_Memory(), AtSubCommit_Memory(), blbuild(), blinsert(), brin_free_desc(), bringetbitmap(), brininsert(), bt_check_every_level(), btendscan(), btvacuumscan(), BuildRelationExtStatistics(), cluster(), compile_plperl_function(), compile_pltcl_function(), compute_index_stats(), CopyTo(), createTrgmNFA(), 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(), ExecEndRecursiveUnion(), ExecEndSetOp(), ExecEndUnique(), ExecEndWindowAgg(), ExecHashTableDestroy(), file_acquire_sample_rows(), fill_hba_view(), fmgr_sql(), free_plperl_function(), FreeDecodingContext(), FreeExecutorState(), FreeExprContext(), freeGISTstate(), FreeSnapshotBuilder(), geqo_eval(), gin_xlog_cleanup(), ginbuild(), ginbulkdelete(), ginendscan(), gininsert(), ginInsertCleanup(), ginPlaceToPage(), gist_xlog_cleanup(), gistbuild(), hash_destroy(), inline_function(), inline_set_returning_function(), libpqrcv_processTuples(), load_hba(), load_ident(), load_tzoffsets(), makeArrayResultArr(), makeMdArrayResult(), materializeQueryResult(), 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(), PLyObject_ToComposite(), PLyString_ToComposite(), PortalDrop(), PostgresMain(), printtup_shutdown(), publicationListToArray(), rebuild_database_list(), ReindexMultipleTables(), 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(), tokenize_inc_file(), tqueueDestroyReceiver(), tuplesort_end(), union_tuples(), and vacuum().

 {
     AssertArg(MemoryContextIsValid(context));
     /* We had better not be deleting TopMemoryContext ... */
     Assert(context != TopMemoryContext);
     /* And not CurrentMemoryContext, either */
     Assert(context != CurrentMemoryContext);
 
     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);
 
     (*context->methods->delete_context) (context);
     VALGRIND_DESTROY_MEMPOOL(context);
     pfree(context);
 }

void MemoryContextDeleteChildren ( MemoryContext context )

Definition at line 236 of file mcxt.c.

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

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

 {
     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);
 }

MemoryContext MemoryContextGetParent ( MemoryContext context )

Definition at line 403 of file mcxt.c.

References AssertArg, MemoryContextIsValid, and MemoryContextData::parent.

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

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

void MemoryContextInit ( void )

Definition at line 89 of file mcxt.c.

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

Referenced by main().

 {
     AssertState(TopMemoryContext == NULL);
 
     /*
      * First, initialize TopMemoryContext, which will hold the MemoryContext
      * nodes for all other contexts.  (There is special-case code in
      * MemoryContextCreate() to handle this call.)
      */
     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);
 }

bool MemoryContextIsEmpty ( MemoryContext context )

Definition at line 415 of file mcxt.c.

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

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);
 }

void MemoryContextReset ( MemoryContext context )

Definition at line 135 of file mcxt.c.

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

Referenced by _bt_preprocess_array_keys(), AfterTriggerExecute(), bloomBuildCallback(), brin_memtuple_initialize(), bt_check_level_from_leftmost(), btvacuumpage(), buildSubPlanHash(), CopyOneRowTo(), dumpbatch(), 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(), ExecHashTableReset(), ExecMakeTableFunctionResult(), ExecRecursiveUnion(), execTuplesMatch(), execTuplesUnequal(), fetch_more_data(), file_acquire_sample_rows(), gin_redo(), ginBuildCallback(), ginHeapTupleBulkInsert(), ginInsertCleanup(), ginVacuumPostingTreeLeaves(), gist_redo(), gistBuildCallback(), gistgetbitmap(), gistgettuple(), gistinsert(), gistProcessEmptyingQueue(), gistrescan(), gistScanPage(), HandleParallelMessages(), IndexBuildHeapRangeScan(), IndexCheckExclusion(), keyGetItem(), libpqrcv_processTuples(), LogicalRepApplyLoop(), make_tuple_from_result_row(), pg_decode_change(), pgoutput_change(), plperl_return_next(), PLyDict_FromTuple(), postgresExecForeignDelete(), postgresExecForeignInsert(), postgresExecForeignUpdate(), printtup(), printtup_20(), printtup_internal_20(), process_ordered_aggregate_multi(), process_ordered_aggregate_single(), ReScanExprContext(), scanPendingInsert(), sepgsql_avc_reset(), setop_fill_hash_table(), spg_redo(), spginsert(), spgistBuildCallback(), spgWalk(), startScanKey(), storeRow(), tfuncLoadRows(), tqueueReceiveSlot(), and validate_index_heapscan().

 {
     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);
 }

void MemoryContextResetChildren ( MemoryContext context )

Definition at line 176 of file mcxt.c.

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

Referenced by MemoryContextResetChildren().

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

void MemoryContextResetOnly ( MemoryContext context )

Definition at line 154 of file mcxt.c.

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

Referenced by MemoryContextReset(), and MemoryContextResetChildren().

 {
     AssertArg(MemoryContextIsValid(context));
 
     /* Nothing to do if no pallocs since startup or last reset */
     if (!context->isReset)
     {
         MemoryContextCallResetCallbacks(context);
         (*context->methods->reset) (context);
         context->isReset = true;
         VALGRIND_DESTROY_MEMPOOL(context);
         VALGRIND_CREATE_MEMPOOL(context, 0, false);
     }
 }

void MemoryContextSetParent	(	MemoryContext	context,
		MemoryContext	new_parent
	)

Definition at line 317 of file mcxt.c.

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

Referenced by _SPI_save_plan(), CachedPlanSetParentContext(), CompleteCachedPlan(), exec_parse_message(), GetCachedPlan(), load_domaintype_info(), MemoryContextDelete(), 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;
     }
 }

void MemoryContextStats ( MemoryContext context )

Definition at line 438 of file mcxt.c.

References MemoryContextStatsDetail().

Referenced by AllocSetContextCreate(), finish_xact_command(), MemoryContextAlloc(), MemoryContextAllocExtended(), MemoryContextAllocHuge(), MemoryContextAllocZero(), MemoryContextAllocZeroAligned(), palloc(), palloc0(), palloc_extended(), repalloc(), and repalloc_huge().

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

void MemoryContextStatsDetail	(	MemoryContext	context,
		int	max_children
	)

Definition at line 450 of file mcxt.c.

References 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);
 }

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

Definition at line 183 of file slab.c.

References Assert, SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, elog, ERROR, SlabContext::fullChunkSize, MAXALIGN, MemoryContextCreate(), SlabContext::minFreeChunks, name, SlabContext::nblocks, offsetof, SlabMethods, StaticAssertStmt, and T_SlabContext.

Referenced by ReorderBufferAllocate().

 {
     int         chunksPerBlock;
     Size        fullChunkSize;
     Size        freelistSize;
     SlabContext *slab;
 
     StaticAssertStmt(offsetof(SlabChunk, slab) + sizeof(MemoryContext) ==
                      MAXALIGN(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 = MAXALIGN(sizeof(SlabChunk) + MAXALIGN(chunkSize));
 
     /* Make sure the block can store at least one chunk. */
     if (blockSize - sizeof(SlabBlock) < fullChunkSize)
         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);
 
     /* if we can't fit at least one chunk into the block, we're hosed */
     Assert(chunksPerBlock > 0);
 
     /* make sure the chunks actually fit on the block   */
     Assert((fullChunkSize * chunksPerBlock) + sizeof(SlabBlock) <= blockSize);
 
     /* Do the type-independent part of context creation */
     slab = (SlabContext *)
         MemoryContextCreate(T_SlabContext,
                             (offsetof(SlabContext, freelist) + freelistSize),
                             &SlabMethods,
                             parent,
                             name);
 
     slab->blockSize = blockSize;
     slab->chunkSize = chunkSize;
     slab->fullChunkSize = fullChunkSize;
     slab->chunksPerBlock = chunksPerBlock;
     slab->nblocks = 0;
     slab->minFreeChunks = 0;
 
     return (MemoryContext) slab;
 }

Variable Documentation

PGDLLIMPORT MemoryContext CacheMemoryContext

Definition at line 46 of file mcxt.c.

Referenced by _SPI_save_plan(), AllocateRelationDesc(), assign_record_type_typmod(), AttrDefaultFetch(), BuildEventTriggerCache(), BuildHardcodedDescriptor(), CatalogCacheCreateEntry(), CatalogCacheInitializeCache(), CheckConstraintFetch(), CreateCacheMemoryContext(), generate_partition_qual(), get_attribute_options(), get_rel_sync_entry(), get_tablespace(), 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(), RelationSetIndexList(), RememberToFreeTupleDescAtEOX(), SaveCachedPlan(), SearchCatCacheList(), and SPI_keepplan().

PGDLLIMPORT MemoryContext CurTransactionContext

Definition at line 49 of file mcxt.c.

Referenced by AddInvalidationMessage(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AtSubStart_Memory(), MakeTransitionCaptureState(), NIStartBuild(), PopTransaction(), queue_listen(), ReleaseCurrentSubTransaction(), sepgsql_set_client_label(), setup_background_workers(), StartTransactionCommand(), and xactGetCommittedInvalidationMessages().

PGDLLIMPORT MemoryContext ErrorContext

Definition at line 44 of file mcxt.c.

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

PGDLLIMPORT MemoryContext MessageContext

Definition at line 47 of file mcxt.c.

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

PGDLLIMPORT MemoryContext PortalContext

Definition at line 52 of file mcxt.c.

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

PGDLLIMPORT MemoryContext PostmasterContext

Definition at line 45 of file mcxt.c.

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

PGDLLIMPORT MemoryContext TopMemoryContext

Definition at line 43 of file mcxt.c.

Referenced by _PG_init(), add_reloption(), add_string_reloption(), allocate_reloption(), AllocateAttribute(), AllocSetContextCreate(), ApplyLauncherMain(), ApplyWorkerMain(), AtAbort_Memory(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AutoVacLauncherMain(), BackendRun(), BackgroundWriterMain(), be_tls_open_server(), cache_single_time(), CheckpointerMain(), compile_plperl_function(), compile_pltcl_function(), ConditionVariablePrepareToSleep(), ConvertTriggerToFK(), CreateCacheMemoryContext(), dblink_connect(), dblink_init(), do_autovacuum(), do_compile(), do_start_bgworker(), dsm_create_descriptor(), dsm_impl_sysv(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), Exec_ListenCommit(), finish_xact_command(), get_tabstat_entry(), GetLocalBufferStorage(), GetLockConflicts(), HandleParallelMessages(), hash_create(), InitDeadLockChecking(), initialize_reloptions(), InitializeParallelDSM(), InitializeSearchPath(), InitXLogInsert(), LockAcquireExtended(), LogicalRepApplyLoop(), mdinit(), MemoryContextInit(), mxid_to_string(), on_dsm_detach(), PageSetChecksumCopy(), ParallelWorkerMain(), PerformAuthentication(), 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(), ri_HashCompareOp(), roles_has_privs_of(), roles_is_member_of(), sepgsql_avc_init(), sepgsql_xact_callback(), SetDatabasePath(), StartChildProcess(), WalWriterMain(), and XLOGShmemInit().

PGDLLIMPORT MemoryContext TopTransactionContext

Definition at line 48 of file mcxt.c.

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

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

Function Documentation

Variable Documentation