generation.c File Reference

#include "postgres.h"
#include "lib/ilist.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	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 *	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 blockSize)

Variables
static const MemoryContextMethods	GenerationMethods

Macro Definition Documentation

Generation_BLOCKHDRSZ

#define Generation_BLOCKHDRSZ   MAXALIGN(sizeof(GenerationBlock))

Definition at line 46 of file generation.c.

Referenced by GenerationAlloc(), and GenerationStats().

Generation_CHUNKHDRSZ

#define Generation_CHUNKHDRSZ   sizeof(GenerationChunk)

Definition at line 47 of file generation.c.

Referenced by GenerationAlloc(), GenerationContextCreate(), GenerationGetChunkSpace(), and GenerationStats().

GENERATIONCHUNK_PRIVATE_LEN

#define GENERATIONCHUNK_PRIVATE_LEN   offsetof(GenerationChunk, context)

Definition at line 133 of file generation.c.

Referenced by GenerationAlloc(), GenerationFree(), GenerationGetChunkSpace(), GenerationRealloc(), and GenerationStats().

GENERATIONCHUNK_RAWSIZE

#define GENERATIONCHUNK_RAWSIZE   (SIZEOF_SIZE_T + SIZEOF_VOID_P * 2)

Definition at line 114 of file generation.c.

GenerationChunkGetPointer

#define GenerationChunkGetPointer

(

chk

)

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

Definition at line 143 of file generation.c.

Referenced by GenerationAlloc().

GenerationIsValid

#define GenerationIsValid

(

set

)

PointerIsValid(set)

Definition at line 139 of file generation.c.

Referenced by GenerationReset().

GenerationPointerGetChunk

#define GenerationPointerGetChunk

(

ptr

)

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

Definition at line 141 of file generation.c.

Referenced by GenerationFree(), GenerationGetChunkSpace(), and GenerationRealloc().

Typedef Documentation

GenerationBlock

typedef struct GenerationBlock GenerationBlock

Definition at line 49 of file generation.c.

GenerationChunk

typedef struct GenerationChunk GenerationChunk

Definition at line 50 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 326 of file generation.c.

References Assert, GenerationBlock::blksize, GenerationContext::block, GenerationChunk::block, GenerationChunk::context, dlist_push_head(), GenerationBlock::endptr, GenerationBlock::freeptr, Generation_BLOCKHDRSZ, Generation_CHUNKHDRSZ, GENERATIONCHUNK_PRIVATE_LEN, GenerationChunkGetPointer, malloc, MAXALIGN, MemoryContextData::mem_allocated, GenerationBlock::nchunks, GenerationBlock::nfree, GenerationBlock::node, GenerationChunk::size, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by GenerationRealloc().

