#include "nodes/memnodes.h"
#include "storage/condition_variable.h"
#include "storage/lmgr.h"
#include "utils/dsa.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.

Data Structures
struct	MemoryStatsEntry

struct	MemoryStatsCtl

struct	MemoryStatsBackendState

struct	MemoryStatsContextId

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	MEMORY_CONTEXT_IDENT_SHMEM_SIZE 64

#define	MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND ((size_t) (1 * 1024 * 1024))

#define	MAX_MEMORY_CONTEXT_STATS_SIZE

#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)

Typedefs
typedef struct MemoryStatsEntry	MemoryStatsEntry

typedef struct MemoryStatsCtl	MemoryStatsCtl

typedef struct MemoryStatsBackendState	MemoryStatsBackendState

typedef struct MemoryStatsContextId	MemoryStatsContextId

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	MemoryContextMemConsumed (MemoryContext context, MemoryContextCounters *consumed)

void	MemoryContextStats (MemoryContext context)

void	MemoryContextStatsDetail (MemoryContext context, int max_level, 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)

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

static bool	pg_memory_is_all_zeros (const void *ptr, size_t len)

void	ProcessGetMemoryContextInterrupt (void)

const char *	ContextTypeToString (NodeTag type)

void	HandleGetMemoryContextInterrupt (void)

Size	MemoryContextReportingShmemSize (void)

void	MemoryContextReportingShmemInit (void)

void	AtProcExit_memstats_cleanup (int code, Datum arg)

Macro Definition Documentation

◆ AllocHugeSizeIsValid

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

Definition at line 52 of file memutils.h.

◆ ALLOCSET_DEFAULT_INITSIZE

#define ALLOCSET_DEFAULT_INITSIZE (8 * 1024)

Definition at line 178 of file memutils.h.

◆ ALLOCSET_DEFAULT_MAXSIZE

#define ALLOCSET_DEFAULT_MAXSIZE (8 * 1024 * 1024)

Definition at line 179 of file memutils.h.

◆ ALLOCSET_DEFAULT_MINSIZE

#define ALLOCSET_DEFAULT_MINSIZE 0

Definition at line 177 of file memutils.h.

◆ ALLOCSET_DEFAULT_SIZES

#define ALLOCSET_DEFAULT_SIZES ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 180 of file memutils.h.

◆ ALLOCSET_SEPARATE_THRESHOLD

#define ALLOCSET_SEPARATE_THRESHOLD 8192

Definition at line 207 of file memutils.h.

◆ ALLOCSET_SMALL_INITSIZE

#define ALLOCSET_SMALL_INITSIZE (1 * 1024)

Definition at line 188 of file memutils.h.

◆ ALLOCSET_SMALL_MAXSIZE

#define ALLOCSET_SMALL_MAXSIZE (8 * 1024)

Definition at line 189 of file memutils.h.

◆ ALLOCSET_SMALL_MINSIZE

#define ALLOCSET_SMALL_MINSIZE 0

Definition at line 187 of file memutils.h.

◆ ALLOCSET_SMALL_SIZES

#define ALLOCSET_SMALL_SIZES ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE

Definition at line 190 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 197 of file memutils.h.

◆ AllocSetContextCreate

#define AllocSetContextCreate AllocSetContextCreateInternal

Definition at line 149 of file memutils.h.

◆ AllocSizeIsValid

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

Definition at line 45 of file memutils.h.

◆ InvalidAllocSize

#define InvalidAllocSize SIZE_MAX

Definition at line 50 of file memutils.h.

◆ MAX_MEMORY_CONTEXT_STATS_SIZE

#define MAX_MEMORY_CONTEXT_STATS_SIZE

Value:

(sizeof(MemoryStatsEntry) + \

(100 * sizeof(int)) + (2 * MEMORY_CONTEXT_IDENT_SHMEM_SIZE))

MEMORY_CONTEXT_IDENT_SHMEM_SIZE

#define MEMORY_CONTEXT_IDENT_SHMEM_SIZE

Definition: memutils.h:59

MemoryStatsEntry

struct MemoryStatsEntry MemoryStatsEntry

Definition at line 69 of file memutils.h.

◆ MaxAllocHugeSize

#define MaxAllocHugeSize (SIZE_MAX / 2)

Definition at line 48 of file memutils.h.

◆ MaxAllocSize

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

Definition at line 43 of file memutils.h.

◆ MEMORY_CONTEXT_IDENT_SHMEM_SIZE

#define MEMORY_CONTEXT_IDENT_SHMEM_SIZE 64

Definition at line 59 of file memutils.h.

◆ MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND

#define MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND ((size_t) (1 * 1024 * 1024))

Definition at line 61 of file memutils.h.

◆ MemoryContextCopyAndSetIdentifier

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

Definition at line 121 of file memutils.h.

◆ SLAB_DEFAULT_BLOCK_SIZE

#define SLAB_DEFAULT_BLOCK_SIZE (8 * 1024)

Definition at line 209 of file memutils.h.

◆ SLAB_LARGE_BLOCK_SIZE

#define SLAB_LARGE_BLOCK_SIZE (8 * 1024 * 1024)

Definition at line 210 of file memutils.h.

Typedef Documentation

◆ MemoryStatsBackendState

typedef struct MemoryStatsBackendState MemoryStatsBackendState

◆ MemoryStatsContextId

typedef struct MemoryStatsContextId MemoryStatsContextId

◆ MemoryStatsCtl

typedef struct MemoryStatsCtl MemoryStatsCtl

◆ MemoryStatsEntry

typedef struct MemoryStatsEntry MemoryStatsEntry

Function Documentation

◆ AllocSetContextCreateInternal()

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

Definition at line 347 of file aset.c.

