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

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 158 of file memutils.h.

ALLOCSET_DEFAULT_MAXSIZE

#define ALLOCSET_DEFAULT_MAXSIZE   (8 * 1024 * 1024)

Definition at line 159 of file memutils.h.

ALLOCSET_DEFAULT_MINSIZE

#define ALLOCSET_DEFAULT_MINSIZE   0

Definition at line 157 of file memutils.h.

ALLOCSET_DEFAULT_SIZES

#define ALLOCSET_DEFAULT_SIZES    ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE

Definition at line 160 of file memutils.h.

ALLOCSET_SEPARATE_THRESHOLD

#define ALLOCSET_SEPARATE_THRESHOLD   8192

Definition at line 187 of file memutils.h.

ALLOCSET_SMALL_INITSIZE

#define ALLOCSET_SMALL_INITSIZE   (1 * 1024)

Definition at line 168 of file memutils.h.

ALLOCSET_SMALL_MAXSIZE

#define ALLOCSET_SMALL_MAXSIZE   (8 * 1024)

Definition at line 169 of file memutils.h.

ALLOCSET_SMALL_MINSIZE

#define ALLOCSET_SMALL_MINSIZE   0

Definition at line 167 of file memutils.h.

ALLOCSET_SMALL_SIZES

#define ALLOCSET_SMALL_SIZES    ALLOCSET_SMALL_MINSIZE, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MAXSIZE

Definition at line 170 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 177 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.

SLAB_DEFAULT_BLOCK_SIZE

#define SLAB_DEFAULT_BLOCK_SIZE   (8 * 1024)

Definition at line 189 of file memutils.h.

SLAB_LARGE_BLOCK_SIZE

#define SLAB_LARGE_BLOCK_SIZE   (8 * 1024 * 1024)

Definition at line 190 of file memutils.h.

Function Documentation

AllocSetContextCreateInternal()

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

Definition at line 343 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.
     */
 
    /* Create a vpool associated with the context */
    VALGRIND_CREATE_MEMPOOL(set, 0, false);
 
    /*
     * Create a vchunk covering both the AllocSetContext struct and the keeper
     * block's header.  (Perhaps it would be more sensible for these to be two
     * separate vchunks, but doing that seems to tickle bugs in some versions
     * of Valgrind.)  We must have these vchunks, and also a vchunk for each
     * subsequently-added block header, so that Valgrind considers the
     * pointers within them while checking for leaked memory.  Note that
     * Valgrind doesn't distinguish between these vchunks and those created by
     * mcxt.c for the user-accessible-data chunks we allocate.
     */
    VALGRIND_MEMPOOL_ALLOC(set, set, FIRST_BLOCKHDRSZ);
 
    /* 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, FIRST_BLOCKHDRSZ, 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, VALGRIND_CREATE_MEMPOOL, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MEMPOOL_ALLOC.

BumpContextCreate()

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

Definition at line 133 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.
     */
 
    /* See comments about Valgrind interactions in aset.c */
    VALGRIND_CREATE_MEMPOOL(set, 0, false);
    /* This vchunk covers the BumpContext and the keeper block header */
    VALGRIND_MEMPOOL_ALLOC(set, set, FIRST_BLOCKHDRSZ);
 
    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, FIRST_BLOCKHDRSZ, 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, TopMemoryContext, VALGRIND_CREATE_MEMPOOL, and VALGRIND_MEMPOOL_ALLOC.

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

GenerationContextCreate()

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

Definition at line 162 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.
     */
 
    /* See comments about Valgrind interactions in aset.c */
    VALGRIND_CREATE_MEMPOOL(set, 0, false);
    /* This vchunk covers the GenerationContext and the keeper block header */
    VALGRIND_MEMPOOL_ALLOC(set, set, FIRST_BLOCKHDRSZ);
 
    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, FIRST_BLOCKHDRSZ, 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, TopMemoryContext, VALGRIND_CREATE_MEMPOOL, and VALGRIND_MEMPOOL_ALLOC.

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

GetMemoryChunkContext()

MemoryContext GetMemoryChunkContext

(

void *

pointer

)

Definition at line 753 of file mcxt.c.

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

References MCXT_METHOD.

Referenced by AlignedAllocFree(), AlignedAllocGetChunkContext(), AlignedAllocRealloc(), create_unique_paths(), enlarge_list(), execute_dml_stmt(), guc_free(), guc_realloc(), list_delete_first_n(), list_delete_nth_cell(), mark_dummy_rel(), pfree(), repalloc(), repalloc_extended(), reparameterize_path_by_child(), SetPlannerGlobalExtensionState(), and SetRelOptInfoExtensionState().

