generation.c File Reference

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

Include dependency graph for generation.c:

Go to the source code of this file.

Data Structures
struct	GenerationContext
struct	GenerationBlock
struct	GenerationChunk

Macros
#define	Generation_BLOCKHDRSZ   MAXALIGN(sizeof(GenerationBlock))
#define	Generation_CHUNKHDRSZ   sizeof(GenerationChunk)
#define	Generation_CHUNK_FRACTION   8
#define	GENERATIONCHUNK_RAWSIZE   (SIZEOF_SIZE_T + SIZEOF_VOID_P * 2)
#define	GENERATIONCHUNK_PRIVATE_LEN   offsetof(GenerationChunk, context)
#define	GenerationIsValid(set)   PointerIsValid(set)
#define	GenerationPointerGetChunk(ptr)    ((GenerationChunk *)(((char *)(ptr)) - Generation_CHUNKHDRSZ))
#define	GenerationChunkGetPointer(chk)    ((GenerationPointer *)(((char *)(chk)) + Generation_CHUNKHDRSZ))

Typedefs
typedef struct GenerationBlock	GenerationBlock
typedef struct GenerationChunk	GenerationChunk
typedef void *	GenerationPointer
typedef struct GenerationContext	GenerationContext

Functions
static void	GenerationBlockInit (GenerationBlock *block, Size blksize)
static bool	GenerationBlockIsEmpty (GenerationBlock *block)
static void	GenerationBlockMarkEmpty (GenerationBlock *block)
static Size	GenerationBlockFreeBytes (GenerationBlock *block)
static void	GenerationBlockFree (GenerationContext *set, GenerationBlock *block)
static void *	GenerationAlloc (MemoryContext context, Size size)
static void	GenerationFree (MemoryContext context, void *pointer)
static void *	GenerationRealloc (MemoryContext context, void *pointer, Size size)
static void	GenerationReset (MemoryContext context)
static void	GenerationDelete (MemoryContext context)
static Size	GenerationGetChunkSpace (MemoryContext context, void *pointer)
static bool	GenerationIsEmpty (MemoryContext context)
static void	GenerationStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals, bool print_to_stderr)
MemoryContext	GenerationContextCreate (MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)

Variables
static const MemoryContextMethods	GenerationMethods

Macro Definition Documentation

Generation_BLOCKHDRSZ

#define Generation_BLOCKHDRSZ   MAXALIGN(sizeof(GenerationBlock))

Definition at line 44 of file generation.c.

Generation_CHUNK_FRACTION

#define Generation_CHUNK_FRACTION   8

Definition at line 47 of file generation.c.

Generation_CHUNKHDRSZ

#define Generation_CHUNKHDRSZ   sizeof(GenerationChunk)

Definition at line 45 of file generation.c.

GENERATIONCHUNK_PRIVATE_LEN

#define GENERATIONCHUNK_PRIVATE_LEN   offsetof(GenerationChunk, context)

Definition at line 141 of file generation.c.

GENERATIONCHUNK_RAWSIZE

#define GENERATIONCHUNK_RAWSIZE   (SIZEOF_SIZE_T + SIZEOF_VOID_P * 2)

Definition at line 122 of file generation.c.

GenerationChunkGetPointer

#define GenerationChunkGetPointer

(

chk

)

((GenerationPointer *)(((char *)(chk)) + Generation_CHUNKHDRSZ))

Definition at line 151 of file generation.c.

GenerationIsValid

#define GenerationIsValid

(

set

)

PointerIsValid(set)

Definition at line 147 of file generation.c.

GenerationPointerGetChunk

#define GenerationPointerGetChunk

(

ptr

)

((GenerationChunk *)(((char *)(ptr)) - Generation_CHUNKHDRSZ))

Definition at line 149 of file generation.c.

Typedef Documentation

GenerationBlock

typedef struct GenerationBlock GenerationBlock

Definition at line 1 of file generation.c.

