memutils.h File Reference

#include "nodes/memnodes.h"

Include dependency graph for memutils.h:

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

Go to the source code of this file.

Macros
#define	MaxAllocSize   ((Size) 0x3fffffff) /* 1 gigabyte - 1 */
#define	AllocSizeIsValid(size)   ((Size) (size) <= MaxAllocSize)
#define	MaxAllocHugeSize   (SIZE_MAX / 2)
#define	InvalidAllocSize   SIZE_MAX
#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)
MemoryContext	GetMemoryChunkContext (void *pointer)
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, bool print_to_stderr)
void	MemoryContextAllowInCriticalSection (MemoryContext context, bool allow)
void	HandleLogMemoryContextInterrupt (void)
void	ProcessLogMemoryContextInterrupt (void)
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 minContextSize, Size initBlockSize, Size maxBlockSize)

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

Macro Definition Documentation

AllocHugeSizeIsValid

#define AllocHugeSizeIsValid

(

size

)

((Size) (size) <= MaxAllocHugeSize)

Definition at line 49 of file memutils.h.

ALLOCSET_DEFAULT_INITSIZE

#define ALLOCSET_DEFAULT_INITSIZE   (8 * 1024)

Definition at line 151 of file memutils.h.

ALLOCSET_DEFAULT_MAXSIZE

#define ALLOCSET_DEFAULT_MAXSIZE   (8 * 1024 * 1024)

Definition at line 152 of file memutils.h.

ALLOCSET_DEFAULT_MINSIZE

#define ALLOCSET_DEFAULT_MINSIZE   0

Definition at line 150 of file memutils.h.

ALLOCSET_DEFAULT_SIZES

#define ALLOCSET_DEFAULT_SIZES    ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 153 of file memutils.h.

ALLOCSET_SEPARATE_THRESHOLD

#define ALLOCSET_SEPARATE_THRESHOLD   8192

Definition at line 180 of file memutils.h.

ALLOCSET_SMALL_INITSIZE

#define ALLOCSET_SMALL_INITSIZE   (1 * 1024)

Definition at line 161 of file memutils.h.

ALLOCSET_SMALL_MAXSIZE

#define ALLOCSET_SMALL_MAXSIZE   (8 * 1024)

Definition at line 162 of file memutils.h.

ALLOCSET_SMALL_MINSIZE

#define ALLOCSET_SMALL_MINSIZE   0

Definition at line 160 of file memutils.h.

ALLOCSET_SMALL_SIZES

#define ALLOCSET_SMALL_SIZES    ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE

Definition at line 163 of file memutils.h.

ALLOCSET_START_SMALL_SIZES

#define ALLOCSET_START_SMALL_SIZES    ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 170 of file memutils.h.

AllocSetContextCreate

#define AllocSetContextCreate    AllocSetContextCreateInternal

Definition at line 129 of file memutils.h.

AllocSizeIsValid

#define AllocSizeIsValid

(

size

)

((Size) (size) <= MaxAllocSize)

Definition at line 42 of file memutils.h.

InvalidAllocSize

#define InvalidAllocSize   SIZE_MAX

Definition at line 47 of file memutils.h.

MaxAllocHugeSize

#define MaxAllocHugeSize   (SIZE_MAX / 2)

Definition at line 45 of file memutils.h.

MaxAllocSize

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

Definition at line 40 of file memutils.h.

MemoryContextCopyAndSetIdentifier

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

Definition at line 101 of file memutils.h.

MemoryContextResetAndDeleteChildren

#define MemoryContextResetAndDeleteChildren

(

ctx

)

MemoryContextReset(ctx)

Definition at line 70 of file memutils.h.

SLAB_DEFAULT_BLOCK_SIZE

#define SLAB_DEFAULT_BLOCK_SIZE   (8 * 1024)

Definition at line 182 of file memutils.h.

SLAB_LARGE_BLOCK_SIZE

#define SLAB_LARGE_BLOCK_SIZE   (8 * 1024 * 1024)

