bump.c File Reference

#include "postgres.h"
#include "lib/ilist.h"
#include "port/pg_bitutils.h"
#include "utils/memdebug.h"
#include "utils/memutils.h"
#include "utils/memutils_memorychunk.h"
#include "utils/memutils_internal.h"

Include dependency graph for bump.c:

Go to the source code of this file.

Data Structures
struct	BumpContext
struct	BumpBlock

Macros
#define	Bump_BLOCKHDRSZ   MAXALIGN(sizeof(BumpBlock))
#define	FIRST_BLOCKHDRSZ
#define	Bump_CHUNKHDRSZ   0
#define	Bump_CHUNK_FRACTION   8
#define	KeeperBlock(set)
#define	IsKeeperBlock(set, blk)   (KeeperBlock(set) == (blk))
#define	BumpIsValid(set)    ((set) && IsA(set, BumpContext))
#define	ExternalChunkGetBlock(chunk)    (BumpBlock *) ((char *) chunk - Bump_BLOCKHDRSZ)

Typedefs
typedef struct BumpBlock	BumpBlock
typedef struct BumpContext	BumpContext

Functions
static void	BumpBlockInit (BumpContext *context, BumpBlock *block, Size blksize)
static bool	BumpBlockIsEmpty (BumpBlock *block)
static void	BumpBlockMarkEmpty (BumpBlock *block)
static Size	BumpBlockFreeBytes (BumpBlock *block)
static void	BumpBlockFree (BumpContext *set, BumpBlock *block)
MemoryContext	BumpContextCreate (MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
void	BumpReset (MemoryContext context)
void	BumpDelete (MemoryContext context)
static pg_noinline void *	BumpAllocLarge (MemoryContext context, Size size, int flags)
static void *	BumpAllocChunkFromBlock (MemoryContext context, BumpBlock *block, Size size, Size chunk_size)
static pg_noinline void *	BumpAllocFromNewBlock (MemoryContext context, Size size, int flags, Size chunk_size)
void *	BumpAlloc (MemoryContext context, Size size, int flags)
void	BumpFree (void *pointer)
void *	BumpRealloc (void *pointer, Size size, int flags)
MemoryContext	BumpGetChunkContext (void *pointer)
Size	BumpGetChunkSpace (void *pointer)
bool	BumpIsEmpty (MemoryContext context)
void	BumpStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals, bool print_to_stderr)

Macro Definition Documentation

Bump_BLOCKHDRSZ

#define Bump_BLOCKHDRSZ   MAXALIGN(sizeof(BumpBlock))

Definition at line 48 of file bump.c.

Bump_CHUNK_FRACTION

#define Bump_CHUNK_FRACTION   8

Definition at line 59 of file bump.c.

Bump_CHUNKHDRSZ

#define Bump_CHUNKHDRSZ   0

Definition at line 56 of file bump.c.

BumpIsValid

#define BumpIsValid

(

set

)

((set) && IsA(set, BumpContext))

Definition at line 102 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;
}
 
/*
 * BumpReset
 *      Frees all memory which is allocated in the given set.
 *
 * The code simply frees all the blocks in the context apart from the keeper
 * block.
 */
void
BumpReset(MemoryContext context)
{
    BumpContext *set = (BumpContext *) context;
    dlist_mutable_iter miter;
 
    Assert(BumpIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    BumpCheck(context);
#endif
 
    dlist_foreach_modify(miter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, miter.cur);
 
        if (IsKeeperBlock(set, block))
            BumpBlockMarkEmpty(block);
        else
            BumpBlockFree(set, block);
    }
 
    /*
     * Instruct Valgrind to throw away all the vchunks associated with this
     * context, except for the one covering the BumpContext and keeper-block
     * header.  This gets rid of the vchunks for whatever user data is getting
     * discarded by the context reset.
     */
    VALGRIND_MEMPOOL_TRIM(set, set, FIRST_BLOCKHDRSZ);
 
    /* Reset block size allocation sequence, too */
    set->nextBlockSize = set->initBlockSize;
 
    /* Ensure there is only 1 item in the dlist */
    Assert(!dlist_is_empty(&set->blocks));
    Assert(!dlist_has_next(&set->blocks, dlist_head_node(&set->blocks)));
}
 
/*
 * BumpDelete
 *      Free all memory which is allocated in the given context.
 */
void
BumpDelete(MemoryContext context)
{
    /* Reset to release all releasable BumpBlocks */
    BumpReset(context);
 
    /* Destroy the vpool -- see notes in aset.c */
    VALGRIND_DESTROY_MEMPOOL(context);
 
    /* And free the context header and keeper block */
    free(context);
}
 