GenerationChunk

typedef struct GenerationChunk GenerationChunk

Definition at line 1 of file generation.c.

GenerationContext

typedef struct GenerationContext GenerationContext

GenerationPointer

typedef void* GenerationPointer

Definition at line 52 of file generation.c.

Function Documentation

GenerationAlloc()

static void * GenerationAlloc ( MemoryContext  context, Size  size  )

static

Definition at line 397 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    GenerationBlock *block;
    GenerationChunk *chunk;
    Size        chunk_size = MAXALIGN(size);
    Size        required_size = chunk_size + Generation_CHUNKHDRSZ;
 
    /* is it an over-sized chunk? if yes, allocate special block */
    if (chunk_size > set->allocChunkLimit)
    {
        Size        blksize = required_size + Generation_BLOCKHDRSZ;
 
        block = (GenerationBlock *) malloc(blksize);
        if (block == NULL)
            return NULL;
 
        context->mem_allocated += blksize;
 
        /* block with a single (used) chunk */
        block->blksize = blksize;
        block->nchunks = 1;
        block->nfree = 0;
 
        /* the block is completely full */
        block->freeptr = block->endptr = ((char *) block) + blksize;
 
        chunk = (GenerationChunk *) (((char *) block) + Generation_BLOCKHDRSZ);
        chunk->block = block;
        chunk->context = set;
        chunk->size = chunk_size;
 
#ifdef MEMORY_CONTEXT_CHECKING
        chunk->requested_size = size;
        /* set mark to catch clobber of "unused" space */
        if (size < chunk_size)
            set_sentinel(GenerationChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
        /* fill the allocated space with junk */
        randomize_mem((char *) GenerationChunkGetPointer(chunk), size);
#endif
 
        /* add the block to the list of allocated blocks */
        dlist_push_head(&set->blocks, &block->node);
 
        /* Ensure any padding bytes are marked NOACCESS. */
        VALGRIND_MAKE_MEM_NOACCESS((char *) GenerationChunkGetPointer(chunk) + size,
                                   chunk_size - size);
 
        /* Disallow external access to private part of chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, GENERATIONCHUNK_PRIVATE_LEN);
 
        return GenerationChunkGetPointer(chunk);
    }
 
    /*
     * Not an oversized chunk.  We try to first make use of the current block,
     * but if there's not enough space in it, instead of allocating a new
     * block, we look to see if the freeblock is empty and has enough space.
     * If not, we'll also try the same using the keeper block.  The keeper
     * block may have become empty and we have no other way to reuse it again
     * if we don't try to use it explicitly here.
     *
     * We don't want to start filling the freeblock before the current block
     * is full, otherwise we may cause fragmentation in FIFO type workloads.
     * We only switch to using the freeblock or keeper block if those blocks
     * are completely empty.  If we didn't do that we could end up fragmenting
     * consecutive allocations over multiple blocks which would be a problem
     * that would compound over time.
     */
    block = set->block;
 
    if (block == NULL ||
        GenerationBlockFreeBytes(block) < required_size)
    {
        Size        blksize;
        GenerationBlock *freeblock = set->freeblock;
 
        if (freeblock != NULL &&
            GenerationBlockIsEmpty(freeblock) &&
            GenerationBlockFreeBytes(freeblock) >= required_size)
        {
            block = freeblock;
 
            /*
             * Zero out the freeblock as we'll set this to the current block
             * below
             */
            set->freeblock = NULL;
        }
        else if (GenerationBlockIsEmpty(set->keeper) &&
                 GenerationBlockFreeBytes(set->keeper) >= required_size)
        {
            block = set->keeper;
        }
        else
        {
            /*
             * 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 a block hdr too, so add that to the required size */
            required_size += Generation_BLOCKHDRSZ;
 
            /* round the size up to the next power of 2 */
            if (blksize < required_size)
                blksize = pg_nextpower2_size_t(required_size);
 
            block = (GenerationBlock *) malloc(blksize);
 
            if (block == NULL)
                return NULL;
 
            context->mem_allocated += blksize;
 
            /* initialize the new block */
            GenerationBlockInit(block, blksize);
 
            /* add it to the doubly-linked list of blocks */
            dlist_push_head(&set->blocks, &block->node);
 
            /* Zero out the freeblock in case it's become full */
            set->freeblock = NULL;
        }
 
        /* and also use it as the current allocation block */
        set->block = block;
    }
 
    /* we're supposed to have a block with enough free space now */
    Assert(block != NULL);
    Assert((block->endptr - block->freeptr) >= Generation_CHUNKHDRSZ + chunk_size);
 
    chunk = (GenerationChunk *) block->freeptr;
 
    /* Prepare to initialize the chunk header. */
    VALGRIND_MAKE_MEM_UNDEFINED(chunk, Generation_CHUNKHDRSZ);
 
    block->nchunks += 1;
    block->freeptr += (Generation_CHUNKHDRSZ + chunk_size);
 
    Assert(block->freeptr <= block->endptr);
 
    chunk->block = block;
    chunk->context = set;
    chunk->size = chunk_size;
 
#ifdef MEMORY_CONTEXT_CHECKING
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    if (size < chunk->size)
        set_sentinel(GenerationChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) GenerationChunkGetPointer(chunk), size);
#endif
 
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) GenerationChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow external access to private part of chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, GENERATIONCHUNK_PRIVATE_LEN);
 
    return GenerationChunkGetPointer(chunk);
}