Definition at line 183 of file memutils.h.

Function Documentation

AllocSetContextCreateInternal()

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

Definition at line 349 of file aset.c.

{
    int         freeListIndex;
    Size        firstBlockSize;
    AllocSet    set;
    AllocBlock  block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertStmt(ALLOC_CHUNKHDRSZ == MAXALIGN(ALLOC_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    /* check we have enough space to store the freelist link */
    StaticAssertStmt(sizeof(AllocFreeListLink) <= (1 << ALLOC_MINBITS),
                     "sizeof(AllocFreeListLink) larger than minimum allocation size");
 
    /*
     * First, validate allocation parameters.  Once these were regular runtime
     * tests 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.  We restrict the maximum block size to
     * MEMORYCHUNK_MAX_BLOCKOFFSET as MemoryChunks are limited to this in
     * regards to addressing the offset between the chunk and the block that
     * the chunk is stored on.  We would be unable to store the offset between
     * the chunk and block for any chunks that were beyond
     * MEMORYCHUNK_MAX_BLOCKOFFSET bytes into the block if the block was to be
     * larger than this.
     */
    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));
    Assert(maxBlockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
 
    /*
     * 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,
                                MCTX_ASET_ID,
                                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.
     *
     * Also, allocChunkLimit must not exceed ALLOCSET_SEPARATE_THRESHOLD.
     */
    StaticAssertStmt(ALLOC_CHUNK_LIMIT == ALLOCSET_SEPARATE_THRESHOLD,
                     "ALLOC_CHUNK_LIMIT != ALLOCSET_SEPARATE_THRESHOLD");
 
    /*
     * Determine the maximum size that a chunk can be before we allocate an
     * entire AllocBlock dedicated for that chunk.  We set the absolute limit
     * of that size as ALLOC_CHUNK_LIMIT but we reduce it further so that we
     * can fit about ALLOC_CHUNK_FRACTION chunks this size on a maximally
     * sized block.  (We opt to keep allocChunkLimit a power-of-2 value
     * primarily for legacy reasons rather than calculating it so that exactly
     * ALLOC_CHUNK_FRACTION chunks fit on a maximally sized block.)
     */
    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,
                        MCTX_ASET_ID,
                        parent,
                        name);
 
    ((MemoryContext) set)->mem_allocated = firstBlockSize;
 
    return (MemoryContext) set;
}

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

GenerationContextCreate()

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

Definition at line 158 of file generation.c.