{
    int         freeListIndex;
    Size        firstBlockSize;
    AllocSet    set;
    AllocBlock  block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(ALLOC_CHUNKHDRSZ == MAXALIGN(ALLOC_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    /* check we have enough space to store the freelist link */
    StaticAssertDecl(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 =
                KeeperBlock(set)->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 = KeeperBlock(set);
    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;
 
    /* Finish filling in aset-specific parts of the context header */
    MemSetAligned(set->freelist, 0, sizeof(set->freelist));
 
    set->initBlockSize = (uint32) initBlockSize;
    set->maxBlockSize = (uint32) maxBlockSize;
    set->nextBlockSize = (uint32) 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, KeeperBlock, 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, StaticAssertDecl, StaticAssertStmt, TopMemoryContext, and VALGRIND_MAKE_MEM_NOACCESS.

◆ AtProcExit_memstats_cleanup()

void AtProcExit_memstats_cleanup	(	int	code,
		Datum	arg
	)

Definition at line 1908 of file mcxt.c.

{
    int         idx = MyProcNumber;
 
    if (memCxtArea->memstats_dsa_handle == DSA_HANDLE_INVALID)
        return;
 
    LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
 
    if (!DsaPointerIsValid(memCxtState[idx].memstats_dsa_pointer))
    {
        LWLockRelease(&memCxtState[idx].lw_lock);
        return;
    }
 
    /* If the dsa mapping could not be found, attach to the area */
    if (MemoryStatsDsaArea == NULL)
        MemoryStatsDsaArea = dsa_attach(memCxtArea->memstats_dsa_handle);
 
    /*
     * Free the memory context statistics, free the name, ident and path
     * pointers before freeing the pointer that contains these pointers and
     * integer statistics.
     */
    free_memorycontextstate_dsa(MemoryStatsDsaArea, memCxtState[idx].total_stats,
                                memCxtState[idx].memstats_dsa_pointer);
 
    dsa_detach(MemoryStatsDsaArea);
    LWLockRelease(&memCxtState[idx].lw_lock);
}

References dsa_attach(), dsa_detach(), DSA_HANDLE_INVALID, DsaPointerIsValid, free_memorycontextstate_dsa(), idx(), LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), memCxtArea, memCxtState, MemoryStatsDsaArea, MemoryStatsCtl::memstats_dsa_handle, and MyProcNumber.

Referenced by BaseInit().

◆ BumpContextCreate()

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

Definition at line 131 of file bump.c.

{
    Size        firstBlockSize;
    Size        allocSize;
    BumpContext *set;
    BumpBlock  *block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(Bump_CHUNKHDRSZ == MAXALIGN(Bump_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(BumpContext)) + Bump_BLOCKHDRSZ +
        Bump_CHUNKHDRSZ;
    if (minContextSize != 0)
        allocSize = Max(allocSize, minContextSize);
    else
        allocSize = Max(allocSize, initBlockSize);
 
    /*
     * Allocate the initial block.  Unlike other bump.c blocks, it starts with
     * the context header and its block header follows that.
     */
    set = (BumpContext *) 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 and initial block if we ereport in this stretch.
     */
    dlist_init(&set->blocks);
 
    /* Fill in the initial block's block header */
    block = KeeperBlock(set);
    /* determine the block size and initialize it */
    firstBlockSize = allocSize - MAXALIGN(sizeof(BumpContext));
    BumpBlockInit(set, block, firstBlockSize);
 
    /* add it to the doubly-linked list of blocks */
    dlist_push_head(&set->blocks, &block->node);
 
    /*
     * Fill in BumpContext-specific header fields.  The Asserts above should
     * ensure that these all fit inside a uint32.
     */
    set->initBlockSize = (uint32) initBlockSize;
    set->maxBlockSize = (uint32) maxBlockSize;
    set->nextBlockSize = (uint32) 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 Bump_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 + Bump_CHUNKHDRSZ) >
           (Size) ((Size) (maxBlockSize - Bump_BLOCKHDRSZ) / Bump_CHUNK_FRACTION))
        set->allocChunkLimit >>= 1;
 
    /* Finally, do the type-independent part of context creation */
    MemoryContextCreate((MemoryContext) set, T_BumpContext, MCTX_BUMP_ID,
                        parent, name);
 
    ((MemoryContext) set)->mem_allocated = allocSize;
 
    return (MemoryContext) set;
}

References BumpContext::allocChunkLimit, AllocHugeSizeIsValid, Assert(), BumpContext::blocks, Bump_BLOCKHDRSZ, Bump_CHUNK_FRACTION, Bump_CHUNKHDRSZ, BumpBlockInit(), dlist_init(), dlist_push_head(), ereport, errcode(), errdetail(), errmsg(), ERROR, BumpContext::initBlockSize, KeeperBlock, malloc, Max, MAXALIGN, BumpContext::maxBlockSize, MCTX_BUMP_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), Min, name, BumpContext::nextBlockSize, BumpBlock::node, StaticAssertDecl, and TopMemoryContext.

Referenced by hash_create_memory(), TidStoreCreateLocal(), and tuplesort_begin_batch().

◆ ContextTypeToString()

const char * ContextTypeToString ( NodeTag type )

Definition at line 165 of file mcxtfuncs.c.

{
    const char *context_type;
 
    switch (type)
    {
        case T_AllocSetContext:
            context_type = "AllocSet";
            break;
        case T_GenerationContext:
            context_type = "Generation";
            break;
        case T_SlabContext:
            context_type = "Slab";
            break;
        case T_BumpContext:
            context_type = "Bump";
            break;
        default:
            context_type = "???";
            break;
    }
    return context_type;
}

References type.

Referenced by pg_get_process_memory_contexts(), and PutMemoryContextsStatsTupleStore().

◆ GenerationContextCreate()

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

Definition at line 160 of file generation.c.

{
    Size        firstBlockSize;
    Size        allocSize;
    GenerationContext *set;
    GenerationBlock *block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(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 = KeeperBlock(set);
    /* 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;
 
    /* Fill in GenerationContext-specific header fields */
    set->initBlockSize = (uint32) initBlockSize;
    set->maxBlockSize = (uint32) maxBlockSize;
    set->nextBlockSize = (uint32) 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, KeeperBlock, malloc, Max, MAXALIGN, GenerationContext::maxBlockSize, MCTX_GENERATION_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), Min, name, GenerationContext::nextBlockSize, GenerationBlock::node, StaticAssertDecl, and TopMemoryContext.

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

◆ GetMemoryChunkContext()

MemoryContext GetMemoryChunkContext ( void * pointer )

Definition at line 738 of file mcxt.c.

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

References MCXT_METHOD.

Referenced by AlignedAllocFree(), AlignedAllocGetChunkContext(), AlignedAllocRealloc(), 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 752 of file mcxt.c.

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

References MCXT_METHOD.

Referenced by AlignedAllocGetChunkSpace(), AlignedAllocRealloc(), copytup_heap(), free_sort_tuple(), getDatumCopy(), ginAllocEntryAccumulator(), ginCombineData(), ginInsertBAEntry(), grow_memtuples(), inittapestate(), intset_create(), intset_new_internal_node(), intset_new_leaf_node(), mergeruns(), tuplesort_begin_batch(), tuplesort_putbrintuple(), tuplesort_putgintuple(), tuplesort_putheaptuple(), tuplesort_putindextuplevalues(), tuplesort_puttupleslot(), tuplestore_begin_common(), tuplestore_clear(), tuplestore_puttupleslot(), tuplestore_putvalues(), tuplestore_trim(), and writetup_heap().

◆ HandleGetMemoryContextInterrupt()

void HandleGetMemoryContextInterrupt ( void )

Definition at line 1363 of file mcxt.c.

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

References InterruptPending, and PublishMemoryContextPending.

Referenced by procsignal_sigusr1_handler().

◆ HandleLogMemoryContextInterrupt()

void HandleLogMemoryContextInterrupt ( void )

Definition at line 1347 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 725 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 485 of file mcxt.c.

{
    MemoryContext curr;
 
    Assert(MemoryContextIsValid(context));
 
    /*
     * Delete subcontexts from the bottom up.
     *
     * Note: Do not use recursion here.  A "stack depth limit exceeded" error
     * would be unpleasant if we're already in the process of cleaning up from
     * transaction abort.  We also cannot use MemoryContextTraverseNext() here
     * because we modify the tree as we go.
     */
    curr = context;
    for (;;)
    {
        MemoryContext parent;
 
        /* Descend down until we find a leaf context with no children */
        while (curr->firstchild != NULL)
            curr = curr->firstchild;
 
        /*
         * We're now at a leaf with no children. Free it and continue from the
         * parent.  Or if this was the original node, we're all done.
         */
        parent = curr->parent;
        MemoryContextDeleteOnly(curr);
 
        if (curr == context)
            break;
        curr = parent;
    }
}

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

Referenced by _brin_parallel_merge(), AfterTriggerEndXact(), afterTriggerInvokeEvents(), ApplyLauncherMain(), AtEOSubXact_SPI(), AtEOXact_LargeObject(), AtSubCleanup_Memory(), AtSubCommit_Memory(), AttachPartitionEnsureIndexes(), AutoVacLauncherMain(), autovacuum_do_vac_analyze(), AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), 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(), daitch_mokotoff(), decr_dcc_refcount(), DeleteExpandedObject(), DiscreteKnapsack(), do_analyze_rel(), 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(), ExecVacuum(), file_acquire_sample_rows(), fill_hba_view(), fill_ident_view(), free_auth_file(), free_plperl_function(), FreeCachedExpression(), FreeDecodingContext(), FreeExecutorState(), FreeExprContext(), freeGISTstate(), FreeSnapshotBuilder(), geqo_eval(), get_actual_variable_range(), get_rel_sync_entry(), GetWALRecordsInfo(), GetXLogSummaryStats(), gin_check_parent_keys_consistency(), gin_check_posting_tree_parent_keys_consistency(), 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(), pg_get_wal_block_info(), 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_cursor_plan(), PLy_plan_dealloc(), PLy_pop_execution_context(), PLy_procedure_delete(), PLy_spi_execute_fetch_result(), PLy_spi_execute_plan(), PortalDrop(), PostgresMain(), postquel_end(), prepare_next_query(), printtup_shutdown(), ProcessConfigFile(), publicationListToArray(), RE_compile_and_cache(), rebuild_database_list(), ReindexMultipleTables(), ReindexPartitions(), ReindexRelationConcurrently(), RelationBuildDesc(), RelationBuildRuleLock(), RelationDestroyRelation(), ReleaseCachedPlan(), ReorderBufferFree(), ResetUnloggedRelations(), RevalidateCachedQuery(), serializeAnalyzeShutdown(), shdepReassignOwned(), shutdown_MultiFuncCall(), spg_xlog_cleanup(), spgbuild(), spgendscan(), spginsert(), SPI_finish(), SPI_freeplan(), SPI_freetuptable(), sql_delete_callback(), statext_dependencies_build(), strlist_to_textarray(), SysLoggerMain(), test_pattern(), TidStoreDestroy(), tokenize_auth_file(), tuplesort_end(), tuplestore_end(), union_tuples(), UploadManifest(), and validateForeignKeyConstraint().

◆ MemoryContextDeleteChildren()

void MemoryContextDeleteChildren ( MemoryContext context )

Definition at line 570 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(), MemoryContextReset(), PersistHoldablePortal(), PortalRunMulti(), and RelationCloseCleanup().

◆ MemoryContextGetParent()

MemoryContext MemoryContextGetParent ( MemoryContext context )

Definition at line 762 of file mcxt.c.

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

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

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

◆ MemoryContextInit()

void MemoryContextInit ( void )

Definition at line 370 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 774 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 793 of file mcxt.c.

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

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

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

◆ MemoryContextMemConsumed()

void MemoryContextMemConsumed	(	MemoryContext	context,
		MemoryContextCounters *	consumed
	)

Definition at line 817 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    memset(consumed, 0, sizeof(*consumed));
 
    /* Examine the context itself */
    context->methods->stats(context, NULL, NULL, consumed, false);
 
    /* Examine children, using iteration not recursion */
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        curr->methods->stats(curr, NULL, NULL, consumed, false);
    }
}

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