References GenerationContext::allocChunkLimit, Assert(), GenerationBlock::blksize, GenerationContext::block, GenerationChunk::block, GenerationContext::blocks, GenerationChunk::context, dlist_push_head(), GenerationBlock::endptr, GenerationContext::freeblock, GenerationBlock::freeptr, Generation_BLOCKHDRSZ, Generation_CHUNKHDRSZ, GenerationBlockFreeBytes(), GenerationBlockInit(), GenerationBlockIsEmpty(), GENERATIONCHUNK_PRIVATE_LEN, GenerationChunkGetPointer, GenerationContext::keeper, malloc, MAXALIGN, GenerationContext::maxBlockSize, MemoryContextData::mem_allocated, GenerationBlock::nchunks, GenerationContext::nextBlockSize, GenerationBlock::nfree, GenerationBlock::node, pg_nextpower2_size_t, GenerationChunk::size, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by GenerationRealloc().

GenerationBlockFree()

static void GenerationBlockFree ( GenerationContext *  set, GenerationBlock *  block  )

inlinestatic

Definition at line 640 of file generation.c.

{
    /* Make sure nobody tries to free the keeper block */
    Assert(block != set->keeper);
    /* We shouldn't be freeing the freeblock either */
    Assert(block != set->freeblock);
 
    /* release the block from the list of blocks */
    dlist_delete(&block->node);
 
    ((MemoryContext) set)->mem_allocated -= block->blksize;
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(block, block->blksize);
#endif
 
    free(block);
}

References Assert(), GenerationBlock::blksize, dlist_delete(), free, GenerationContext::freeblock, GenerationContext::keeper, and GenerationBlock::node.

Referenced by GenerationReset().

GenerationBlockFreeBytes()

static Size GenerationBlockFreeBytes ( GenerationBlock *  block )

inlinestatic

Definition at line 630 of file generation.c.

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

References GenerationBlock::endptr, and GenerationBlock::freeptr.

Referenced by GenerationAlloc().

GenerationBlockInit()

static void GenerationBlockInit ( GenerationBlock *  block, Size  blksize  )

inlinestatic

Definition at line 577 of file generation.c.