{
    Size        firstBlockSize;
    Size        allocSize;
    GenerationContext *set;
    GenerationBlock *block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertStmt(Generation_CHUNKHDRSZ == MAXALIGN(Generation_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
 
    /*
     * First, validate allocation parameters.  Asserts seem sufficient because
     * nobody varies their parameters at runtime.  We somewhat arbitrarily
     * enforce a minimum 1K block size.  We restrict the maximum block size to
     * MEMORYCHUNK_MAX_BLOCKOFFSET as MemoryChunks are limited to this in
     * regards to addressing the offset between the chunk and the block that
     * the chunk is stored on.  We would be unable to store the offset between
     * the chunk and block for any chunks that were beyond
     * MEMORYCHUNK_MAX_BLOCKOFFSET bytes into the block if the block was to be
     * larger than this.
     */
    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));
    Assert(maxBlockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
 
    /* Determine size of initial block */
    allocSize = MAXALIGN(sizeof(GenerationContext)) +
        Generation_BLOCKHDRSZ + Generation_CHUNKHDRSZ;
    if (minContextSize != 0)
        allocSize = Max(allocSize, minContextSize);
    else
        allocSize = Max(allocSize, initBlockSize);
 
    /*
     * Allocate the initial block.  Unlike other generation.c blocks, it
     * starts with the context header and its block header follows that.
     */
    set = (GenerationContext *) malloc(allocSize);
    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.
     */
    dlist_init(&set->blocks);
 
    /* Fill in the initial block's block header */
    block = (GenerationBlock *) (((char *) set) + MAXALIGN(sizeof(GenerationContext)));
    /* determine the block size and initialize it */
    firstBlockSize = allocSize - MAXALIGN(sizeof(GenerationContext));
    GenerationBlockInit(set, block, firstBlockSize);
 
    /* add it to the doubly-linked list of blocks */
    dlist_push_head(&set->blocks, &block->node);
 
    /* use it as the current allocation block */
    set->block = block;
 
    /* No free block, yet */
    set->freeblock = NULL;
 
    /* Mark block as not to be released at reset time */
    set->keeper = block;
 
    /* Fill in GenerationContext-specific header fields */
    set->initBlockSize = initBlockSize;
    set->maxBlockSize = maxBlockSize;
    set->nextBlockSize = initBlockSize;
 
    /*
     * Compute the allocation chunk size limit for this context.
     *
     * Limit the maximum size a non-dedicated chunk can be so that we can fit
     * at least Generation_CHUNK_FRACTION of chunks this big onto the maximum
     * sized block.  We must further limit this value so that it's no more
     * than MEMORYCHUNK_MAX_VALUE.  We're unable to have non-external chunks
     * larger than that value as we store the chunk size in the MemoryChunk
     * 'value' field in the call to MemoryChunkSetHdrMask().
     */
    set->allocChunkLimit = Min(maxBlockSize, MEMORYCHUNK_MAX_VALUE);
    while ((Size) (set->allocChunkLimit + Generation_CHUNKHDRSZ) >
           (Size) ((Size) (maxBlockSize - Generation_BLOCKHDRSZ) / Generation_CHUNK_FRACTION))
        set->allocChunkLimit >>= 1;
 
    /* Finally, do the type-independent part of context creation */
    MemoryContextCreate((MemoryContext) set,
                        T_GenerationContext,
                        MCTX_GENERATION_ID,
                        parent,
                        name);
 
    ((MemoryContext) set)->mem_allocated = firstBlockSize;
 
    return (MemoryContext) set;
}

References GenerationContext::allocChunkLimit, AllocHugeSizeIsValid, Assert(), GenerationContext::block, GenerationContext::blocks, dlist_init(), dlist_push_head(), ereport, errcode(), errdetail(), errmsg(), ERROR, GenerationContext::freeblock, Generation_BLOCKHDRSZ, Generation_CHUNK_FRACTION, Generation_CHUNKHDRSZ, GenerationBlockInit(), GenerationContext::initBlockSize, GenerationContext::keeper, malloc, Max, MAXALIGN, GenerationContext::maxBlockSize, MCTX_GENERATION_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), Min, name, GenerationContext::nextBlockSize, GenerationBlock::node, StaticAssertStmt, and TopMemoryContext.

Referenced by gistvacuumscan(), ReorderBufferAllocate(), and tuplesort_begin_batch().

GetMemoryChunkContext()

MemoryContext GetMemoryChunkContext

(

void *

pointer

)

Definition at line 589 of file mcxt.c.

{
    return MCXT_METHOD(pointer, get_chunk_context) (pointer);
}

References MCXT_METHOD.

Referenced by create_unique_path(), enlarge_list(), guc_free(), guc_realloc(), list_delete_first_n(), list_delete_nth_cell(), mark_dummy_rel(), pfree(), repalloc(), repalloc_extended(), and reparameterize_path_by_child().

GetMemoryChunkSpace()

Size GetMemoryChunkSpace

(

void *

pointer

)

Definition at line 603 of file mcxt.c.

{
    return MCXT_METHOD(pointer, get_chunk_space) (pointer);
}

References MCXT_METHOD.

Referenced by copytup_heap(), dumptuples(), 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_batch(), tuplesort_puttuple_common(), tuplestore_begin_common(), tuplestore_clear(), tuplestore_puttupleslot(), tuplestore_putvalues(), tuplestore_trim(), and writetup_heap().

HandleLogMemoryContextInterrupt()

void HandleLogMemoryContextInterrupt

(

void

)

Definition at line 1155 of file mcxt.c.