Referenced by ExplainExecuteQuery(), and standard_ExplainOneQuery().

◆ MemoryContextReportingShmemInit()

void MemoryContextReportingShmemInit ( void )

Definition at line 637 of file mcxtfuncs.c.

{
    bool        found;
 
    memCxtArea = (MemoryStatsCtl *)
        ShmemInitStruct("MemoryStatsCtl",
                        sizeof(MemoryStatsCtl), &found);
 
    if (!found)
    {
        LWLockInitialize(&memCxtArea->lw_lock, LWTRANCHE_MEMORY_CONTEXT_REPORTING_STATE);
        memCxtArea->memstats_dsa_handle = DSA_HANDLE_INVALID;
    }
 
    memCxtState = (MemoryStatsBackendState *)
        ShmemInitStruct("MemoryStatsBackendState",
                        ((MaxBackends + NUM_AUXILIARY_PROCS) * sizeof(MemoryStatsBackendState)),
                        &found);
 
    if (found)
        return;
 
    for (int i = 0; i < (MaxBackends + NUM_AUXILIARY_PROCS); i++)
    {
        ConditionVariableInit(&memCxtState[i].memcxt_cv);
        LWLockInitialize(&memCxtState[i].lw_lock, LWTRANCHE_MEMORY_CONTEXT_REPORTING_PROC);
        memCxtState[i].memstats_dsa_pointer = InvalidDsaPointer;
    }
}

References ConditionVariableInit(), DSA_HANDLE_INVALID, i, InvalidDsaPointer, MemoryStatsCtl::lw_lock, LWLockInitialize(), LWTRANCHE_MEMORY_CONTEXT_REPORTING_PROC, LWTRANCHE_MEMORY_CONTEXT_REPORTING_STATE, MaxBackends, memCxtArea, memCxtState, MemoryStatsCtl::memstats_dsa_handle, MemoryStatsBackendState::memstats_dsa_pointer, NUM_AUXILIARY_PROCS, and ShmemInitStruct().

Referenced by CreateOrAttachShmemStructs().

◆ MemoryContextReportingShmemSize()

Size MemoryContextReportingShmemSize ( void )

Definition at line 619 of file mcxtfuncs.c.

{
    Size        sz = 0;
    Size        TotalProcs = 0;
 
    TotalProcs = add_size(TotalProcs, NUM_AUXILIARY_PROCS);
    TotalProcs = add_size(TotalProcs, MaxBackends);
    sz = add_size(sz, mul_size(TotalProcs, sizeof(MemoryStatsBackendState)));
 
    sz = add_size(sz, sizeof(MemoryStatsCtl));
 
    return sz;
}

References add_size(), MaxBackends, mul_size(), and NUM_AUXILIARY_PROCS.

Referenced by CalculateShmemSize().

◆ MemoryContextReset()

void MemoryContextReset ( MemoryContext context )