{
    block->blksize = blksize;
    block->nchunks = 0;
    block->nfree = 0;
 
    block->freeptr = ((char *) block) + Generation_BLOCKHDRSZ;
    block->endptr = ((char *) block) + blksize;
 
    /* Mark unallocated space NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS(block->freeptr,
                               blksize - Generation_BLOCKHDRSZ);
}

References GenerationBlock::blksize, GenerationBlock::endptr, GenerationBlock::freeptr, Generation_BLOCKHDRSZ, GenerationBlock::nchunks, GenerationBlock::nfree, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by GenerationAlloc(), and GenerationContextCreate().

GenerationBlockIsEmpty()

static bool GenerationBlockIsEmpty ( GenerationBlock *  block )

inlinestatic

Definition at line 596 of file generation.c.

{
    return (block->nchunks == 0);
}

References GenerationBlock::nchunks.

Referenced by GenerationAlloc().

GenerationBlockMarkEmpty()

static void GenerationBlockMarkEmpty ( GenerationBlock *  block )

inlinestatic

Definition at line 606 of file generation.c.

{
#if defined(USE_VALGRIND) || defined(CLOBBER_FREED_MEMORY)
    char       *datastart = ((char *) block) + Generation_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->nchunks = 0;
    block->nfree = 0;
    block->freeptr = ((char *) block) + Generation_BLOCKHDRSZ;
}

References GenerationBlock::freeptr, Generation_BLOCKHDRSZ, GenerationBlock::nchunks, GenerationBlock::nfree, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by GenerationFree(), and GenerationReset().

GenerationContextCreate()

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

Definition at line 215 of file generation.c.

{
    Size        firstBlockSize;
    Size        allocSize;
    GenerationContext *set;
    GenerationBlock *block;
 
    /* Assert we padded GenerationChunk properly */
    StaticAssertStmt(Generation_CHUNKHDRSZ == MAXALIGN(Generation_CHUNKHDRSZ),
                     "sizeof(GenerationChunk) is not maxaligned");
    StaticAssertStmt(offsetof(GenerationChunk, context) + sizeof(MemoryContext) ==
                     Generation_CHUNKHDRSZ,
                     "padding calculation in GenerationChunk is wrong");
 
    /*
     * First, validate allocation parameters.  Asserts seem sufficient because
     * nobody varies their parameters at runtime.  We somewhat arbitrarily
     * enforce a minimum 1K block size.
     */
    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));
 
    /* Determine size of initial block */
    allocSize = MAXALIGN(sizeof(GenerationContext)) +
        Generation_BLOCKHDRSZ + Generation_CHUNKHDRSZ;
    if (minContextSize != 0)
        allocSize = Max(allocSize, minContextSize);
    else
        allocSize = Max(allocSize, initBlockSize);
 
    /*
     * Allocate the initial block.  Unlike other generation.c blocks, it
     * starts with the context header and its block header follows that.
     */
    set = (GenerationContext *) malloc(allocSize);
    if (set == NULL)
    {
        MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed while creating memory context \"%s\".",
                           name)));
    }
 
    /*
     * Avoid writing code that can fail between here and MemoryContextCreate;
     * we'd leak the header if we ereport in this stretch.
     */
    dlist_init(&set->blocks);
 
    /* Fill in the initial block's block header */
    block = (GenerationBlock *) (((char *) set) + MAXALIGN(sizeof(GenerationContext)));
    /* determine the block size and initialize it */
    firstBlockSize = allocSize - MAXALIGN(sizeof(GenerationContext));
    GenerationBlockInit(block, firstBlockSize);
 
    /* add it to the doubly-linked list of blocks */
    dlist_push_head(&set->blocks, &block->node);
 
    /* use it as the current allocation block */
    set->block = block;
 
    /* No free block, yet */
    set->freeblock = NULL;
 
    /* Mark block as not to be released at reset time */
    set->keeper = block;
 
    /* Fill in GenerationContext-specific header fields */
    set->initBlockSize = initBlockSize;
    set->maxBlockSize = maxBlockSize;
    set->nextBlockSize = initBlockSize;
 
    /*
     * Compute the allocation chunk size limit for this context.
     *
     * Follows similar ideas as AllocSet, see aset.c for details ...
     */
    set->allocChunkLimit = maxBlockSize;
    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,
                        &GenerationMethods,
                        parent,
                        name);
 
    ((MemoryContext) set)->mem_allocated = firstBlockSize;
 
    return (MemoryContext) set;
}

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

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