{
    InterruptPending = true;
    LogMemoryContextPending = true;
    /* latch will be set by procsignal_sigusr1_handler */
}

References InterruptPending, and LogMemoryContextPending.

Referenced by procsignal_sigusr1_handler().

MemoryContextAllowInCriticalSection()

void MemoryContextAllowInCriticalSection	(	MemoryContext	context,
		bool	allow
	)

Definition at line 576 of file mcxt.c.

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

References MemoryContextData::allowInCritSection, Assert(), and MemoryContextIsValid.

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

MemoryContextDelete()

void MemoryContextDelete

(

MemoryContext

context

)

Definition at line 376 of file mcxt.c.

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

References Assert(), CurrentMemoryContext, MemoryContextMethods::delete_context, MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextCallResetCallbacks(), MemoryContextDeleteChildren(), MemoryContextIsValid, MemoryContextSetParent(), MemoryContextData::methods, TopMemoryContext, 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(), brin_minmax_multi_union(), bringetbitmap(), brininsert(), bt_check_every_level(), btendscan(), btree_xlog_cleanup(), btvacuumscan(), BuildParamLogString(), BuildRelationExtStatistics(), CloneRowTriggersToPartition(), cluster(), compactify_ranges(), compile_plperl_function(), compile_pltcl_function(), compute_expr_stats(), compute_index_stats(), ComputeExtStatisticsRows(), createTrgmNFA(), CreateTriggerFiringOn(), decr_dcc_refcount(), DeleteExpandedObject(), DiscreteKnapsack(), do_analyze_rel(), do_start_bgworker(), do_start_worker(), DoCopyTo(), DropCachedPlan(), each_worker(), each_worker_jsonb(), elements_worker(), elements_worker_jsonb(), end_heap_rewrite(), EndCopy(), EndCopyFrom(), ensure_free_space_in_buffer(), EventTriggerEndCompleteQuery(), EventTriggerInvoke(), exec_replication_command(), exec_simple_query(), ExecEndAgg(), ExecEndMemoize(), ExecEndRecursiveUnion(), ExecEndSetOp(), ExecEndWindowAgg(), ExecHashTableDestroy(), execute_sql_string(), file_acquire_sample_rows(), fill_hba_view(), fill_ident_view(), fmgr_sql(), free_auth_file(), free_plperl_function(), FreeCachedExpression(), FreeDecodingContext(), FreeExecutorState(), FreeExprContext(), freeGISTstate(), FreeSnapshotBuilder(), geqo_eval(), get_actual_variable_range(), get_rel_sync_entry(), 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(), NIFinishBuild(), pg_backup_stop(), pg_decode_shutdown(), pgstat_clear_backend_activity_snapshot(), 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(), ReindexPartitions(), ReindexRelationConcurrently(), RelationBuildDesc(), RelationBuildRuleLock(), RelationDestroyRelation(), ReleaseCachedPlan(), ReorderBufferFree(), ResetUnloggedRelations(), RevalidateCachedQuery(), shdepReassignOwned(), shutdown_MultiFuncCall(), spg_xlog_cleanup(), spgbuild(), spgendscan(), spginsert(), SPI_finish(), SPI_freeplan(), SPI_freetuptable(), StartChildProcess(), statext_dependencies_build(), strlist_to_textarray(), test_pattern(), tokenize_auth_file(), tuplesort_end(), union_tuples(), vacuum(), and validateForeignKeyConstraint().

MemoryContextDeleteChildren()

void MemoryContextDeleteChildren

(

MemoryContext

context

)

Definition at line 421 of file mcxt.c.

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

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

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

MemoryContextGetParent()

MemoryContext MemoryContextGetParent

(

MemoryContext

context

)

Definition at line 613 of file mcxt.c.

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

References Assert(), MemoryContextIsValid, and MemoryContextData::parent.

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

MemoryContextInit()

void MemoryContextInit

(

void

)