Definition at line 414 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 _brin_parallel_merge(), _bt_preprocess_array_keys(), _SPI_end_call(), AfterTriggerExecute(), agg_refill_hash_table(), apply_spooled_messages(), AtCleanup_Memory(), AtCommit_Memory(), AtEOSubXact_SPI(), AtSubCleanup_Memory(), AutoVacLauncherMain(), BackgroundWriterMain(), bloomBuildCallback(), brin_memtuple_initialize(), bringetbitmap(), brininsert(), bt_check_level_from_leftmost(), btree_redo(), btvacuumpage(), BuildEventTriggerCache(), BuildRelationExtStatistics(), buildSubPlanHash(), cache_purge_all(), check_domain_for_new_field(), check_domain_for_new_tuple(), CheckpointerMain(), CloneRowTriggersToPartition(), compute_expr_stats(), compute_index_stats(), CopyOneRowTo(), CreateTriggerFiringOn(), do_analyze_rel(), do_autovacuum(), dumptuples(), each_object_field_end(), each_worker_jsonb(), elements_array_element_end(), elements_worker_jsonb(), errstart(), eval_windowaggregates(), 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(), ExecReScanAgg(), ExecReScanRecursiveUnion(), ExecReScanSetOp(), execTuplesUnequal(), execute_foreign_modify(), expanded_record_set_field_internal(), expanded_record_set_tuple(), fetch_more_data(), file_acquire_sample_rows(), FlushErrorState(), get_rel_sync_entry(), get_short_term_cxt(), GetWALRecordsInfo(), GetXLogSummaryStats(), gin_redo(), ginBuildCallback(), ginFlushBuildState(), ginFreeScanKeys(), ginHeapTupleBulkInsert(), ginInsertCleanup(), ginVacuumPostingTreeLeaves(), gist_indexsortbuild(), gist_redo(), gistBuildCallback(), gistgetbitmap(), gistgettuple(), gistinsert(), gistProcessEmptyingQueue(), gistrescan(), gistScanPage(), gistSortedBuildCallback(), heapam_index_build_range_scan(), heapam_index_validate_scan(), IndexCheckExclusion(), init_execution_state(), initialize_windowaggregate(), InvalidateEventCacheCallback(), keyGetItem(), libpqrcv_processTuples(), LogicalParallelApplyLoop(), LogicalRepApplyLoop(), lookup_ts_dictionary_cache(), make_tuple_from_result_row(), perform_work_item(), pg_backup_start(), pg_decode_change(), pg_decode_truncate(), pg_get_wal_block_info(), pgarch_archiveXlog(), pgoutput_change(), pgoutput_truncate(), plperl_return_next_internal(), PLy_input_convert(), PLy_input_from_tuple(), PostgresMain(), printtup(), process_ordered_aggregate_single(), ProcessParallelApplyMessages(), ProcessParallelMessages(), release_partition(), ReScanExprContext(), resetSpGistScanOpaque(), RT_FREE(), scanPendingInsert(), sepgsql_avc_reset(), serializeAnalyzeReceive(), spcache_init(), spg_redo(), spginsert(), spgistBuildCallback(), spgWalk(), startScanKey(), statext_dependencies_build(), storeRow(), stream_stop_internal(), tfuncFetchRows(), tfuncLoadRows(), tuplesort_free(), tuplestore_clear(), UpdateCachedPlan(), validateForeignKeyConstraint(), WalSummarizerMain(), and WalWriterMain().

◆ MemoryContextResetChildren()

void MemoryContextResetChildren ( MemoryContext context )

Definition at line 464 of file mcxt.c.

{
    Assert(MemoryContextIsValid(context));
 
    for (MemoryContext curr = context->firstchild;
         curr != NULL;
         curr = MemoryContextTraverseNext(curr, context))
    {
        MemoryContextResetOnly(curr);
    }
}

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

◆ MemoryContextResetOnly()

void MemoryContextResetOnly ( MemoryContext context )

Definition at line 433 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(), JsonTableResetRowPattern(), MemoryContextReset(), MemoryContextResetChildren(), and mergeruns().

◆ MemoryContextSetIdentifier()

void MemoryContextSetIdentifier	(	MemoryContext	context,
		const char *	id
	)

Definition at line 643 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(), hash_create(), lookup_ts_dictionary_cache(), plpgsql_compile_callback(), PLy_procedure_create(), RE_compile_and_cache(), sql_compile_callback(), and test_pattern().

◆ MemoryContextSetParent()

void MemoryContextSetParent	(	MemoryContext	context,
		MemoryContext	new_parent
	)

Definition at line 668 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(), BuildCachedPlan(), CachedPlanSetParentContext(), CompleteCachedPlan(), exec_parse_message(), GetCachedExpression(), GetCachedPlan(), load_domaintype_info(), MemoryContextDeleteOnly(), RE_compile_and_cache(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), RelationBuildRowSecurity(), RelationRebuildRelation(), RevalidateCachedQuery(), SaveCachedPlan(), SPI_keepplan(), sql_compile_callback(), TransferExpandedObject(), and UploadManifest().

◆ MemoryContextStats()

void MemoryContextStats ( MemoryContext context )

Definition at line 845 of file mcxt.c.

{
    /* Hard-wired limits are usually good enough */
    MemoryContextStatsDetail(context, 100, 100, true);
}

References MemoryContextStatsDetail().

Referenced by AllocSetContextCreateInternal(), BumpContextCreate(), finish_xact_command(), GenerationContextCreate(), MemoryContextAllocationFailure(), SlabContextCreate(), and test_pattern().

◆ MemoryContextStatsDetail()

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

Definition at line 860 of file mcxt.c.