GenerationDelete()

static void GenerationDelete ( MemoryContext  context )

static

Definition at line 375 of file generation.c.

{
    /* Reset to release all releasable GenerationBlocks */
    GenerationReset(context);
    /* And free the context header and keeper block */
    free(context);
}

References free, and GenerationReset().

GenerationFree()

static void GenerationFree ( MemoryContext  context, void *  pointer  )

static

Definition at line 665 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    GenerationChunk *chunk = GenerationPointerGetChunk(pointer);
    GenerationBlock *block;
 
    /* Allow access to private part of chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, GENERATIONCHUNK_PRIVATE_LEN);
 
    block = chunk->block;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Test for someone scribbling on unused space in chunk */
    if (chunk->requested_size < chunk->size)
        if (!sentinel_ok(pointer, chunk->requested_size))
            elog(WARNING, "detected write past chunk end in %s %p",
                 ((MemoryContext) set)->name, chunk);
#endif
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(pointer, chunk->size);
#endif
 
    /* Reset context to NULL in freed chunks */
    chunk->context = NULL;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Reset requested_size to 0 in freed chunks */
    chunk->requested_size = 0;
#endif
 
    block->nfree += 1;
 
    Assert(block->nchunks > 0);
    Assert(block->nfree <= block->nchunks);
 
    /* If there are still allocated chunks in the block, we're done. */
    if (block->nfree < block->nchunks)
        return;
 
    /* Don't try to free the keeper block, just mark it empty */
    if (block == set->keeper)
    {
        GenerationBlockMarkEmpty(block);
        return;
    }
 
    /*
     * If there is no freeblock set or if this is the freeblock then instead
     * of freeing this memory, we keep it around so that new allocations have
     * the option of recycling it.
     */
    if (set->freeblock == NULL || set->freeblock == block)
    {
        /* XXX should we only recycle maxBlockSize sized blocks? */
        set->freeblock = block;
        GenerationBlockMarkEmpty(block);
        return;
    }
 
    /* Also make sure the block is not marked as the current block. */
    if (set->block == block)
        set->block = NULL;
 
    /*
     * The block is empty, so let's get rid of it. First remove it from the
     * list of blocks, then return it to malloc().
     */
    dlist_delete(&block->node);
 
    context->mem_allocated -= block->blksize;
    free(block);
}

References Assert(), GenerationBlock::blksize, GenerationContext::block, GenerationChunk::block, GenerationChunk::context, dlist_delete(), elog, free, GenerationContext::freeblock, GenerationBlockMarkEmpty(), GENERATIONCHUNK_PRIVATE_LEN, GenerationPointerGetChunk, GenerationContext::keeper, MemoryContextData::mem_allocated, name, GenerationBlock::nchunks, GenerationBlock::nfree, GenerationBlock::node, GenerationChunk::size, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

Referenced by GenerationRealloc().

GenerationGetChunkSpace()

static Size GenerationGetChunkSpace ( MemoryContext  context, void *  pointer  )

static

Definition at line 862 of file generation.c.

{
    GenerationChunk *chunk = GenerationPointerGetChunk(pointer);
    Size        result;
 
    VALGRIND_MAKE_MEM_DEFINED(chunk, GENERATIONCHUNK_PRIVATE_LEN);
    result = chunk->size + Generation_CHUNKHDRSZ;
    VALGRIND_MAKE_MEM_NOACCESS(chunk, GENERATIONCHUNK_PRIVATE_LEN);
    return result;
}

References Generation_CHUNKHDRSZ, GENERATIONCHUNK_PRIVATE_LEN, GenerationPointerGetChunk, GenerationChunk::size, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