/*
 * Helper for BumpAlloc() that allocates an entire block for the chunk.
 *
 * BumpAlloc()'s comment explains why this is separate.
 */
pg_noinline
static void *
BumpAllocLarge(MemoryContext context, Size size, int flags)
{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
#ifdef MEMORY_CONTEXT_CHECKING
    MemoryChunk *chunk;
#endif
    Size        chunk_size;
    Size        required_size;
    Size        blksize;
 
    /* validate 'size' is within the limits for the given 'flags' */
    MemoryContextCheckSize(context, size, flags);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    chunk_size = MAXALIGN(size + 1);
#else
    chunk_size = MAXALIGN(size);
#endif
 
    required_size = chunk_size + Bump_CHUNKHDRSZ;
    blksize = required_size + Bump_BLOCKHDRSZ;
 
    block = (BumpBlock *) malloc(blksize);
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    /* Make a vchunk covering the new block's header */
    VALGRIND_MEMPOOL_ALLOC(set, block, Bump_BLOCKHDRSZ);
 
    context->mem_allocated += blksize;
 
    /* the block is completely full */
    block->freeptr = block->endptr = ((char *) block) + blksize;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* block with a single (used) chunk */
    block->context = set;
 
    chunk = (MemoryChunk *) (((char *) block) + Bump_BLOCKHDRSZ);
 
    /* mark the MemoryChunk as externally managed */
    MemoryChunkSetHdrMaskExternal(chunk, MCTX_BUMP_ID);
 
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    Assert(size < chunk_size);
    set_sentinel(MemoryChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /*
     * Add the block to the tail of allocated blocks list.  The current block
     * is left at the head of the list as it may still have space for
     * non-large allocations.
     */
    dlist_push_tail(&set->blocks, &block->node);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Bump_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
#else
    return (void *) (((char *) block) + Bump_BLOCKHDRSZ);
#endif
}
 
/*
 * Small helper for allocating a new chunk from a chunk, to avoid duplicating
 * the code between BumpAlloc() and BumpAllocFromNewBlock().
 */
static inline void *
BumpAllocChunkFromBlock(MemoryContext context, BumpBlock *block, Size size,
                        Size chunk_size)
{
#ifdef MEMORY_CONTEXT_CHECKING
    MemoryChunk *chunk;
#else
    void       *ptr;
#endif
 
    /* validate we've been given a block with enough free space */
    Assert(block != NULL);
    Assert((block->endptr - block->freeptr) >= Bump_CHUNKHDRSZ + chunk_size);
 
#ifdef MEMORY_CONTEXT_CHECKING
    chunk = (MemoryChunk *) block->freeptr;
#else
    ptr = block->freeptr;
#endif
 
    /* point the freeptr beyond this chunk */
    block->freeptr += (Bump_CHUNKHDRSZ + chunk_size);
    Assert(block->freeptr <= block->endptr);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Prepare to initialize the chunk header. */
    VALGRIND_MAKE_MEM_UNDEFINED(chunk, Bump_CHUNKHDRSZ);
 
    MemoryChunkSetHdrMask(chunk, block, chunk_size, MCTX_BUMP_ID);
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    Assert(size < chunk_size);
    set_sentinel(MemoryChunkGetPointer(chunk), size);
 
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Bump_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
#else
    return ptr;
#endif                          /* MEMORY_CONTEXT_CHECKING */
}
 
/*
 * Helper for BumpAlloc() that allocates a new block and returns a chunk
 * allocated from it.
 *
 * BumpAlloc()'s comment explains why this is separate.
 */
pg_noinline
static void *
BumpAllocFromNewBlock(MemoryContext context, Size size, int flags,
                      Size chunk_size)
{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
    Size        blksize;
    Size        required_size;
 
    /*
     * The first such block has size initBlockSize, and we double the space in
     * each succeeding block, but not more than maxBlockSize.
     */
    blksize = set->nextBlockSize;
    set->nextBlockSize <<= 1;
    if (set->nextBlockSize > set->maxBlockSize)
        set->nextBlockSize = set->maxBlockSize;
 
    /* we'll need space for the chunk, chunk hdr and block hdr */
    required_size = chunk_size + Bump_CHUNKHDRSZ + Bump_BLOCKHDRSZ;
    /* round the size up to the next power of 2 */
    if (blksize < required_size)
        blksize = pg_nextpower2_size_t(required_size);
 
    block = (BumpBlock *) malloc(blksize);
 
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    /* Make a vchunk covering the new block's header */
    VALGRIND_MEMPOOL_ALLOC(set, block, Bump_BLOCKHDRSZ);
 
    context->mem_allocated += blksize;
 
    /* initialize the new block */
    BumpBlockInit(set, block, blksize);
 
    /* add it to the doubly-linked list of blocks */
    dlist_push_head(&set->blocks, &block->node);
 
    return BumpAllocChunkFromBlock(context, block, size, chunk_size);
}
 
/*
 * BumpAlloc
 *      Returns a pointer to allocated memory of given size or raises an ERROR
 *      on allocation failure, or returns NULL when flags contains
 *      MCXT_ALLOC_NO_OOM.
 *
 * No request may exceed:
 *      MAXALIGN_DOWN(SIZE_MAX) - Bump_BLOCKHDRSZ - Bump_CHUNKHDRSZ
 * All callers use a much-lower limit.
 *
 *
 * Note: when using valgrind, it doesn't matter how the returned allocation
 * is marked, as mcxt.c will set it to UNDEFINED.
 * This function should only contain the most common code paths.  Everything
 * else should be in pg_noinline helper functions, thus avoiding the overhead
 * of creating a stack frame for the common cases.  Allocating memory is often
 * a bottleneck in many workloads, so avoiding stack frame setup is
 * worthwhile.  Helper functions should always directly return the newly
 * allocated memory so that we can just return that address directly as a tail
 * call.
 */
void *
BumpAlloc(MemoryContext context, Size size, int flags)
{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
    Size        chunk_size;
    Size        required_size;
 
    Assert(BumpIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    chunk_size = MAXALIGN(size + 1);
#else
    chunk_size = MAXALIGN(size);
#endif
 
    /*
     * If requested size exceeds maximum for chunks we hand the request off to
     * BumpAllocLarge().
     */
    if (chunk_size > set->allocChunkLimit)
        return BumpAllocLarge(context, size, flags);
 
    required_size = chunk_size + Bump_CHUNKHDRSZ;
 
    /*
     * Not an oversized chunk.  We try to first make use of the latest block,
     * but if there's not enough space in it we must allocate a new block.
     */
    block = dlist_container(BumpBlock, node, dlist_head_node(&set->blocks));
 
    if (BumpBlockFreeBytes(block) < required_size)
        return BumpAllocFromNewBlock(context, size, flags, chunk_size);
 
    /* The current block has space, so just allocate chunk there. */
    return BumpAllocChunkFromBlock(context, block, size, chunk_size);
}
 
/*
 * BumpBlockInit
 *      Initializes 'block' assuming 'blksize'.  Does not update the context's
 *      mem_allocated field.
 */
static inline void
BumpBlockInit(BumpContext *context, BumpBlock *block, Size blksize)
{
#ifdef MEMORY_CONTEXT_CHECKING
    block->context = context;
#endif
    block->freeptr = ((char *) block) + Bump_BLOCKHDRSZ;
    block->endptr = ((char *) block) + blksize;
 
    /* Mark unallocated space NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS(block->freeptr, blksize - Bump_BLOCKHDRSZ);
}
 
/*
 * BumpBlockIsEmpty
 *      Returns true iff 'block' contains no chunks
 */
static inline bool
BumpBlockIsEmpty(BumpBlock *block)
{
    /* it's empty if the freeptr has not moved */
    return (block->freeptr == ((char *) block + Bump_BLOCKHDRSZ));
}
 
/*
 * BumpBlockMarkEmpty
 *      Set a block as empty.  Does not free the block.
 */
static inline void
BumpBlockMarkEmpty(BumpBlock *block)
{
#if defined(USE_VALGRIND) || defined(CLOBBER_FREED_MEMORY)
    char       *datastart = ((char *) block) + Bump_BLOCKHDRSZ;
#endif
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(datastart, block->freeptr - datastart);
#else
    /* wipe_mem() would have done this */
    VALGRIND_MAKE_MEM_NOACCESS(datastart, block->freeptr - datastart);
#endif
 
    /* Reset the block, but don't return it to malloc */
    block->freeptr = ((char *) block) + Bump_BLOCKHDRSZ;
}
 
/*
 * BumpBlockFreeBytes
 *      Returns the number of bytes free in 'block'
 */
static inline Size
BumpBlockFreeBytes(BumpBlock *block)
{
    return (block->endptr - block->freeptr);
}
 
/*
 * BumpBlockFree
 *      Remove 'block' from 'set' and release the memory consumed by it.
 */
static inline void
BumpBlockFree(BumpContext *set, BumpBlock *block)
{
    /* Make sure nobody tries to free the keeper block */
    Assert(!IsKeeperBlock(set, block));
 
    /* release the block from the list of blocks */
    dlist_delete(&block->node);
 
    ((MemoryContext) set)->mem_allocated -= ((char *) block->endptr - (char *) block);
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(block, ((char *) block->endptr - (char *) block));
#endif
 
    /* As in aset.c, free block-header vchunks explicitly */
    VALGRIND_MEMPOOL_FREE(set, block);
 
    free(block);
}
 
/*
 * BumpFree
 *      Unsupported.
 */
void
BumpFree(void *pointer)
{
    elog(ERROR, "%s is not supported by the bump memory allocator", "pfree");
}
 
/*
 * BumpRealloc
 *      Unsupported.
 */
void *
BumpRealloc(void *pointer, Size size, int flags)
{
    elog(ERROR, "%s is not supported by the bump memory allocator", "realloc");
    return NULL;                /* keep compiler quiet */
}
 
/*
 * BumpGetChunkContext
 *      Unsupported.
 */
MemoryContext
BumpGetChunkContext(void *pointer)
{
    elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkContext");
    return NULL;                /* keep compiler quiet */
}
 
/*
 * BumpGetChunkSpace
 *      Unsupported.
 */
Size
BumpGetChunkSpace(void *pointer)
{
    elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkSpace");
    return 0;                   /* keep compiler quiet */
}
 
/*
 * BumpIsEmpty
 *      Is a BumpContext empty of any allocated space?
 */
bool
BumpIsEmpty(MemoryContext context)
{
    BumpContext *set = (BumpContext *) context;
    dlist_iter  iter;
 
    Assert(BumpIsValid(set));
 
    dlist_foreach(iter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
 
        if (!BumpBlockIsEmpty(block))
            return false;
    }
 
    return true;
}
 
/*
 * BumpStats
 *      Compute stats about memory consumption of a Bump context.
 *
 * printfunc: if not NULL, pass a human-readable stats string to this.
 * passthru: pass this pointer through to printfunc.
 * totals: if not NULL, add stats about this context into *totals.
 * print_to_stderr: print stats to stderr if true, elog otherwise.
 */
void
BumpStats(MemoryContext context, MemoryStatsPrintFunc printfunc,
          void *passthru, MemoryContextCounters *totals, bool print_to_stderr)
{
    BumpContext *set = (BumpContext *) context;
    Size        nblocks = 0;
    Size        totalspace = 0;
    Size        freespace = 0;
    dlist_iter  iter;
 
    Assert(BumpIsValid(set));
 
    dlist_foreach(iter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
 
        nblocks++;
        totalspace += (block->endptr - (char *) block);
        freespace += (block->endptr - block->freeptr);
    }
 
    if (printfunc)
    {
        char        stats_string[200];
 
        snprintf(stats_string, sizeof(stats_string),
                 "%zu total in %zu blocks; %zu free; %zu used",
                 totalspace, nblocks, freespace, totalspace - freespace);
        printfunc(context, passthru, stats_string, print_to_stderr);
    }
 
    if (totals)
    {
        totals->nblocks += nblocks;
        totals->totalspace += totalspace;
        totals->freespace += freespace;
    }
}
 
 
#ifdef MEMORY_CONTEXT_CHECKING
 
/*
 * BumpCheck
 *      Walk through chunks and check consistency of memory.
 *
 * NOTE: report errors as WARNING, *not* ERROR or FATAL.  Otherwise you'll
 * find yourself in an infinite loop when trouble occurs, because this
 * routine will be entered again when elog cleanup tries to release memory!
 */
void
BumpCheck(MemoryContext context)
{
    BumpContext *bump = (BumpContext *) context;
    const char *name = context->name;
    dlist_iter  iter;
    Size        total_allocated = 0;
 
    /* walk all blocks in this context */
    dlist_foreach(iter, &bump->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
        int         nchunks;
        char       *ptr;
        bool        has_external_chunk = false;
 
        if (IsKeeperBlock(bump, block))
            total_allocated += block->endptr - (char *) bump;
        else
            total_allocated += block->endptr - (char *) block;
 
        /* check block belongs to the correct context */
        if (block->context != bump)
            elog(WARNING, "problem in Bump %s: bogus context link in block %p",
                 name, block);
 
        /* now walk through the chunks and count them */
        nchunks = 0;
        ptr = ((char *) block) + Bump_BLOCKHDRSZ;
 
        while (ptr < block->freeptr)
        {
            MemoryChunk *chunk = (MemoryChunk *) ptr;
            BumpBlock  *chunkblock;
            Size        chunksize;
 
            /* allow access to the chunk header */
            VALGRIND_MAKE_MEM_DEFINED(chunk, Bump_CHUNKHDRSZ);
 
            if (MemoryChunkIsExternal(chunk))
            {
                chunkblock = ExternalChunkGetBlock(chunk);
                chunksize = block->endptr - (char *) MemoryChunkGetPointer(chunk);
                has_external_chunk = true;
            }
            else
            {
                chunkblock = MemoryChunkGetBlock(chunk);
                chunksize = MemoryChunkGetValue(chunk);
            }
 
            /* move to the next chunk */
            ptr += (chunksize + Bump_CHUNKHDRSZ);
 
            nchunks += 1;
 
            /* chunks have both block and context pointers, so check both */
            if (chunkblock != block)
                elog(WARNING, "problem in Bump %s: bogus block link in block %p, chunk %p",
                     name, block, chunk);
        }
 
        if (has_external_chunk && nchunks > 1)
            elog(WARNING, "problem in Bump %s: external chunk on non-dedicated block %p",
                 name, block);
 
    }
 
    Assert(total_allocated == context->mem_allocated);
}
 
#endif                          /* MEMORY_CONTEXT_CHECKING */

ExternalChunkGetBlock

#define ExternalChunkGetBlock

(

chunk

)

(BumpBlock *) ((char *) chunk - Bump_BLOCKHDRSZ)

Definition at line 110 of file bump.c.

FIRST_BLOCKHDRSZ

#define FIRST_BLOCKHDRSZ

Value:

                             (MAXALIGN(sizeof(BumpContext)) + \
                             Bump_BLOCKHDRSZ)

Definition at line 49 of file bump.c.

IsKeeperBlock

#define IsKeeperBlock	(		set,
			blk
	)		(KeeperBlock(set) == (blk))

Definition at line 64 of file bump.c.

KeeperBlock

#define KeeperBlock

(

set

)

Value:

            ((BumpBlock *) ((char *) (set) + \
            MAXALIGN(sizeof(BumpContext))))

Definition at line 62 of file bump.c.

Typedef Documentation

BumpBlock

typedef struct BumpBlock BumpBlock

Definition at line 66 of file bump.c.

BumpContext

typedef struct BumpContext BumpContext

Function Documentation

BumpAlloc()

void * BumpAlloc	(	MemoryContext	context,
		Size	size,
		int	flags
	)

Definition at line 517 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
    Size        chunk_size;
    Size        required_size;
 
    Assert(BumpIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    chunk_size = MAXALIGN(size + 1);
#else
    chunk_size = MAXALIGN(size);
#endif
 
    /*
     * If requested size exceeds maximum for chunks we hand the request off to
     * BumpAllocLarge().
     */
    if (chunk_size > set->allocChunkLimit)
        return BumpAllocLarge(context, size, flags);
 
    required_size = chunk_size + Bump_CHUNKHDRSZ;
 
    /*
     * Not an oversized chunk.  We try to first make use of the latest block,
     * but if there's not enough space in it we must allocate a new block.
     */
    block = dlist_container(BumpBlock, node, dlist_head_node(&set->blocks));
 
    if (BumpBlockFreeBytes(block) < required_size)
        return BumpAllocFromNewBlock(context, size, flags, chunk_size);
 
    /* The current block has space, so just allocate chunk there. */
    return BumpAllocChunkFromBlock(context, block, size, chunk_size);
}

References BumpContext::allocChunkLimit, Assert, BumpContext::blocks, Bump_CHUNKHDRSZ, BumpAllocChunkFromBlock(), BumpAllocFromNewBlock(), BumpAllocLarge(), BumpBlockFreeBytes(), BumpIsValid, dlist_container, dlist_head_node(), fb(), and MAXALIGN.

BumpAllocChunkFromBlock()

static void * BumpAllocChunkFromBlock ( MemoryContext  context, BumpBlock *  block, Size  size, Size  chunk_size  )

inlinestatic

Definition at line 394 of file bump.c.

{
#ifdef MEMORY_CONTEXT_CHECKING
    MemoryChunk *chunk;
#else
    void       *ptr;
#endif
 
    /* validate we've been given a block with enough free space */
    Assert(block != NULL);
    Assert((block->endptr - block->freeptr) >= Bump_CHUNKHDRSZ + chunk_size);
 
#ifdef MEMORY_CONTEXT_CHECKING
    chunk = (MemoryChunk *) block->freeptr;
#else
    ptr = block->freeptr;
#endif
 
    /* point the freeptr beyond this chunk */
    block->freeptr += (Bump_CHUNKHDRSZ + chunk_size);
    Assert(block->freeptr <= block->endptr);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Prepare to initialize the chunk header. */
    VALGRIND_MAKE_MEM_UNDEFINED(chunk, Bump_CHUNKHDRSZ);
 
    MemoryChunkSetHdrMask(chunk, block, chunk_size, MCTX_BUMP_ID);
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    Assert(size < chunk_size);
    set_sentinel(MemoryChunkGetPointer(chunk), size);
 
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Bump_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
#else
    return ptr;
#endif                          /* MEMORY_CONTEXT_CHECKING */
}

References Assert, Bump_CHUNKHDRSZ, BumpBlock::endptr, fb(), BumpBlock::freeptr, MCTX_BUMP_ID, MemoryChunkGetPointer, MemoryChunkSetHdrMask(), VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by BumpAlloc(), and BumpAllocFromNewBlock().

BumpAllocFromNewBlock()

static pg_noinline void * BumpAllocFromNewBlock ( MemoryContext  context, Size  size, int  flags, Size  chunk_size  )

static

Definition at line 453 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
    Size        blksize;
    Size        required_size;
 
    /*
     * The first such block has size initBlockSize, and we double the space in
     * each succeeding block, but not more than maxBlockSize.
     */
    blksize = set->nextBlockSize;
    set->nextBlockSize <<= 1;
    if (set->nextBlockSize > set->maxBlockSize)
        set->nextBlockSize = set->maxBlockSize;
 
    /* we'll need space for the chunk, chunk hdr and block hdr */
    required_size = chunk_size + Bump_CHUNKHDRSZ + Bump_BLOCKHDRSZ;
    /* round the size up to the next power of 2 */
    if (blksize < required_size)
        blksize = pg_nextpower2_size_t(required_size);
 
    block = (BumpBlock *) malloc(blksize);
 
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    /* Make a vchunk covering the new block's header */
    VALGRIND_MEMPOOL_ALLOC(set, block, Bump_BLOCKHDRSZ);
 
    context->mem_allocated += blksize;
 
    /* initialize the new block */
    BumpBlockInit(set, block, blksize);
 
    /* add it to the doubly-linked list of blocks */
    dlist_push_head(&set->blocks, &block->node);
 
    return BumpAllocChunkFromBlock(context, block, size, chunk_size);
}

References BumpContext::blocks, Bump_BLOCKHDRSZ, Bump_CHUNKHDRSZ, BumpAllocChunkFromBlock(), BumpBlockInit(), dlist_push_head(), fb(), malloc, BumpContext::maxBlockSize, MemoryContextData::mem_allocated, MemoryContextAllocationFailure(), BumpContext::nextBlockSize, BumpBlock::node, pg_nextpower2_size_t, and VALGRIND_MEMPOOL_ALLOC.

Referenced by BumpAlloc().

BumpAllocLarge()

static pg_noinline void * BumpAllocLarge ( MemoryContext  context, Size  size, int  flags  )

static

Definition at line 313 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    BumpBlock  *block;
#ifdef MEMORY_CONTEXT_CHECKING
    MemoryChunk *chunk;
#endif
    Size        chunk_size;
    Size        required_size;
    Size        blksize;
 
    /* validate 'size' is within the limits for the given 'flags' */
    MemoryContextCheckSize(context, size, flags);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    chunk_size = MAXALIGN(size + 1);
#else
    chunk_size = MAXALIGN(size);
#endif
 
    required_size = chunk_size + Bump_CHUNKHDRSZ;
    blksize = required_size + Bump_BLOCKHDRSZ;
 
    block = (BumpBlock *) malloc(blksize);
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    /* Make a vchunk covering the new block's header */
    VALGRIND_MEMPOOL_ALLOC(set, block, Bump_BLOCKHDRSZ);
 
    context->mem_allocated += blksize;
 
    /* the block is completely full */
    block->freeptr = block->endptr = ((char *) block) + blksize;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* block with a single (used) chunk */
    block->context = set;
 
    chunk = (MemoryChunk *) (((char *) block) + Bump_BLOCKHDRSZ);
 
    /* mark the MemoryChunk as externally managed */
    MemoryChunkSetHdrMaskExternal(chunk, MCTX_BUMP_ID);
 
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    Assert(size < chunk_size);
    set_sentinel(MemoryChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /*
     * Add the block to the tail of allocated blocks list.  The current block
     * is left at the head of the list as it may still have space for
     * non-large allocations.
     */
    dlist_push_tail(&set->blocks, &block->node);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Bump_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
#else
    return (void *) (((char *) block) + Bump_BLOCKHDRSZ);
#endif
}

References Assert, BumpContext::blocks, Bump_BLOCKHDRSZ, Bump_CHUNKHDRSZ, dlist_push_tail(), BumpBlock::endptr, fb(), BumpBlock::freeptr, malloc, MAXALIGN, MCTX_BUMP_ID, MemoryContextData::mem_allocated, MemoryChunkGetPointer, MemoryChunkSetHdrMaskExternal(), MemoryContextAllocationFailure(), MemoryContextCheckSize(), BumpBlock::node, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MEMPOOL_ALLOC.

Referenced by BumpAlloc().

BumpBlockFree()

static void BumpBlockFree ( BumpContext *  set, BumpBlock *  block  )

inlinestatic

Definition at line 621 of file bump.c.

{
    /* Make sure nobody tries to free the keeper block */
    Assert(!IsKeeperBlock(set, block));
 
    /* release the block from the list of blocks */
    dlist_delete(&block->node);
 
    ((MemoryContext) set)->mem_allocated -= ((char *) block->endptr - (char *) block);
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(block, ((char *) block->endptr - (char *) block));
#endif
 
    /* As in aset.c, free block-header vchunks explicitly */
    VALGRIND_MEMPOOL_FREE(set, block);
 
    free(block);
}

References Assert, dlist_delete(), BumpBlock::endptr, fb(), free, IsKeeperBlock, BumpBlock::node, and VALGRIND_MEMPOOL_FREE.

Referenced by BumpReset().

BumpBlockFreeBytes()

static Size BumpBlockFreeBytes ( BumpBlock *  block )

inlinestatic

Definition at line 611 of file bump.c.

{
    return (block->endptr - block->freeptr);
}

References BumpBlock::endptr, and BumpBlock::freeptr.

Referenced by BumpAlloc().

BumpBlockInit()

static void BumpBlockInit ( BumpContext *  context, BumpBlock *  block, Size  blksize  )

inlinestatic

Definition at line 561 of file bump.c.

{
#ifdef MEMORY_CONTEXT_CHECKING
    block->context = context;
#endif
    block->freeptr = ((char *) block) + Bump_BLOCKHDRSZ;
    block->endptr = ((char *) block) + blksize;
 
    /* Mark unallocated space NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS(block->freeptr, blksize - Bump_BLOCKHDRSZ);
}

References Bump_BLOCKHDRSZ, BumpBlock::endptr, BumpBlock::freeptr, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by BumpAllocFromNewBlock(), and BumpContextCreate().

BumpBlockIsEmpty()

static bool BumpBlockIsEmpty ( BumpBlock *  block )

inlinestatic

Definition at line 578 of file bump.c.

{
    /* it's empty if the freeptr has not moved */
    return (block->freeptr == ((char *) block + Bump_BLOCKHDRSZ));
}

References Bump_BLOCKHDRSZ, and BumpBlock::freeptr.

Referenced by BumpIsEmpty().

BumpBlockMarkEmpty()

static void BumpBlockMarkEmpty ( BumpBlock *  block )

inlinestatic

Definition at line 589 of file bump.c.

{
#if defined(USE_VALGRIND) || defined(CLOBBER_FREED_MEMORY)
    char       *datastart = ((char *) block) + Bump_BLOCKHDRSZ;
#endif
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(datastart, block->freeptr - datastart);
#else
    /* wipe_mem() would have done this */
    VALGRIND_MAKE_MEM_NOACCESS(datastart, block->freeptr - datastart);
#endif
 
    /* Reset the block, but don't return it to malloc */
    block->freeptr = ((char *) block) + Bump_BLOCKHDRSZ;
}

References Bump_BLOCKHDRSZ, fb(), BumpBlock::freeptr, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by BumpReset().

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, fb(), 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 ExecInitRecursiveUnion(), ExecInitSetOp(), ExecInitSubPlan(), hash_create_memory(), TidStoreCreateLocal(), and tuplesort_begin_batch().

BumpDelete()

void BumpDelete

(

MemoryContext

context

)

Definition at line 294 of file bump.c.

{
    /* Reset to release all releasable BumpBlocks */
    BumpReset(context);
 
    /* Destroy the vpool -- see notes in aset.c */
    VALGRIND_DESTROY_MEMPOOL(context);
 
    /* And free the context header and keeper block */
    free(context);
}

References BumpReset(), free, and VALGRIND_DESTROY_MEMPOOL.

BumpFree()

void BumpFree

(

void *

pointer

)

Definition at line 646 of file bump.c.

{
    elog(ERROR, "%s is not supported by the bump memory allocator", "pfree");
}

References elog, and ERROR.

BumpGetChunkContext()

MemoryContext BumpGetChunkContext

(

void *

pointer

)

Definition at line 667 of file bump.c.

{
    elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkContext");
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, and fb().

BumpGetChunkSpace()

Size BumpGetChunkSpace

(

void *

pointer

)

Definition at line 678 of file bump.c.

{
    elog(ERROR, "%s is not supported by the bump memory allocator", "GetMemoryChunkSpace");
    return 0;                   /* keep compiler quiet */
}

References elog, and ERROR.

BumpIsEmpty()

bool BumpIsEmpty

(

MemoryContext

context

)

Definition at line 689 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    dlist_iter  iter;
 
    Assert(BumpIsValid(set));
 
    dlist_foreach(iter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
 
        if (!BumpBlockIsEmpty(block))
            return false;
    }
 
    return true;
}

References Assert, BumpContext::blocks, BumpBlockIsEmpty(), BumpIsValid, dlist_iter::cur, dlist_container, and dlist_foreach.

BumpRealloc()

void * BumpRealloc	(	void *	pointer,
		Size	size,
		int	flags
	)

Definition at line 656 of file bump.c.

{
    elog(ERROR, "%s is not supported by the bump memory allocator", "realloc");
    return NULL;                /* keep compiler quiet */
}

References elog, ERROR, and fb().

BumpReset()

void BumpReset

(

MemoryContext

context

)

Definition at line 251 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    dlist_mutable_iter miter;
 
    Assert(BumpIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    BumpCheck(context);
#endif
 
    dlist_foreach_modify(miter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, miter.cur);
 
        if (IsKeeperBlock(set, block))
            BumpBlockMarkEmpty(block);
        else
            BumpBlockFree(set, block);
    }
 
    /*
     * Instruct Valgrind to throw away all the vchunks associated with this
     * context, except for the one covering the BumpContext and keeper-block
     * header.  This gets rid of the vchunks for whatever user data is getting
     * discarded by the context reset.
     */
    VALGRIND_MEMPOOL_TRIM(set, set, FIRST_BLOCKHDRSZ);
 
    /* Reset block size allocation sequence, too */
    set->nextBlockSize = set->initBlockSize;
 
    /* Ensure there is only 1 item in the dlist */
    Assert(!dlist_is_empty(&set->blocks));
    Assert(!dlist_has_next(&set->blocks, dlist_head_node(&set->blocks)));
}