{
    MemoryContextCounters grand_totals;
    int         num_contexts;
    PrintDestination print_location;
 
    memset(&grand_totals, 0, sizeof(grand_totals));
 
    if (print_to_stderr)
        print_location = PRINT_STATS_TO_STDERR;
    else
        print_location = PRINT_STATS_TO_LOGS;
 
    /* num_contexts report number of contexts aggregated in the output */
    MemoryContextStatsInternal(context, 0, max_level, max_children,
                               &grand_totals, print_location, &num_contexts);
 
    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.  That would
         * require the buffer to be enlarged, risking an OOM as there could 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, PRINT_STATS_TO_LOGS, PRINT_STATS_TO_STDERR, and MemoryContextCounters::totalspace.

Referenced by MemoryContextStats(), and ProcessLogMemoryContextInterrupt().

◆ pg_memory_is_all_zeros()

static bool pg_memory_is_all_zeros	(	const void *	ptr,
		size_t	len
	)

inlinestatic

Definition at line 239 of file memutils.h.

{
    const unsigned char *p = (const unsigned char *) ptr;
    const unsigned char *end = &p[len];
    const unsigned char *aligned_end = (const unsigned char *)
        ((uintptr_t) end & (~(sizeof(size_t) - 1)));
 
    if (len < sizeof(size_t))
    {
        while (p < end)
        {
            if (*p++ != 0)
                return false;
        }
        return true;
    }
 
    /* "len" in the [sizeof(size_t), sizeof(size_t) * 8 - 1] range */
    if (len < sizeof(size_t) * 8)
    {
        /* Compare bytes until the pointer "p" is aligned */
        while (((uintptr_t) p & (sizeof(size_t) - 1)) != 0)
        {
            if (p == end)
                return true;
            if (*p++ != 0)
                return false;
        }
 
        /*
         * Compare remaining size_t-aligned chunks.
         *
         * There is no risk to read beyond the memory area, as "aligned_end"
         * cannot be higher than "end".
         */
        for (; p < aligned_end; p += sizeof(size_t))
        {
            if (*(size_t *) p != 0)
                return false;
        }
 
        /* Compare remaining bytes until the end */
        while (p < end)
        {
            if (*p++ != 0)
                return false;
        }
        return true;
    }
 
    /* "len" in the [sizeof(size_t) * 8, inf) range */
 
    /* Compare bytes until the pointer "p" is aligned */
    while (((uintptr_t) p & (sizeof(size_t) - 1)) != 0)
    {
        if (p == end)
            return true;
 
        if (*p++ != 0)
            return false;
    }
 
    /*
     * Compare 8 * sizeof(size_t) chunks at once.
     *
     * For performance reasons, we manually unroll this loop and purposefully
     * use bitwise-ORs to combine each comparison.  This prevents boolean
     * short-circuiting and lets the compiler know that it's safe to access
     * all 8 elements regardless of the result of the other comparisons.  This
     * seems to be enough to coax a few compilers into using SIMD
     * instructions.
     */
    for (; p < aligned_end - (sizeof(size_t) * 7); p += sizeof(size_t) * 8)
    {
        if ((((size_t *) p)[0] != 0) | (((size_t *) p)[1] != 0) |
            (((size_t *) p)[2] != 0) | (((size_t *) p)[3] != 0) |
            (((size_t *) p)[4] != 0) | (((size_t *) p)[5] != 0) |
            (((size_t *) p)[6] != 0) | (((size_t *) p)[7] != 0))
            return false;
    }
 
    /*
     * Compare remaining size_t-aligned chunks.
     *
     * There is no risk to read beyond the memory area, as "aligned_end"
     * cannot be higher than "end".
     */
    for (; p < aligned_end; p += sizeof(size_t))
    {
        if (*(size_t *) p != 0)
            return false;
    }
 
    /* Compare remaining bytes until the end */
    while (p < end)
    {
        if (*p++ != 0)
            return false;
    }
 
    return true;
}

References len.

Referenced by PageIsVerified(), pg_stat_get_activity(), pg_stat_get_backend_client_addr(), pg_stat_get_backend_client_port(), pgstat_relation_flush_cb(), pgstat_report_bgwriter(), and pgstat_report_checkpointer().

◆ ProcessGetMemoryContextInterrupt()

void ProcessGetMemoryContextInterrupt ( void )

Definition at line 1432 of file mcxt.c.

{
    List       *contexts;
    HASHCTL     ctl;
    HTAB       *context_id_lookup;
    int         context_id = 0;
    MemoryStatsEntry *meminfo;
    bool        summary = false;
    int         max_stats;
    int         idx = MyProcNumber;
    int         stats_count = 0;
    int         stats_num = 0;
    MemoryContextCounters stat;
    int         num_individual_stats = 0;
 
    PublishMemoryContextPending = false;
 
    /*
     * The hash table is used for constructing "path" column of the view,
     * similar to its local backend counterpart.
     */
    ctl.keysize = sizeof(MemoryContext);
    ctl.entrysize = sizeof(MemoryStatsContextId);
    ctl.hcxt = CurrentMemoryContext;
 
    context_id_lookup = hash_create("pg_get_remote_backend_memory_contexts",
                                    256,
                                    &ctl,
                                    HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
 
    /* List of contexts to process in the next round - start at the top. */
    contexts = list_make1(TopMemoryContext);
 
    /* Compute the number of stats that can fit in the defined limit */
    max_stats =
        MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND / MAX_MEMORY_CONTEXT_STATS_SIZE;
    LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
    summary = memCxtState[idx].summary;
    LWLockRelease(&memCxtState[idx].lw_lock);
 
    /*
     * Traverse the memory context tree to find total number of contexts. If
     * summary is requested report the total number of contexts at level 1 and
     * 2 from the top. Also, populate the hash table of context ids.
     */
    compute_contexts_count_and_ids(contexts, context_id_lookup, &stats_count,
                                   summary);
 
    /*
     * Allocate memory in this process's DSA for storing statistics of the the
     * memory contexts upto max_stats, for contexts that don't fit within a
     * limit, a cumulative total is written as the last record in the DSA
     * segment.
     */
    stats_num = Min(stats_count, max_stats);
 
    LWLockAcquire(&memCxtArea->lw_lock, LW_EXCLUSIVE);
 
    /*
     * Create a DSA and send handle to the the client process after storing
     * the context statistics. If number of contexts exceed a predefined
     * limit(8MB), a cumulative total is stored for such contexts.
     */
    if (memCxtArea->memstats_dsa_handle == DSA_HANDLE_INVALID)
    {
        MemoryContext oldcontext = CurrentMemoryContext;
        dsa_handle  handle;
 
        MemoryContextSwitchTo(TopMemoryContext);
 
        MemoryStatsDsaArea = dsa_create(memCxtArea->lw_lock.tranche);
 
        handle = dsa_get_handle(MemoryStatsDsaArea);
        MemoryContextSwitchTo(oldcontext);
 
        dsa_pin_mapping(MemoryStatsDsaArea);
 
        /*
         * Pin the DSA area, this is to make sure the area remains attachable
         * even if current backend exits. This is done so that the statistics
         * are published even if the process exits while a client is waiting.
         */
        dsa_pin(MemoryStatsDsaArea);
 
        /* Set the handle in shared memory */
        memCxtArea->memstats_dsa_handle = handle;
    }
 
    /*
     * If DSA exists, created by another process publishing statistics, attach
     * to it.
     */
    else if (MemoryStatsDsaArea == NULL)
    {
        MemoryContext oldcontext = CurrentMemoryContext;
 
        MemoryContextSwitchTo(TopMemoryContext);
        MemoryStatsDsaArea = dsa_attach(memCxtArea->memstats_dsa_handle);
        MemoryContextSwitchTo(oldcontext);
        dsa_pin_mapping(MemoryStatsDsaArea);
    }
    LWLockRelease(&memCxtArea->lw_lock);
 
    /*
     * Hold the process lock to protect writes to process specific memory. Two
     * processes publishing statistics do not block each other.
     */
    LWLockAcquire(&memCxtState[idx].lw_lock, LW_EXCLUSIVE);
    memCxtState[idx].proc_id = MyProcPid;
 
    if (DsaPointerIsValid(memCxtState[idx].memstats_dsa_pointer))
    {
        /*
         * Free any previous allocations, free the name, ident and path
         * pointers before freeing the pointer that contains them.
         */
        free_memorycontextstate_dsa(MemoryStatsDsaArea, memCxtState[idx].total_stats,
                                    memCxtState[idx].memstats_dsa_pointer);
    }
 
    /*
     * Assigning total stats before allocating memory so that memory cleanup
     * can run if any subsequent dsa_allocate call to allocate name/ident/path
     * fails.
     */
    memCxtState[idx].total_stats = stats_num;
    memCxtState[idx].memstats_dsa_pointer =
        dsa_allocate0(MemoryStatsDsaArea, stats_num * sizeof(MemoryStatsEntry));
 
    meminfo = (MemoryStatsEntry *)
        dsa_get_address(MemoryStatsDsaArea, memCxtState[idx].memstats_dsa_pointer);
 
    if (summary)
    {
        int         cxt_id = 0;
        List       *path = NIL;
 
        /* Copy TopMemoryContext statistics to DSA */
        memset(&stat, 0, sizeof(stat));
        (*TopMemoryContext->methods->stats) (TopMemoryContext, NULL, NULL,
                                             &stat, true);
        path = lcons_int(1, path);
        PublishMemoryContext(meminfo, cxt_id, TopMemoryContext, path, stat,
                             1, MemoryStatsDsaArea, 100);
        cxt_id = cxt_id + 1;
 
        /*
         * Copy statistics for each of TopMemoryContexts children.  This
         * includes statistics of at most 100 children per node, with each
         * child node limited to a depth of 100 in its subtree.
         */
        for (MemoryContext c = TopMemoryContext->firstchild; c != NULL;
             c = c->nextchild)
        {
            MemoryContextCounters grand_totals;
            int         num_contexts = 0;
            int         level = 0;
 
            path = NIL;
            memset(&grand_totals, 0, sizeof(grand_totals));
 
            MemoryContextStatsInternal(c, level, 100, 100, &grand_totals,
                                       PRINT_STATS_NONE, &num_contexts);
 
            path = compute_context_path(c, context_id_lookup);
 
            /*
             * Register the stats entry first, that way the cleanup handler
             * can reach it in case of allocation failures of one or more
             * members.
             */
            memCxtState[idx].total_stats = cxt_id++;
            PublishMemoryContext(meminfo, cxt_id, c, path,
                                 grand_totals, num_contexts, MemoryStatsDsaArea, 100);
        }
        memCxtState[idx].total_stats = cxt_id;
 
        end_memorycontext_reporting();
 
        /* Notify waiting backends and return */
        hash_destroy(context_id_lookup);
 
        return;
    }
 
    foreach_ptr(MemoryContextData, cur, contexts)
    {
        List       *path = NIL;
 
        /*
         * Figure out the transient context_id of this context and each of its
         * ancestors, to compute a path for this context.
         */
        path = compute_context_path(cur, context_id_lookup);
 
        /* Examine the context stats */
        memset(&stat, 0, sizeof(stat));
        (*cur->methods->stats) (cur, NULL, NULL, &stat, true);
 
        /* Account for saving one statistics slot for cumulative reporting */
        if (context_id < (max_stats - 1) || stats_count <= max_stats)
        {
            /* Copy statistics to DSA memory */
            PublishMemoryContext(meminfo, context_id, cur, path, stat, 1, MemoryStatsDsaArea, 100);
        }
        else
        {
            meminfo[max_stats - 1].totalspace += stat.totalspace;
            meminfo[max_stats - 1].nblocks += stat.nblocks;
            meminfo[max_stats - 1].freespace += stat.freespace;
            meminfo[max_stats - 1].freechunks += stat.freechunks;
        }
 
        /*
         * DSA max limit per process is reached, write aggregate of the
         * remaining statistics.
         *
         * We can store contexts from 0 to max_stats - 1. When stats_count is
         * greater than max_stats, we stop reporting individual statistics
         * when context_id equals max_stats - 2. As we use max_stats - 1 array
         * slot for reporting cumulative statistics or "Remaining Totals".
         */
        if (stats_count > max_stats && context_id == (max_stats - 2))
        {
            char       *nameptr;
            int         namelen = strlen("Remaining Totals");
 
            num_individual_stats = context_id + 1;
            meminfo[max_stats - 1].name = dsa_allocate(MemoryStatsDsaArea, namelen + 1);
            nameptr = dsa_get_address(MemoryStatsDsaArea, meminfo[max_stats - 1].name);
            strncpy(nameptr, "Remaining Totals", namelen);
            meminfo[max_stats - 1].ident = InvalidDsaPointer;
            meminfo[max_stats - 1].path = InvalidDsaPointer;
            meminfo[max_stats - 1].type = 0;
        }
        context_id++;
    }
 
    /*
     * Statistics are not aggregated, i.e individual statistics reported when
     * stats_count <= max_stats.
     */
    if (stats_count <= max_stats)
    {
        memCxtState[idx].total_stats = context_id;
    }
    /* Report number of aggregated memory contexts */
    else
    {
        meminfo[max_stats - 1].num_agg_stats = context_id -
            num_individual_stats;
 
        /*
         * Total stats equals num_individual_stats + 1 record for cumulative
         * statistics.
         */
        memCxtState[idx].total_stats = num_individual_stats + 1;
    }
 
    /* Notify waiting backends and return */
    end_memorycontext_reporting();
 
    hash_destroy(context_id_lookup);
}

References compute_context_path(), compute_contexts_count_and_ids(), ctl, cur, CurrentMemoryContext, dsa_allocate, dsa_allocate0, dsa_attach(), dsa_create, dsa_get_address(), dsa_get_handle(), DSA_HANDLE_INVALID, dsa_pin(), dsa_pin_mapping(), DsaPointerIsValid, end_memorycontext_reporting(), MemoryContextData::firstchild, foreach_ptr, free_memorycontextstate_dsa(), MemoryStatsEntry::freechunks, MemoryStatsEntry::freespace, HASH_BLOBS, HASH_CONTEXT, hash_create(), hash_destroy(), HASH_ELEM, MemoryStatsEntry::ident, idx(), InvalidDsaPointer, lcons_int(), list_make1, LW_EXCLUSIVE, MemoryStatsCtl::lw_lock, LWLockAcquire(), LWLockRelease(), MAX_MEMORY_CONTEXT_STATS_SIZE, memCxtArea, memCxtState, MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND, MemoryContextStatsInternal(), MemoryContextSwitchTo(), MemoryStatsDsaArea, MemoryStatsCtl::memstats_dsa_handle, MemoryStatsBackendState::memstats_dsa_pointer, MemoryContextData::methods, Min, MyProcNumber, MyProcPid, name, MemoryStatsEntry::name, MemoryStatsEntry::nblocks, MemoryContextData::nextchild, NIL, MemoryStatsEntry::num_agg_stats, MemoryStatsEntry::path, PRINT_STATS_NONE, MemoryStatsBackendState::proc_id, PublishMemoryContext(), PublishMemoryContextPending, stat, MemoryContextMethods::stats, MemoryStatsBackendState::summary, TopMemoryContext, MemoryStatsBackendState::total_stats, MemoryStatsEntry::totalspace, LWLock::tranche, and MemoryStatsEntry::type.

Referenced by ProcessAutoVacLauncherInterrupts(), ProcessCheckpointerInterrupts(), ProcessInterrupts(), ProcessMainLoopInterrupts(), ProcessPgArchInterrupts(), ProcessStartupProcInterrupts(), and ProcessWalSummarizerInterrupts().

◆ ProcessLogMemoryContextInterrupt()

void ProcessLogMemoryContextInterrupt ( void )

Definition at line 1380 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 depth of the hierarchy, as well as 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, 100, false);
}

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