Definition at line 259 of file mcxt.c.

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

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), CurrentMemoryContext, ErrorContext, MemoryContextAllowInCriticalSection(), and TopMemoryContext.

Referenced by main().

MemoryContextIsEmpty()

bool MemoryContextIsEmpty

(

MemoryContext

context

)

Definition at line 625 of file mcxt.c.

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

References Assert(), MemoryContextData::firstchild, MemoryContextMethods::is_empty, MemoryContextIsValid, and MemoryContextData::methods.

Referenced by AtSubCommit_Memory().

MemoryContextMemAllocated()

Size MemoryContextMemAllocated	(	MemoryContext	context,
		bool	recurse
	)

Definition at line 644 of file mcxt.c.

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

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

Referenced by hash_agg_check_limits(), and hash_agg_update_metrics().

MemoryContextReset()

void MemoryContextReset

(

MemoryContext

context

)

Definition at line 303 of file mcxt.c.

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

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

Referenced by _bt_preprocess_array_keys(), AfterTriggerExecute(), apply_handle_stream_stop(), apply_spooled_messages(), basic_archive_file(), bloomBuildCallback(), brin_memtuple_initialize(), bt_check_level_from_leftmost(), btree_redo(), btvacuumpage(), BuildRelationExtStatistics(), buildSubPlanHash(), cache_purge_all(), check_domain_for_new_field(), check_domain_for_new_tuple(), CloneRowTriggersToPartition(), CopyOneRowTo(), CreateTriggerFiringOn(), 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(), exec_stmt_return_query(), 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_indexsortbuild(), gist_redo(), gistBuildCallback(), gistgetbitmap(), gistgettuple(), gistinsert(), gistProcessEmptyingQueue(), gistrescan(), gistScanPage(), gistSortedBuildCallback(), 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_backup_start(), pg_decode_change(), pg_decode_truncate(), pgoutput_change(), pgoutput_truncate(), plperl_return_next_internal(), PLy_input_convert(), PLy_input_from_tuple(), printtup(), process_ordered_aggregate_single(), ReScanExprContext(), resetSpGistScanOpaque(), scanPendingInsert(), sepgsql_avc_reset(), spg_redo(), spginsert(), spgistBuildCallback(), spgWalk(), startScanKey(), statext_dependencies_build(), storeRow(), tfuncFetchRows(), tfuncLoadRows(), tuplesort_free(), and validateForeignKeyConstraint().

MemoryContextResetChildren()

void MemoryContextResetChildren

(

MemoryContext

context

)

Definition at line 353 of file mcxt.c.

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

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

MemoryContextResetOnly()

void MemoryContextResetOnly

(

MemoryContext

context

)

Definition at line 322 of file mcxt.c.

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

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

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

MemoryContextSetIdentifier()

void MemoryContextSetIdentifier	(	MemoryContext	context,
		const char *	id
	)

Definition at line 494 of file mcxt.c.

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

References Assert(), 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().

MemoryContextSetParent()

void MemoryContextSetParent	(	MemoryContext	context,
		MemoryContext	new_parent
	)

Definition at line 519 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
    Assert(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)
    {
        Assert(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;
    }
}

References Assert(), 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(), RelationBuildRowSecurity(), RelationClearRelation(), RevalidateCachedQuery(), SaveCachedPlan(), SPI_keepplan(), and TransferExpandedObject().

MemoryContextStats()

void MemoryContextStats

(

MemoryContext

context

)

Definition at line 672 of file mcxt.c.

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

References MemoryContextStatsDetail().

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

MemoryContextStatsDetail()

void MemoryContextStatsDetail	(	MemoryContext	context,
		int	max_children,
		bool	print_to_stderr
	)

Definition at line 687 of file mcxt.c.