References Assert, BumpContext::blocks, BumpBlockFree(), BumpBlockMarkEmpty(), BumpIsValid, dlist_container, dlist_foreach_modify, dlist_has_next(), dlist_head_node(), dlist_is_empty(), fb(), FIRST_BLOCKHDRSZ, BumpContext::initBlockSize, IsKeeperBlock, BumpContext::nextBlockSize, and VALGRIND_MEMPOOL_TRIM.

Referenced by BumpDelete().

BumpStats()

void BumpStats	(	MemoryContext	context,
		MemoryStatsPrintFunc	printfunc,
		void *	passthru,
		MemoryContextCounters *	totals,
		bool	print_to_stderr
	)

Definition at line 717 of file bump.c.

{
    BumpContext *set = (BumpContext *) context;
    Size        nblocks = 0;
    Size        totalspace = 0;
    Size        freespace = 0;
    dlist_iter  iter;
 
    Assert(BumpIsValid(set));
 
    dlist_foreach(iter, &set->blocks)
    {
        BumpBlock  *block = dlist_container(BumpBlock, node, iter.cur);
 
        nblocks++;
        totalspace += (block->endptr - (char *) block);
        freespace += (block->endptr - block->freeptr);
    }
 
    if (printfunc)
    {
        char        stats_string[200];
 
        snprintf(stats_string, sizeof(stats_string),
                 "%zu total in %zu blocks; %zu free; %zu used",
                 totalspace, nblocks, freespace, totalspace - freespace);
        printfunc(context, passthru, stats_string, print_to_stderr);
    }
 
    if (totals)
    {
        totals->nblocks += nblocks;
        totals->totalspace += totalspace;
        totals->freespace += freespace;
    }
}

References Assert, BumpContext::blocks, BumpIsValid, dlist_iter::cur, dlist_container, dlist_foreach, BumpBlock::endptr, fb(), BumpBlock::freeptr, and snprintf.