Referenced by ProcessAutoVacLauncherInterrupts(), ProcessCheckpointerInterrupts(), ProcessInterrupts(), ProcessMainLoopInterrupts(), ProcessPgArchInterrupts(), ProcessStartupProcInterrupts(), and ProcessWalSummarizerInterrupts().

◆ SlabContextCreate()

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

Definition at line 322 of file slab.c.

{
    int         chunksPerBlock;
    Size        fullChunkSize;
    SlabContext *slab;
    int         i;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(Slab_CHUNKHDRSZ == MAXALIGN(Slab_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    Assert(blockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
 
    /*
     * Ensure there's enough space to store the pointer to the next free chunk
     * in the memory of the (otherwise) unused allocation.
     */
    if (chunkSize < sizeof(MemoryChunk *))
        chunkSize = sizeof(MemoryChunk *);
 
    /* length of the maxaligned chunk including the chunk header  */
#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
 
    Assert(fullChunkSize <= MEMORYCHUNK_MAX_VALUE);
 
    /* compute the number of chunks that will fit on each block */
    chunksPerBlock = (blockSize - Slab_BLOCKHDRSZ) / fullChunkSize;
 
    /* Make sure the block can store at least one chunk. */
    if (chunksPerBlock == 0)
        elog(ERROR, "block size %zu for slab is too small for %zu-byte chunks",
             blockSize, chunkSize);
 
 
 
    slab = (SlabContext *) malloc(Slab_CONTEXT_HDRSZ(chunksPerBlock));
    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 = (uint32) chunkSize;
    slab->fullChunkSize = (uint32) fullChunkSize;
    slab->blockSize = (uint32) blockSize;
    slab->chunksPerBlock = chunksPerBlock;
    slab->curBlocklistIndex = 0;
 
    /*
     * Compute a shift that guarantees that shifting chunksPerBlock with it is
     * < SLAB_BLOCKLIST_COUNT - 1.  The reason that we subtract 1 from
     * SLAB_BLOCKLIST_COUNT in this calculation is that we reserve the 0th
     * blocklist element for blocks which have no free chunks.
     *
     * We calculate the number of bits to shift by rather than a divisor to
     * divide by as performing division each time we need to find the
     * blocklist index would be much slower.
     */
    slab->blocklist_shift = 0;
    while ((slab->chunksPerBlock >> slab->blocklist_shift) >= (SLAB_BLOCKLIST_COUNT - 1))
        slab->blocklist_shift++;
 
    /* initialize the list to store empty blocks to be reused */
    dclist_init(&slab->emptyblocks);
 
    /* initialize each blocklist slot */
    for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
        dlist_init(&slab->blocklist[i]);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* set the isChunkFree pointer right after the end of the context */
    slab->isChunkFree = (bool *) ((char *) slab + sizeof(SlabContext));
#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::blocklist, SlabContext::blocklist_shift, SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dclist_init(), dlist_init(), elog, SlabContext::emptyblocks, ereport, errcode(), errdetail(), errmsg(), ERROR, SlabContext::fullChunkSize, i, malloc, MAXALIGN, MCTX_SLAB_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), name, Slab_BLOCKHDRSZ, SLAB_BLOCKLIST_COUNT, Slab_CHUNKHDRSZ, Slab_CONTEXT_HDRSZ, StaticAssertDecl, and TopMemoryContext.

Referenced by for(), ReorderBufferAllocate(), and test_random().

Variable Documentation

◆ CacheMemoryContext

PGDLLIMPORT MemoryContext CacheMemoryContext

extern

Definition at line 168 of file mcxt.c.

Referenced by _SPI_save_plan(), AllocateRelationDesc(), assign_record_type_typmod(), AttrDefaultFetch(), BuildEventTriggerCache(), BuildHardcodedDescriptor(), CatalogCacheCreateEntry(), CatalogCacheInitializeCache(), CheckNNConstraintFetch(), CreateCacheMemoryContext(), ensure_record_cache_typmod_slot_exists(), FetchTableStates(), generate_partition_qual(), get_attribute_options(), get_tablespace(), GetCachedExpression(), GetCachedPlan(), GetFdwRoutineForRelation(), init_ts_config_cache(), 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(), RehashCatCacheLists(), 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(), SPI_keepplan(), sql_compile_callback(), and UploadManifest().

◆ CurTransactionContext

◆ ErrorContext

PGDLLIMPORT MemoryContext ErrorContext

extern

Definition at line 166 of file mcxt.c.

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

◆ memCxtArea

PGDLLIMPORT MemoryStatsCtl* memCxtArea

extern

Definition at line 38 of file mcxtfuncs.c.

Referenced by AtProcExit_memstats_cleanup(), MemoryContextReportingShmemInit(), pg_get_process_memory_contexts(), and ProcessGetMemoryContextInterrupt().

◆ memCxtState

PGDLLIMPORT MemoryStatsBackendState* memCxtState

extern

Definition at line 37 of file mcxtfuncs.c.

Referenced by AtProcExit_memstats_cleanup(), end_memorycontext_reporting(), free_memorycontextstate_dsa(), MemoryContextReportingShmemInit(), pg_get_process_memory_contexts(), and ProcessGetMemoryContextInterrupt().

◆ MemoryStatsDsaArea

PGDLLIMPORT dsa_area* MemoryStatsDsaArea

extern

Definition at line 175 of file mcxt.c.

Referenced by AtProcExit_memstats_cleanup(), pg_get_process_memory_contexts(), and ProcessGetMemoryContextInterrupt().

◆ MessageContext

PGDLLIMPORT MemoryContext MessageContext

extern

Definition at line 169 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 174 of file mcxt.c.

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

◆ PostmasterContext

PGDLLIMPORT MemoryContext PostmasterContext

extern

Definition at line 167 of file mcxt.c.

Referenced by AutoVacLauncherMain(), AutoVacWorkerMain(), AuxiliaryProcessMainCommon(), BackgroundWorkerMain(), BackgroundWorkerStateChange(), load_hba(), load_ident(), PerformAuthentication(), PostgresMain(), PostmasterMain(), RegisterBackgroundWorker(), and SysLoggerMain().

◆ TopMemoryContext

PGDLLIMPORT MemoryContext TopMemoryContext

extern

Definition at line 165 of file mcxt.c.

Referenced by _PG_init(), AbortOutOfAnyTransaction(), add_reloption(), allocate_reloption(), AllocateAttribute(), AllocSetContextCreateInternal(), ApplyLauncherMain(), AtAbort_Memory(), AtStart_Memory(), AttachSession(), AutoVacLauncherMain(), BackendInitialize(), BackendMain(), BackgroundWorkerMain(), BackgroundWriterMain(), BaseBackupAddTarget(), be_tls_open_server(), build_guc_variables(), BumpContextCreate(), cache_single_string(), cached_function_compile(), cfunc_hashtable_insert(), check_foreign_key(), check_primary_key(), CheckpointerMain(), ClientAuthentication(), compile_plperl_function(), compile_pltcl_function(), CreateCacheMemoryContext(), CreateWaitEventSet(), dblink_connect(), dblink_init(), DCH_cache_getnew(), do_autovacuum(), dsm_create_descriptor(), dsm_impl_sysv(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), Exec_ListenCommit(), executeDateTimeMethod(), find_plan(), finish_xact_command(), GenerationContextCreate(), GetExplainExtensionId(), GetLocalBufferStorage(), GetLockConflicts(), getmissingattr(), GetNamedDSMSegment(), GetSessionDsmHandle(), hash_create(), init_database_collation(), init_missing_cache(), init_string_reloption(), InitDeadLockChecking(), initialize_reloptions(), initialize_target_list(), InitializeClientEncoding(), InitializeLogRepWorker(), InitializeParallelDSM(), InitializeSearchPath(), InitializeSession(), InitializeSystemUser(), InitSync(), InitWalSender(), InitXLogInsert(), injection_points_attach(), injection_points_detach(), llvm_compile_module(), llvm_create_context(), llvm_session_initialize(), LockAcquireExtended(), logicalrep_launcher_attach_dshmem(), LogicalRepApplyLoop(), LWLockRegisterTranche(), mdinit(), MemoryContextAllocationFailure(), MemoryContextDeleteOnly(), MemoryContextInit(), mxid_to_string(), newLOfd(), NUM_cache_getnew(), on_dsm_detach(), PageSetChecksumCopy(), ParallelWorkerMain(), PerformAuthentication(), pg_backup_start(), pg_get_backend_memory_contexts(), pg_get_process_memory_contexts(), pg_newlocale_from_collation(), PgArchiverMain(), pgstat_attach_shmem(), pgstat_init_snapshot_fixed(), pgstat_prep_pending_entry(), pgstat_prep_snapshot(), pgstat_register_kind(), pgstat_setup_backend_status_context(), pgstat_setup_memcxt(), plperl_spi_prepare(), plpgsql_compile_callback(), 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(), postmaster_child_launch(), PostmasterMain(), pq_init(), PrepareClientEncoding(), ProcessGetMemoryContextInterrupt(), ProcessLogMemoryContextInterrupt(), ProcessParallelApplyMessages(), ProcessParallelMessages(), ProcessStartupPacket(), px_find_cipher(), px_find_digest(), RE_compile_and_cache(), recomputeNamespacePath(), register_label_provider(), RegisterExtensionExplainOption(), RegisterResourceReleaseCallback(), RegisterSubXactCallback(), RegisterXactCallback(), RelationCreateStorage(), RelationDropStorage(), RequestNamedLWLockTranche(), ResourceOwnerCreate(), ResourceOwnerEnlarge(), RestoreClientConnectionInfo(), RestoreReindexState(), ri_HashCompareOp(), roles_is_member_of(), secure_open_gssapi(), sepgsql_avc_init(), sepgsql_xact_callback(), set_authn_id(), SetDatabasePath(), SharedRecordTypmodRegistryAttach(), SharedRecordTypmodRegistryInit(), SlabContextCreate(), spcache_init(), SPI_connect_ext(), test_create(), WalSummarizerMain(), WalWriterMain(), and XLOGShmemInit().

◆ TopTransactionContext

PGDLLIMPORT MemoryContext TopTransactionContext

extern

Definition at line 170 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_enum_types(), init_uncommitted_enum_values(), InitializeParallelDSM(), LaunchParallelWorkers(), LogicalRepWorkersWakeupAtCommit(), make_tuple_indirect(), mXactCachePut(), pa_start_subtrans(), 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().

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

PGDLLIMPORT MemoryStatsBackendState *	memCxtState

PGDLLIMPORT MemoryStatsCtl *	memCxtArea

PGDLLIMPORT dsa_area *	MemoryStatsDsaArea

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ AllocHugeSizeIsValid

◆ ALLOCSET_DEFAULT_INITSIZE

◆ ALLOCSET_DEFAULT_MAXSIZE

◆ ALLOCSET_DEFAULT_MINSIZE

◆ ALLOCSET_DEFAULT_SIZES

◆ ALLOCSET_SEPARATE_THRESHOLD

◆ ALLOCSET_SMALL_INITSIZE

◆ ALLOCSET_SMALL_MAXSIZE

◆ ALLOCSET_SMALL_MINSIZE

◆ ALLOCSET_SMALL_SIZES

◆ ALLOCSET_START_SMALL_SIZES

◆ AllocSetContextCreate

◆ AllocSizeIsValid

◆ InvalidAllocSize

◆ MAX_MEMORY_CONTEXT_STATS_SIZE

◆ MaxAllocHugeSize

◆ MaxAllocSize

◆ MEMORY_CONTEXT_IDENT_SHMEM_SIZE

◆ MEMORY_CONTEXT_REPORT_MAX_PER_BACKEND

◆ MemoryContextCopyAndSetIdentifier

◆ SLAB_DEFAULT_BLOCK_SIZE

◆ SLAB_LARGE_BLOCK_SIZE

Typedef Documentation

◆ MemoryStatsBackendState

◆ MemoryStatsContextId

◆ MemoryStatsCtl

◆ MemoryStatsEntry

Function Documentation

◆ AllocSetContextCreateInternal()

◆ AtProcExit_memstats_cleanup()

◆ BumpContextCreate()

◆ ContextTypeToString()

◆ GenerationContextCreate()

◆ GetMemoryChunkContext()

◆ GetMemoryChunkSpace()

◆ HandleGetMemoryContextInterrupt()

◆ HandleLogMemoryContextInterrupt()

◆ MemoryContextAllowInCriticalSection()

◆ MemoryContextDelete()

◆ MemoryContextDeleteChildren()

◆ MemoryContextGetParent()

◆ MemoryContextInit()

◆ MemoryContextIsEmpty()

◆ MemoryContextMemAllocated()

◆ MemoryContextMemConsumed()

◆ MemoryContextReportingShmemInit()

◆ MemoryContextReportingShmemSize()

◆ MemoryContextReset()

◆ MemoryContextResetChildren()

◆ MemoryContextResetOnly()

◆ MemoryContextSetIdentifier()

◆ MemoryContextSetParent()

◆ MemoryContextStats()

◆ MemoryContextStatsDetail()

◆ pg_memory_is_all_zeros()

◆ ProcessGetMemoryContextInterrupt()

◆ ProcessLogMemoryContextInterrupt()

◆ SlabContextCreate()

Variable Documentation

◆ CacheMemoryContext

◆ CurTransactionContext

◆ ErrorContext

◆ memCxtArea

◆ memCxtState

◆ MemoryStatsDsaArea

◆ MessageContext

◆ PortalContext

◆ PostmasterContext

◆ TopMemoryContext

◆ TopTransactionContext