{
    MemoryContextCounters grand_totals;
 
    memset(&grand_totals, 0, sizeof(grand_totals));
 
    MemoryContextStatsInternal(context, 0, true, max_children, &grand_totals, print_to_stderr);
 
    if (print_to_stderr)
        fprintf(stderr,
                "Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used\n",
                grand_totals.totalspace, grand_totals.nblocks,
                grand_totals.freespace, grand_totals.freechunks,
                grand_totals.totalspace - grand_totals.freespace);
    else
 
        /*
         * Use LOG_SERVER_ONLY to prevent the memory contexts from being sent
         * to the connected client.
         *
         * We don't buffer the information about all memory contexts in a
         * backend into StringInfo and log it as one message. Otherwise which
         * may require the buffer to be enlarged very much and lead to OOM
         * error since there can be a large number of memory contexts in a
         * backend. Instead, we log one message per memory context.
         */
        ereport(LOG_SERVER_ONLY,
                (errhidestmt(true),
                 errhidecontext(true),
                 errmsg_internal("Grand total: %zu bytes in %zu blocks; %zu free (%zu chunks); %zu used",
                                 grand_totals.totalspace, grand_totals.nblocks,
                                 grand_totals.freespace, grand_totals.freechunks,
                                 grand_totals.totalspace - grand_totals.freespace)));
}

References ereport, errhidecontext(), errhidestmt(), errmsg_internal(), fprintf, MemoryContextCounters::freechunks, MemoryContextCounters::freespace, LOG_SERVER_ONLY, MemoryContextStatsInternal(), MemoryContextCounters::nblocks, and MemoryContextCounters::totalspace.

Referenced by MemoryContextStats(), and ProcessLogMemoryContextInterrupt().

ProcessLogMemoryContextInterrupt()

void ProcessLogMemoryContextInterrupt

(

void

)

Definition at line 1172 of file mcxt.c.

{
    LogMemoryContextPending = false;
 
    /*
     * Use LOG_SERVER_ONLY to prevent this message from being sent to the
     * connected client.
     */
    ereport(LOG_SERVER_ONLY,
            (errhidestmt(true),
             errhidecontext(true),
             errmsg("logging memory contexts of PID %d", MyProcPid)));
 
    /*
     * When a backend process is consuming huge memory, logging all its memory
     * contexts might overrun available disk space. To prevent this, we limit
     * the number of child contexts to log per parent to 100.
     *
     * As with MemoryContextStats(), we suppose that practical cases where the
     * dump gets long will typically be huge numbers of siblings under the
     * same parent context; while the additional debugging value from seeing
     * details about individual siblings beyond 100 will not be large.
     */
    MemoryContextStatsDetail(TopMemoryContext, 100, false);
}

References ereport, errhidecontext(), errhidestmt(), errmsg(), LOG_SERVER_ONLY, LogMemoryContextPending, MemoryContextStatsDetail(), MyProcPid, and TopMemoryContext.

Referenced by HandleAutoVacLauncherInterrupts(), HandleCheckpointerInterrupts(), HandleMainLoopInterrupts(), HandlePgArchInterrupts(), HandleStartupProcInterrupts(), HandleWalWriterInterrupts(), and ProcessInterrupts().

SlabContextCreate()

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

Definition at line 141 of file slab.c.

{
    int         chunksPerBlock;
    Size        fullChunkSize;
    Size        freelistSize;
    Size        headerSize;
    SlabContext *slab;
    int         i;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertStmt(Slab_CHUNKHDRSZ == MAXALIGN(Slab_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    Assert(MAXALIGN(chunkSize) <= MEMORYCHUNK_MAX_VALUE);
 
    /* 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) */
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    fullChunkSize = Slab_CHUNKHDRSZ + MAXALIGN(chunkSize + 1);
#else
    fullChunkSize = Slab_CHUNKHDRSZ + MAXALIGN(chunkSize);
#endif
 
    /* Make sure the block can store at least one chunk. */
    if (blockSize < fullChunkSize + Slab_BLOCKHDRSZ)
        elog(ERROR, "block size %zu for slab is too small for %zu chunks",
             blockSize, chunkSize);
 
    /* Compute maximum number of chunks per block */
    chunksPerBlock = (blockSize - Slab_BLOCKHDRSZ) / 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,
                        MCTX_SLAB_ID,
                        parent,
                        name);
 
    return (MemoryContext) slab;
}

References Assert(), SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, dlist_init(), elog(), ereport, errcode(), errdetail(), errmsg(), ERROR, SlabContext::freelist, SlabContext::fullChunkSize, SlabContext::headerSize, i, malloc, MAXALIGN, MCTX_SLAB_ID, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), SlabContext::minFreeChunks, name, SlabContext::nblocks, Slab_BLOCKHDRSZ, Slab_CHUNKHDRSZ, StaticAssertStmt, and TopMemoryContext.