GenerationIsEmpty()

static bool GenerationIsEmpty ( MemoryContext  context )

static

Definition at line 878 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    dlist_iter  iter;
 
    dlist_foreach(iter, &set->blocks)
    {
        GenerationBlock *block = dlist_container(GenerationBlock, node, iter.cur);
 
        if (block->nchunks > 0)
            return false;
    }
 
    return true;
}

References GenerationContext::blocks, dlist_iter::cur, dlist_container, dlist_foreach, and GenerationBlock::nchunks.

GenerationRealloc()

static void * GenerationRealloc ( MemoryContext  context, void *  pointer, Size  size  )

static

Definition at line 746 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    GenerationChunk *chunk = GenerationPointerGetChunk(pointer);
    GenerationPointer newPointer;
    Size        oldsize;
 
    /* Allow access to private part of chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, GENERATIONCHUNK_PRIVATE_LEN);
 
    oldsize = chunk->size;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Test for someone scribbling on unused space in chunk */
    if (chunk->requested_size < oldsize)
        if (!sentinel_ok(pointer, chunk->requested_size))
            elog(WARNING, "detected write past chunk end in %s %p",
                 ((MemoryContext) set)->name, chunk);
#endif
 
    /*
     * Maybe the allocated area already is >= the new size.  (In particular,
     * we always fall out here if the requested size is a decrease.)
     *
     * This memory context does not use power-of-2 chunk sizing and instead
     * carves the chunks to be as small as possible, so most repalloc() calls
     * will end up in the palloc/memcpy/pfree branch.
     *
     * XXX Perhaps we should annotate this condition with unlikely()?
     */
    if (oldsize >= size)
    {
#ifdef MEMORY_CONTEXT_CHECKING
        Size        oldrequest = chunk->requested_size;
 
#ifdef RANDOMIZE_ALLOCATED_MEMORY
        /* We can only fill the extra space if we know the prior request */
        if (size > oldrequest)
            randomize_mem((char *) pointer + oldrequest,
                          size - oldrequest);
#endif
 
        chunk->requested_size = size;
 
        /*
         * If this is an increase, mark any newly-available part UNDEFINED.
         * Otherwise, mark the obsolete part NOACCESS.
         */
        if (size > oldrequest)
            VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + oldrequest,
                                        size - oldrequest);
        else
            VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size,
                                       oldsize - size);
 
        /* set mark to catch clobber of "unused" space */
        if (size < oldsize)
            set_sentinel(pointer, size);
#else                           /* !MEMORY_CONTEXT_CHECKING */
 
        /*
         * We don't have the information to determine whether we're growing
         * the old request or shrinking it, so we conservatively mark the
         * entire new allocation DEFINED.
         */
        VALGRIND_MAKE_MEM_NOACCESS(pointer, oldsize);
        VALGRIND_MAKE_MEM_DEFINED(pointer, size);
#endif
 
        /* Disallow external access to private part of chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, GENERATIONCHUNK_PRIVATE_LEN);
 
        return pointer;
    }
 
    /* allocate new chunk */
    newPointer = GenerationAlloc((MemoryContext) set, size);
 
    /* leave immediately if request was not completed */
    if (newPointer == NULL)
    {
        /* Disallow external access to private part of chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, GENERATIONCHUNK_PRIVATE_LEN);
        return NULL;
    }
 
    /*
     * GenerationAlloc() may have returned a region that is still NOACCESS.
     * Change it to UNDEFINED for the moment; memcpy() will then transfer
     * definedness from the old allocation to the new.  If we know the old
     * allocation, copy just that much.  Otherwise, make the entire old chunk
     * defined to avoid errors as we copy the currently-NOACCESS trailing
     * bytes.
     */
    VALGRIND_MAKE_MEM_UNDEFINED(newPointer, size);
#ifdef MEMORY_CONTEXT_CHECKING
    oldsize = chunk->requested_size;
#else
    VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
#endif
 
    /* transfer existing data (certain to fit) */
    memcpy(newPointer, pointer, oldsize);
 
    /* free old chunk */
    GenerationFree((MemoryContext) set, pointer);
 
    return newPointer;
}