GetMemoryChunkSpace()

Size GetMemoryChunkSpace

(

void *

pointer

)

Definition at line 767 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().

HandleLogMemoryContextInterrupt()

void HandleLogMemoryContextInterrupt

(

void

)

Definition at line 1320 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 740 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 469 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_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(), materializeQueryResult(), 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 552 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 777 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 356 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 789 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 808 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 832 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().

MemoryContextReset()

void MemoryContextReset

(

MemoryContext

context

)

Definition at line 400 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(), _gin_parallel_merge(), _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(), errfinish(), errstart(), eval_windowaggregates(), EventTriggerInvoke(), exec_dynquery_with_params(), exec_replication_command(), 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(), validateForeignKeyConstraint(), WalSummarizerMain(), and WalWriterMain().

MemoryContextResetChildren()

void MemoryContextResetChildren

(

MemoryContext

context

)

Definition at line 448 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 419 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;
    }
}

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

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

MemoryContextSetIdentifier()

void MemoryContextSetIdentifier	(	MemoryContext	context,
		const char *	id
	)

Definition at line 658 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 683 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(), MemoryContextDeleteOnly(), plpgsql_compile_callback(), 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 860 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 875 of file mcxt.c.

{
    MemoryContextCounters grand_totals;
 
    memset(&grand_totals, 0, sizeof(grand_totals));
 
    MemoryContextStatsInternal(context, 1, max_level, 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.  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, 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 219 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().

ProcessLogMemoryContextInterrupt()

void ProcessLogMemoryContextInterrupt

(

void

)

Definition at line 1337 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.
     */
 
    /* See comments about Valgrind interactions in aset.c */
    VALGRIND_CREATE_MEMPOOL(slab, 0, false);
    /* This vchunk covers the SlabContext only */
    VALGRIND_MEMPOOL_ALLOC(slab, slab, sizeof(SlabContext));
 
    /* 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, TopMemoryContext, VALGRIND_CREATE_MEMPOOL, and VALGRIND_MEMPOOL_ALLOC.

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

Variable Documentation

CacheMemoryContext

PGDLLIMPORT MemoryContext CacheMemoryContext

extern

Definition at line 169 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(), FetchRelationStates(), 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(), plpgsql_compile_callback(), 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

PGDLLIMPORT MemoryContext CurTransactionContext

extern

Definition at line 172 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(), PLy_cursor_plan(), PLy_spi_execute_plan(), PopTransaction(), queue_listen(), RelationBuildPartitionDesc(), RelationBuildPartitionKey(), ReleaseCurrentSubTransaction(), sepgsql_set_client_label(), setup_background_workers(), StartTransactionCommand(), and xactGetCommittedInvalidationMessages().

ErrorContext

PGDLLIMPORT MemoryContext ErrorContext

extern

Definition at line 167 of file mcxt.c.

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

MessageContext

PGDLLIMPORT MemoryContext MessageContext

extern

Definition at line 170 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 175 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 168 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 166 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_init(), DCH_cache_getnew(), do_autovacuum(), dsm_create_descriptor(), dsm_impl_sysv(), EnablePortalManager(), EventTriggerBeginCompleteQuery(), Exec_ListenCommit(), exec_replication_command(), executeDateTimeMethod(), find_plan(), finish_xact_command(), GenerationContextCreate(), GetExplainExtensionId(), GetLocalBufferStorage(), GetLockConflicts(), getmissingattr(), GetNamedDSA(), GetNamedDSHash(), GetNamedDSMSegment(), GetPlannerExtensionId(), GetSessionDsmHandle(), hash_create(), init_database_collation(), init_missing_cache(), init_string_reloption(), InitDeadLockChecking(), initialize_reloptions(), initialize_target_list(), InitializeClientEncoding(), InitializeLogRepWorker(), InitializeParallelDSM(), InitializeSearchPath(), InitializeSession(), InitializeSystemUser(), InitPgFdwOptions(), InitSync(), InitWalSender(), InitXLogInsert(), injection_points_attach(), injection_points_detach(), llvm_compile_module(), llvm_create_context(), llvm_session_initialize(), LockAcquireExtended(), logicalrep_launcher_attach_dshmem(), LogicalRepApplyLoop(), 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_dsm_registry_allocations(), 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(), 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(), 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 171 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(), do_autovacuum(), 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().