Referenced by ReorderBufferAllocate().

Variable Documentation

CacheMemoryContext

PGDLLIMPORT MemoryContext CacheMemoryContext

extern

Definition at line 133 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(), FetchTableStates(), generate_partition_qual(), get_attribute_options(), get_rel_sync_entry(), get_tablespace(), GetCachedExpression(), GetCachedPlan(), GetFdwRoutineForRelation(), init_ts_config_cache(), init_tuple_slot(), InitCatCache(), InitializeAttoptCache(), InitializeRelfilenumberMap(), InitializeTableSpaceCache(), load_domaintype_info(), load_enum_cache_data(), load_rangetype_info(), load_relcache_init_file(), logicalrep_partmap_init(), logicalrep_relmap_init(), lookup_ts_config_cache(), lookup_ts_dictionary_cache(), lookup_ts_parser_cache(), lookup_type_cache(), LookupOpclassInfo(), pgoutput_startup(), register_on_commit_action(), RehashCatCache(), RelationBuildLocalRelation(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildPublicationDesc(), RelationBuildRowSecurity(), RelationBuildRuleLock(), RelationBuildTriggers(), RelationBuildTupleDesc(), RelationCacheInitialize(), RelationCacheInitializePhase2(), RelationCacheInitializePhase3(), RelationGetFKeyList(), RelationGetIdentityKeyBitmap(), RelationGetIndexAttrBitmap(), RelationGetIndexList(), RelationGetStatExtList(), RelationInitIndexAccessInfo(), RelationParseRelOptions(), RememberToFreeTupleDescAtEOX(), SaveCachedPlan(), SearchCatCacheList(), set_schema_sent_in_streamed_txn(), and SPI_keepplan().

CurTransactionContext

PGDLLIMPORT MemoryContext CurTransactionContext

extern

Definition at line 136 of file mcxt.c.

Referenced by AddEventToPendingNotifies(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AtSubStart_Memory(), GetAfterTriggersStoreSlot(), GetAfterTriggersTableData(), GetCurrentFDWTuplestore(), MakeTransitionCaptureState(), NIStartBuild(), PopTransaction(), queue_listen(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), ReleaseCurrentSubTransaction(), sepgsql_set_client_label(), setup_background_workers(), StartTransactionCommand(), and xactGetCommittedInvalidationMessages().

ErrorContext

PGDLLIMPORT MemoryContext ErrorContext

extern

Definition at line 131 of file mcxt.c.

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

MessageContext

PGDLLIMPORT MemoryContext MessageContext

extern

Definition at line 134 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

extern

Definition at line 139 of file mcxt.c.

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

PostmasterContext

PGDLLIMPORT MemoryContext PostmasterContext

extern

Definition at line 132 of file mcxt.c.

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

TopMemoryContext

PGDLLIMPORT MemoryContext TopMemoryContext

extern

Definition at line 130 of file mcxt.c.

Referenced by _PG_init(), add_reloption(), allocate_reloption(), AllocateAttribute(), AllocSetContextCreateInternal(), ApplyLauncherMain(), ApplyWorkerMain(), AtAbort_Memory(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AttachSession(), AutoVacLauncherMain(), BackendRun(), BackgroundWriterMain(), BaseBackupAddTarget(), be_tls_open_server(), build_guc_variables(), cache_single_string(), check_foreign_key(), check_primary_key(), CheckpointerMain(), ClientAuthentication(), compile_plperl_function(), compile_pltcl_function(), 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(), GetLocalBufferStorage(), GetLockConflicts(), GetSessionDsmHandle(), HandleParallelMessages(), hash_create(), init_string_reloption(), InitDeadLockChecking(), initialize_reloptions(), initialize_target_list(), InitializeClientEncoding(), InitializeLatchWaitSet(), InitializeParallelDSM(), InitializeSearchPath(), InitializeSession(), InitializeSystemUser(), InitSync(), InitXLogInsert(), llvm_compile_module(), llvm_create_context(), llvm_session_initialize(), LockAcquireExtended(), LogicalRepApplyLoop(), LWLockRegisterTranche(), make_icu_collator(), mdinit(), MemoryContextAlloc(), MemoryContextAllocExtended(), MemoryContextAllocHuge(), MemoryContextAllocZero(), MemoryContextAllocZeroAligned(), MemoryContextDelete(), MemoryContextInit(), mxid_to_string(), newLOfd(), NUM_cache_getnew(), on_dsm_detach(), PageSetChecksumCopy(), palloc(), palloc0(), palloc_extended(), ParallelWorkerMain(), PerformAuthentication(), pg_backup_start(), pg_get_backend_memory_contexts(), pg_newlocale_from_collation(), pgstat_attach_shmem(), pgstat_prep_pending_entry(), pgstat_prep_snapshot(), pgstat_setup_backend_status_context(), pgstat_setup_memcxt(), plperl_spi_prepare(), plpgsql_estate_setup(), plpython3_inline_handler(), plsample_func_handler(), pltcl_SPI_prepare(), PLy_cursor_plan(), PLy_cursor_query(), PLy_procedure_create(), PLy_spi_execute_fetch_result(), PLy_spi_prepare(), populate_typ_list(), PostgresMain(), PostmasterMain(), pq_init(), PrepareClientEncoding(), ProcessLogMemoryContextInterrupt(), ProcessStartupPacket(), PushOverrideSearchPath(), px_find_cipher(), px_find_digest(), recomputeNamespacePath(), register_label_provider(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), RelationCreateStorage(), RelationDropStorage(), repalloc(), repalloc_extended(), RequestNamedLWLockTranche(), ResourceArrayEnlarge(), ResourceOwnerCreate(), RestoreClientConnectionInfo(), RestoreReindexState(), ri_HashCompareOp(), roles_is_member_of(), secure_open_gssapi(), sepgsql_avc_init(), sepgsql_xact_callback(), set_authn_id(), SetDatabasePath(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), SlabContextCreate(), SPI_connect_ext(), StartChildProcess(), WalWriterMain(), and XLOGShmemInit().

TopTransactionContext

PGDLLIMPORT MemoryContext TopTransactionContext

extern

Definition at line 135 of file mcxt.c.

Referenced by add_tabstat_xact_level(), AddInvalidationMessage(), AddPendingSync(), afterTriggerAddEvent(), AfterTriggerBeginSubXact(), AfterTriggerEnlargeQueryState(), apply_spooled_messages(), Async_Notify(), AtCleanup_Memory(), AtCommit_Memory(), AtStart_Memory(), AtSubCommit_childXids(), BeginInternalSubTransaction(), CopySnapshot(), create_drop_transactional_internal(), CreateParallelContext(), DefineSavepoint(), ExportSnapshot(), GetComboCommandId(), init_uncommitted_enums(), InitializeParallelDSM(), LaunchParallelWorkers(), make_tuple_indirect(), mXactCachePut(), pgstat_get_xact_stack_level(), plpgsql_create_econtext(), PLy_get_scratch_context(), PLy_push_execution_context(), PLy_subtransaction_enter(), PortalRun(), PrepareInvalidationState(), PrepareTempTablespaces(), PrepareTransactionBlock(), push_old_value(), PushActiveSnapshotWithLevel(), PushTransaction(), queue_listen(), RestoreSnapshot(), SetConstraintStateCreate(), setup_background_workers(), and SPI_connect_ext().