References elog, GenerationAlloc(), GENERATIONCHUNK_PRIVATE_LEN, GenerationFree(), GenerationPointerGetChunk, name, GenerationChunk::size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

GenerationReset()

static void GenerationReset ( MemoryContext  context )

static

Definition at line 330 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    dlist_mutable_iter miter;
 
    AssertArg(GenerationIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    GenerationCheck(context);
#endif
 
    /*
     * NULLify the free block pointer.  We must do this before calling
     * GenerationBlockFree as that function never expects to free the
     * freeblock.
     */
    set->freeblock = NULL;
 
    dlist_foreach_modify(miter, &set->blocks)
    {
        GenerationBlock *block = dlist_container(GenerationBlock, node, miter.cur);
 
        if (block == set->keeper)
            GenerationBlockMarkEmpty(block);
        else
            GenerationBlockFree(set, block);
    }
 
    /* set it so new allocations to make use of the keeper block */
    set->block = set->keeper;
 
    /* 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(), AssertArg, GenerationContext::block, GenerationContext::blocks, dlist_mutable_iter::cur, dlist_container, dlist_foreach_modify, dlist_has_next(), dlist_head_node(), dlist_is_empty(), GenerationContext::freeblock, GenerationBlockFree(), GenerationBlockMarkEmpty(), GenerationIsValid, GenerationContext::initBlockSize, GenerationContext::keeper, and GenerationContext::nextBlockSize.

Referenced by GenerationDelete().

GenerationStats()

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

static

Definition at line 907 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    Size        nblocks = 0;
    Size        nchunks = 0;
    Size        nfreechunks = 0;
    Size        totalspace;
    Size        freespace = 0;
    dlist_iter  iter;
 
    /* Include context header in totalspace */
    totalspace = MAXALIGN(sizeof(GenerationContext));
 
    dlist_foreach(iter, &set->blocks)
    {
        GenerationBlock *block = dlist_container(GenerationBlock, node, iter.cur);
 
        nblocks++;
        nchunks += block->nchunks;
        nfreechunks += block->nfree;
        totalspace += block->blksize;
        freespace += (block->endptr - block->freeptr);
    }
 
    if (printfunc)
    {
        char        stats_string[200];
 
        snprintf(stats_string, sizeof(stats_string),
                 "%zu total in %zu blocks (%zu chunks); %zu free (%zu chunks); %zu used",
                 totalspace, nblocks, nchunks, freespace,
                 nfreechunks, totalspace - freespace);
        printfunc(context, passthru, stats_string, print_to_stderr);
    }
 
    if (totals)
    {
        totals->nblocks += nblocks;
        totals->freechunks += nfreechunks;
        totals->totalspace += totalspace;
        totals->freespace += freespace;
    }
}

References GenerationBlock::blksize, GenerationContext::blocks, dlist_iter::cur, dlist_container, dlist_foreach, GenerationBlock::endptr, MemoryContextCounters::freechunks, GenerationBlock::freeptr, MemoryContextCounters::freespace, MAXALIGN, MemoryContextCounters::nblocks, GenerationBlock::nchunks, GenerationBlock::nfree, snprintf, and MemoryContextCounters::totalspace.

Variable Documentation

GenerationMethods

const MemoryContextMethods GenerationMethods

static

Initial value:

= {
    GenerationAlloc,
    GenerationFree,
    GenerationRealloc,
    GenerationReset,
    GenerationDelete,
    GenerationGetChunkSpace,
    GenerationIsEmpty,
    GenerationStats
 
 
 
}

Definition at line 184 of file generation.c.

Referenced by GenerationContextCreate().