{
    GenerationContext *set = (GenerationContext *) context;
    GenerationBlock *block;
    GenerationChunk *chunk;
    Size        chunk_size = MAXALIGN(size);

    /* is it an over-sized chunk? if yes, allocate special block */
    if (chunk_size > set->blockSize / 8)
    {
        Size        blksize = chunk_size + Generation_BLOCKHDRSZ + Generation_CHUNKHDRSZ;

        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 over-sized chunk. Is there enough space in the current block? If
     * not, allocate a new "regular" block.
     */
    block = set->block;

    if ((block == NULL) ||
        (block->endptr - block->freeptr) < Generation_CHUNKHDRSZ + chunk_size)
    {
        Size        blksize = set->blockSize;

        block = (GenerationBlock *) malloc(blksize);

        if (block == NULL)
            return NULL;

        context->mem_allocated += blksize;

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

        /* add it to the doubly-linked list of blocks */
        dlist_push_head(&set->blocks, &block->node);

        /* 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);
}

GenerationContextCreate()

MemoryContext GenerationContextCreate	(	MemoryContext	parent,
		const char *	name,
		Size	blockSize
	)

Definition at line 197 of file generation.c.

References AllocHugeSizeIsValid, GenerationContext::blockSize, dlist_init(), elog, ereport, errcode(), errdetail(), errmsg(), ERROR, Generation_CHUNKHDRSZ, malloc, MAXALIGN, MemoryContextCreate(), MemoryContextStats(), offsetof, StaticAssertStmt, T_GenerationContext, and TopMemoryContext.

Referenced by gistvacuumscan(), and ReorderBufferAllocate().

{
    GenerationContext *set;

    /* 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.  (If we're going to throw an
     * error, we should do so before the context is created, not after.)  We
     * somewhat arbitrarily enforce a minimum 1K block size, mostly because
     * that's what AllocSet does.
     */
    if (blockSize != MAXALIGN(blockSize) ||
        blockSize < 1024 ||
        !AllocHugeSizeIsValid(blockSize))
        elog(ERROR, "invalid blockSize for memory context: %zu",
             blockSize);

    /*
     * Allocate the context header.  Unlike aset.c, we never try to combine
     * this with the first regular block, since that would prevent us from
     * freeing the first generation of allocations.
     */

    set = (GenerationContext *) malloc(MAXALIGN(sizeof(GenerationContext)));
    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.
     */

    /* Fill in GenerationContext-specific header fields */
    set->blockSize = blockSize;
    set->block = NULL;
    dlist_init(&set->blocks);

    /* Finally, do the type-independent part of context creation */
    MemoryContextCreate((MemoryContext) set,
                        T_GenerationContext,
                        &GenerationMethods,
                        parent,
                        name);

    return (MemoryContext) set;
}

GenerationDelete()

static void GenerationDelete ( MemoryContext  context )

static

Definition at line 304 of file generation.c.

References free, and GenerationReset().

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

GenerationFree()

static void GenerationFree ( MemoryContext  context, void *  pointer  )

static

Definition at line 462 of file generation.c.

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

Referenced by GenerationRealloc().

{
    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;

    /*
     * 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);

    /* Also make sure the block is not marked as the current block. */
    if (set->block == block)
        set->block = NULL;

    context->mem_allocated -= block->blksize;
    free(block);
}

GenerationGetChunkSpace()

static Size GenerationGetChunkSpace ( MemoryContext  context, void *  pointer  )

static

Definition at line 639 of file generation.c.

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

{
    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;
}

GenerationIsEmpty()

static bool GenerationIsEmpty ( MemoryContext  context )

static

Definition at line 655 of file generation.c.

References dlist_is_empty().

{
    GenerationContext *set = (GenerationContext *) context;

    return dlist_is_empty(&set->blocks);
}

GenerationRealloc()

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

static

Definition at line 523 of file generation.c.

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.

{
    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;
}

GenerationReset()

static void GenerationReset ( MemoryContext  context )

static

Definition at line 267 of file generation.c.

References Assert, AssertArg, GenerationBlock::blksize, GenerationContext::block, dlist_mutable_iter::cur, dlist_container, dlist_delete(), dlist_foreach_modify, dlist_is_empty(), free, GenerationIsValid, and MemoryContextData::mem_allocated.

Referenced by GenerationDelete().

{
    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

    dlist_foreach_modify(miter, &set->blocks)
    {
        GenerationBlock *block = dlist_container(GenerationBlock, node, miter.cur);

        dlist_delete(miter.cur);

        context->mem_allocated -= block->blksize;

#ifdef CLOBBER_FREED_MEMORY
        wipe_mem(block, block->blksize);
#endif

        free(block);
    }

    set->block = NULL;

    Assert(dlist_is_empty(&set->blocks));
}

GenerationStats()

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

static

Definition at line 675 of file generation.c.

References Assert, GenerationBlock::blksize, GenerationContext::block, GenerationChunk::block, GenerationContext::blocks, GenerationChunk::context, dlist_iter::cur, dlist_container, dlist_foreach, elog, GenerationBlock::endptr, MemoryContextCounters::freechunks, GenerationBlock::freeptr, MemoryContextCounters::freespace, Generation_BLOCKHDRSZ, Generation_CHUNKHDRSZ, GENERATIONCHUNK_PRIVATE_LEN, MAXALIGN, MemoryContextData::mem_allocated, MemoryContextData::name, name, MemoryContextCounters::nblocks, GenerationBlock::nchunks, GenerationBlock::nfree, GenerationChunk::size, snprintf, MemoryContextCounters::totalspace, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and WARNING.

{
    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 %zd blocks (%zd chunks); %zu free (%zd 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;
    }
}

Variable Documentation

GenerationMethods

const MemoryContextMethods GenerationMethods

static

Initial value:

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



}

Definition at line 168 of file generation.c.