memutils_internal.h File Reference

#include "utils/memutils.h"

Include dependency graph for memutils_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	PallocAlignedExtraBytes(alignto)    ((alignto) + (sizeof(MemoryChunk) - MAXIMUM_ALIGNOF))
#define	MEMORY_CONTEXT_METHODID_BITS   4
#define	MEMORY_CONTEXT_METHODID_MASK    ((((uint64) 1) << MEMORY_CONTEXT_METHODID_BITS) - 1)

Typedefs
typedef enum MemoryContextMethodID	MemoryContextMethodID

Enumerations
enum	MemoryContextMethodID {   MCTX_0_RESERVED_UNUSEDMEM_ID , MCTX_1_RESERVED_GLIBC_ID , MCTX_2_RESERVED_GLIBC_ID , MCTX_ASET_ID ,   MCTX_GENERATION_ID , MCTX_SLAB_ID , MCTX_ALIGNED_REDIRECT_ID , MCTX_BUMP_ID ,   MCTX_8_UNUSED_ID , MCTX_9_UNUSED_ID , MCTX_10_UNUSED_ID , MCTX_11_UNUSED_ID ,   MCTX_12_UNUSED_ID , MCTX_13_UNUSED_ID , MCTX_14_UNUSED_ID , MCTX_15_RESERVED_WIPEDMEM_ID }

Functions
void *	AllocSetAlloc (MemoryContext context, Size size, int flags)
void	AllocSetFree (void *pointer)
void *	AllocSetRealloc (void *pointer, Size size, int flags)
void	AllocSetReset (MemoryContext context)
void	AllocSetDelete (MemoryContext context)
MemoryContext	AllocSetGetChunkContext (void *pointer)
Size	AllocSetGetChunkSpace (void *pointer)
bool	AllocSetIsEmpty (MemoryContext context)
void	AllocSetStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals, bool print_to_stderr)
void *	GenerationAlloc (MemoryContext context, Size size, int flags)
void	GenerationFree (void *pointer)
void *	GenerationRealloc (void *pointer, Size size, int flags)
void	GenerationReset (MemoryContext context)
void	GenerationDelete (MemoryContext context)
MemoryContext	GenerationGetChunkContext (void *pointer)
Size	GenerationGetChunkSpace (void *pointer)
bool	GenerationIsEmpty (MemoryContext context)
void	GenerationStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals, bool print_to_stderr)
void *	SlabAlloc (MemoryContext context, Size size, int flags)
void	SlabFree (void *pointer)
void *	SlabRealloc (void *pointer, Size size, int flags)
void	SlabReset (MemoryContext context)
void	SlabDelete (MemoryContext context)
MemoryContext	SlabGetChunkContext (void *pointer)
Size	SlabGetChunkSpace (void *pointer)
bool	SlabIsEmpty (MemoryContext context)
void	SlabStats (MemoryContext context, MemoryStatsPrintFunc printfunc, void *passthru, MemoryContextCounters *totals, bool print_to_stderr)
void	AlignedAllocFree (void *pointer)
void *	AlignedAllocRealloc (void *pointer, Size size, int flags)
MemoryContext	AlignedAllocGetChunkContext (void *pointer)
Size	AlignedAllocGetChunkSpace (void *pointer)
void *	BumpAlloc (MemoryContext context, Size size, int flags)
void	BumpFree (void *pointer)
void *	BumpRealloc (void *pointer, Size size, int flags)
void	BumpReset (MemoryContext context)
void	BumpDelete (MemoryContext context)
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)
void	MemoryContextCreate (MemoryContext node, NodeTag tag, MemoryContextMethodID method_id, MemoryContext parent, const char *name)
void *	MemoryContextAllocationFailure (MemoryContext context, Size size, int flags)
pg_noreturn void	MemoryContextSizeFailure (MemoryContext context, Size size, int flags)
static void	MemoryContextCheckSize (MemoryContext context, Size size, int flags)

Macro Definition Documentation

MEMORY_CONTEXT_METHODID_BITS

#define MEMORY_CONTEXT_METHODID_BITS   4

Definition at line 145 of file memutils_internal.h.

MEMORY_CONTEXT_METHODID_MASK

#define MEMORY_CONTEXT_METHODID_MASK    ((((uint64) 1) << MEMORY_CONTEXT_METHODID_BITS) - 1)

Definition at line 146 of file memutils_internal.h.

{
    if (unlikely(!AllocSizeIsValid(size)))
    {
        if (!(flags & MCXT_ALLOC_HUGE) || !AllocHugeSizeIsValid(size))
            MemoryContextSizeFailure(context, size, flags);
    }
}
 
#endif                          /* MEMUTILS_INTERNAL_H */

PallocAlignedExtraBytes

#define PallocAlignedExtraBytes

(

alignto

)

((alignto) + (sizeof(MemoryChunk) - MAXIMUM_ALIGNOF))

Definition at line 104 of file memutils_internal.h.

Typedef Documentation

MemoryContextMethodID

typedef enum MemoryContextMethodID MemoryContextMethodID

Enumeration Type Documentation

MemoryContextMethodID

enum MemoryContextMethodID

Enumerator
MCTX_0_RESERVED_UNUSEDMEM_ID
MCTX_1_RESERVED_GLIBC_ID
MCTX_2_RESERVED_GLIBC_ID
MCTX_ASET_ID
MCTX_GENERATION_ID
MCTX_SLAB_ID
MCTX_ALIGNED_REDIRECT_ID
MCTX_BUMP_ID
MCTX_8_UNUSED_ID
MCTX_9_UNUSED_ID
MCTX_10_UNUSED_ID
MCTX_11_UNUSED_ID
MCTX_12_UNUSED_ID
MCTX_13_UNUSED_ID
MCTX_14_UNUSED_ID
MCTX_15_RESERVED_WIPEDMEM_ID

Definition at line 121 of file memutils_internal.h.

{
    MCTX_0_RESERVED_UNUSEDMEM_ID,   /* 0000 occurs in never-used memory */
    MCTX_1_RESERVED_GLIBC_ID,   /* glibc malloc'd chunks usually match 0001 */
    MCTX_2_RESERVED_GLIBC_ID,   /* glibc malloc'd chunks > 128kB match 0010 */
    MCTX_ASET_ID,
    MCTX_GENERATION_ID,
    MCTX_SLAB_ID,
    MCTX_ALIGNED_REDIRECT_ID,
    MCTX_BUMP_ID,
    MCTX_8_UNUSED_ID,
    MCTX_9_UNUSED_ID,
    MCTX_10_UNUSED_ID,
    MCTX_11_UNUSED_ID,
    MCTX_12_UNUSED_ID,
    MCTX_13_UNUSED_ID,
    MCTX_14_UNUSED_ID,
    MCTX_15_RESERVED_WIPEDMEM_ID    /* 1111 occurs in wipe_mem'd memory */
} MemoryContextMethodID;

Function Documentation

AlignedAllocFree()

void AlignedAllocFree ( void *  pointer )

extern

Definition at line 29 of file alignedalloc.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    void       *unaligned;
 
    VALGRIND_MAKE_MEM_DEFINED(chunk, sizeof(MemoryChunk));
 
    Assert(!MemoryChunkIsExternal(chunk));
 
    /* obtain the original (unaligned) allocated pointer */
    unaligned = MemoryChunkGetBlock(chunk);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Test for someone scribbling on unused space in chunk */
    if (!sentinel_ok(pointer, chunk->requested_size))
        elog(WARNING, "detected write past chunk end in %s %p",
             GetMemoryChunkContext(unaligned)->name, chunk);
#endif
 
    /*
     * Create a dummy vchunk covering the start of the unaligned chunk, but
     * not overlapping the aligned chunk.  This will be freed while pfree'ing
     * the unaligned chunk, keeping Valgrind happy.  Then when we return to
     * the outer pfree, that will clean up the vchunk for the aligned chunk.
     */
    VALGRIND_MEMPOOL_ALLOC(GetMemoryChunkContext(unaligned), unaligned,
                           (char *) pointer - (char *) unaligned);
 
    /* Recursively pfree the unaligned chunk */
    pfree(unaligned);
}

References Assert, elog, fb(), GetMemoryChunkContext(), MemoryChunkGetBlock(), MemoryChunkIsExternal(), name, pfree(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MEMPOOL_ALLOC, and WARNING.

AlignedAllocGetChunkContext()

MemoryContext AlignedAllocGetChunkContext ( void *  pointer )

extern

Definition at line 154 of file alignedalloc.c.

{
    MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
    MemoryContext cxt;
 
    VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
 
    Assert(!MemoryChunkIsExternal(redirchunk));
 
    cxt = GetMemoryChunkContext(MemoryChunkGetBlock(redirchunk));
 
    VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
 
    return cxt;
}

References Assert, fb(), GetMemoryChunkContext(), MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AlignedAllocGetChunkSpace()

Size AlignedAllocGetChunkSpace ( void *  pointer )

extern

Definition at line 176 of file alignedalloc.c.

{
    MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
    void       *unaligned;
    Size        space;
 
    VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
 
    unaligned = MemoryChunkGetBlock(redirchunk);
    space = GetMemoryChunkSpace(unaligned);
 
    VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
 
    return space;
}

References fb(), GetMemoryChunkSpace(), MemoryChunkGetBlock(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AlignedAllocRealloc()

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

extern

Definition at line 70 of file alignedalloc.c.

{
    MemoryChunk *redirchunk = PointerGetMemoryChunk(pointer);
    Size        alignto;
    void       *unaligned;
    MemoryContext ctx;
    Size        old_size;
    void       *newptr;
 
    VALGRIND_MAKE_MEM_DEFINED(redirchunk, sizeof(MemoryChunk));
 
    alignto = MemoryChunkGetValue(redirchunk);
    unaligned = MemoryChunkGetBlock(redirchunk);
 
    /* sanity check this is a power of 2 value */
    Assert((alignto & (alignto - 1)) == 0);
 
    /*
     * Determine the size of the original allocation.  We can't determine this
     * exactly as GetMemoryChunkSpace() returns the total space used for the
     * allocation, which for contexts like aset includes rounding up to the
     * next power of 2.  However, this value is just used to memcpy() the old
     * data into the new allocation, so we only need to concern ourselves with
     * not reading beyond the end of the original allocation's memory.  The
     * drawback here is that we may copy more bytes than we need to, which
     * only amounts to wasted effort.  We can safely subtract the extra bytes
     * that we requested to allow us to align the pointer.  We must also
     * subtract the space for the unaligned pointer's MemoryChunk since
     * GetMemoryChunkSpace should have included that.  This does assume that
     * all context types use MemoryChunk as a chunk header.
     */
    old_size = GetMemoryChunkSpace(unaligned) -
        PallocAlignedExtraBytes(alignto) - sizeof(MemoryChunk);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* check that GetMemoryChunkSpace returned something realistic */
    Assert(old_size >= redirchunk->requested_size);
#endif
 
    /*
     * To keep things simple, we always allocate a new aligned chunk and copy
     * data into it.  Because of the above inaccuracy, this may end in copying
     * more data than was in the original allocation request size, but that
     * should be OK.
     */
    ctx = GetMemoryChunkContext(unaligned);
    newptr = MemoryContextAllocAligned(ctx, size, alignto, flags);
 
    /* Cope cleanly with OOM */
    if (unlikely(newptr == NULL))
    {
        VALGRIND_MAKE_MEM_NOACCESS(redirchunk, sizeof(MemoryChunk));
        return MemoryContextAllocationFailure(ctx, size, flags);
    }
 
    /*
     * We may memcpy more than the original allocation request size, which
     * would result in trying to copy trailing bytes that the original
     * MemoryContextAllocAligned call marked NOACCESS.  So we must mark the
     * entire old_size as defined.  That's slightly annoying, but probably not
     * worth improving.
     */
    VALGRIND_MAKE_MEM_DEFINED(pointer, old_size);
    memcpy(newptr, pointer, Min(size, old_size));
 
    /*
     * Create a dummy vchunk covering the start of the old unaligned chunk,
     * but not overlapping the aligned chunk.  This will be freed while
     * pfree'ing the old unaligned chunk, keeping Valgrind happy.  Then when
     * we return to repalloc, it will move the vchunk for the aligned chunk.
     */
    VALGRIND_MEMPOOL_ALLOC(ctx, unaligned,
                           (char *) pointer - (char *) unaligned);
 
    pfree(unaligned);
 
    return newptr;
}

References Assert, fb(), GetMemoryChunkContext(), GetMemoryChunkSpace(), memcpy(), MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryContextAllocAligned(), MemoryContextAllocationFailure(), Min, PallocAlignedExtraBytes, pfree(), PointerGetMemoryChunk, unlikely, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MEMPOOL_ALLOC.

AllocSetAlloc()

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

extern

Definition at line 1012 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    AllocBlock  block;
    MemoryChunk *chunk;
    int         fidx;
    Size        chunk_size;
    Size        availspace;
 
    Assert(AllocSetIsValid(set));
 
    /* due to the keeper block set->blocks should never be NULL */
    Assert(set->blocks != NULL);
 
    /*
     * If requested size exceeds maximum for chunks we hand the request off to
     * AllocSetAllocLarge().
     */
    if (size > set->allocChunkLimit)
        return AllocSetAllocLarge(context, size, flags);
 
    /*
     * Request is small enough to be treated as a chunk.  Look in the
     * corresponding free list to see if there is a free chunk we could reuse.
     * If one is found, remove it from the free list, make it again a member
     * of the alloc set and return its data address.
     *
     * Note that we don't attempt to ensure there's space for the sentinel
     * byte here.  We expect a large proportion of allocations to be for sizes
     * which are already a power of 2.  If we were to always make space for a
     * sentinel byte in MEMORY_CONTEXT_CHECKING builds, then we'd end up
     * doubling the memory requirements for such allocations.
     */
    fidx = AllocSetFreeIndex(size);
    chunk = set->freelist[fidx];
    if (chunk != NULL)
    {
        AllocFreeListLink *link = GetFreeListLink(chunk);
 
        /* Allow access to the chunk header. */
        VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
        Assert(fidx == MemoryChunkGetValue(chunk));
 
        /* pop this chunk off the freelist */
        VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
        set->freelist[fidx] = link->next;
        VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
 
#ifdef MEMORY_CONTEXT_CHECKING
        chunk->requested_size = size;
        /* set mark to catch clobber of "unused" space */
        if (size < GetChunkSizeFromFreeListIdx(fidx))
            set_sentinel(MemoryChunkGetPointer(chunk), size);
#endif
#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,
                                   GetChunkSizeFromFreeListIdx(fidx) - size);
 
        /* Disallow access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
        return MemoryChunkGetPointer(chunk);
    }
 
    /*
     * Choose the actual chunk size to allocate.
     */
    chunk_size = GetChunkSizeFromFreeListIdx(fidx);
    Assert(chunk_size >= size);
 
    block = set->blocks;
    availspace = block->endptr - block->freeptr;
 
    /*
     * If there is enough room in the active allocation block, we will put the
     * chunk into that block.  Else must start a new one.
     */
    if (unlikely(availspace < (chunk_size + ALLOC_CHUNKHDRSZ)))
        return AllocSetAllocFromNewBlock(context, size, flags, fidx);
 
    /* There's enough space on the current block, so allocate from that */
    return AllocSetAllocChunkFromBlock(context, block, size, chunk_size, fidx);
}

References ALLOC_CHUNKHDRSZ, AllocSetContext::allocChunkLimit, AllocSetAllocChunkFromBlock(), AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetFreeIndex(), AllocSetIsValid, Assert, AllocSetContext::blocks, AllocBlockData::endptr, fb(), AllocSetContext::freelist, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, MemoryChunkGetPointer, MemoryChunkGetValue(), unlikely, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by AllocSetRealloc().

AllocSetDelete()

void AllocSetDelete ( MemoryContext  context )

extern

Definition at line 632 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    AllocBlock  block = set->blocks;
    Size        keepersize PG_USED_FOR_ASSERTS_ONLY;
 
    Assert(AllocSetIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    AllocSetCheck(context);
#endif
 
    /* Remember keeper block size for Assert below */
    keepersize = KeeperBlock(set)->endptr - ((char *) set);
 
    /*
     * If the context is a candidate for a freelist, put it into that freelist
     * instead of destroying it.
     */
    if (set->freeListIndex >= 0)
    {
        AllocSetFreeList *freelist = &context_freelists[set->freeListIndex];
 
        /*
         * Reset the context, if it needs it, so that we aren't hanging on to
         * more than the initial malloc chunk.
         */
        if (!context->isReset)
            MemoryContextResetOnly(context);
 
        /*
         * If the freelist is full, just discard what's already in it.  See
         * comments with context_freelists[].
         */
        if (freelist->num_free >= MAX_FREE_CONTEXTS)
        {
            while (freelist->first_free != NULL)
            {
                AllocSetContext *oldset = freelist->first_free;
 
                freelist->first_free = (AllocSetContext *) oldset->header.nextchild;
                freelist->num_free--;
 
                /* Destroy the context's vpool --- see notes below */
                VALGRIND_DESTROY_MEMPOOL(oldset);
 
                /* All that remains is to free the header/initial block */
                free(oldset);
            }
            Assert(freelist->num_free == 0);
        }
 
        /* Now add the just-deleted context to the freelist. */
        set->header.nextchild = (MemoryContext) freelist->first_free;
        freelist->first_free = set;
        freelist->num_free++;
 
        return;
    }
 
    /* Free all blocks, except the keeper which is part of context header */
    while (block != NULL)
    {
        AllocBlock  next = block->next;
 
        if (!IsKeeperBlock(set, block))
            context->mem_allocated -= block->endptr - ((char *) block);
 
#ifdef CLOBBER_FREED_MEMORY
        wipe_mem(block, block->freeptr - ((char *) block));
#endif
 
        if (!IsKeeperBlock(set, block))
        {
            /* As in AllocSetReset, free block-header vchunks explicitly */
            VALGRIND_MEMPOOL_FREE(set, block);
            free(block);
        }
 
        block = next;
    }
 
    Assert(context->mem_allocated == keepersize);
 
    /*
     * Destroy the vpool.  We don't seem to need to explicitly free the
     * initial block's header vchunk, nor any user-data vchunks that Valgrind
     * still knows about; they'll all go away automatically.
     */
    VALGRIND_DESTROY_MEMPOOL(set);
 
    /* Finally, free the context header, including the keeper block */
    free(set);
}

References AllocSetIsValid, Assert, AllocSetContext::blocks, context_freelists, AllocBlockData::endptr, fb(), AllocSetFreeList::first_free, free, AllocSetContext::freeListIndex, AllocBlockData::freeptr, AllocSetContext::header, IsKeeperBlock, MemoryContextData::isReset, KeeperBlock, MAX_FREE_CONTEXTS, MemoryContextData::mem_allocated, MemoryContextResetOnly(), next, AllocBlockData::next, MemoryContextData::nextchild, AllocSetFreeList::num_free, PG_USED_FOR_ASSERTS_ONLY, VALGRIND_DESTROY_MEMPOOL, and VALGRIND_MEMPOOL_FREE.

AllocSetFree()

void AllocSetFree ( void *  pointer )

extern

Definition at line 1107 of file aset.c.

{
    AllocSet    set;
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        /* Release single-chunk block. */
        AllocBlock  block = ExternalChunkGetBlock(chunk);
 
        /*
         * Try to verify that we have a sane block pointer: the block header
         * should reference an aset and the freeptr should match the endptr.
         */
        if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
            elog(ERROR, "could not find block containing chunk %p", chunk);
 
        set = block->aset;
 
#ifdef MEMORY_CONTEXT_CHECKING
        {
            /* Test for someone scribbling on unused space in chunk */
            Assert(chunk->requested_size < (block->endptr - (char *) pointer));
            if (!sentinel_ok(pointer, chunk->requested_size))
                elog(WARNING, "detected write past chunk end in %s %p",
                     set->header.name, chunk);
        }
#endif
 
        /* OK, remove block from aset's list and free it */
        if (block->prev)
            block->prev->next = block->next;
        else
            set->blocks = block->next;
        if (block->next)
            block->next->prev = block->prev;
 
        set->header.mem_allocated -= block->endptr - ((char *) block);
 
#ifdef CLOBBER_FREED_MEMORY
        wipe_mem(block, block->freeptr - ((char *) block));
#endif
 
        /* As in AllocSetReset, free block-header vchunks explicitly */
        VALGRIND_MEMPOOL_FREE(set, block);
 
        free(block);
    }
    else
    {
        AllocBlock  block = MemoryChunkGetBlock(chunk);
        int         fidx;
        AllocFreeListLink *link;
 
        /*
         * In this path, for speed reasons we just Assert that the referenced
         * block is good.  We can also Assert that the value field is sane.
         * Future field experience may show that these Asserts had better
         * become regular runtime test-and-elog checks.
         */
        Assert(AllocBlockIsValid(block));
        set = block->aset;
 
        fidx = MemoryChunkGetValue(chunk);
        Assert(FreeListIdxIsValid(fidx));
        link = GetFreeListLink(chunk);
 
        /*
         * It might seem odd that we use elevel ERROR for double-pfree but
         * only WARNING for write-past-chunk-end.  But the two conditions are
         * not very comparable.  In the double-pfree case we can prevent
         * corruption before it happens; while if we let it go through, the
         * result would be a corrupted freelist that allows this chunk to get
         * re-allocated twice.  Thus the original bug could cascade into
         * hard-to-understand misbehavior that might manifest far away from
         * the actual source of the problem.  On the other hand, a write past
         * chunk end can be relatively benign if just a few bytes too many
         * were written: often, only padding or unused space gets affected.
         * Moreover, whatever damage was done is already done, and we're just
         * reporting after the fact with no ability to clean it up.  So just
         * warn, like AllocSetCheck would do if the chunk didn't get freed.
         */
#ifdef MEMORY_CONTEXT_CHECKING
        /* Test for previously-freed chunk */
        if (unlikely(chunk->requested_size == InvalidAllocSize))
            elog(ERROR, "detected double pfree in %s %p",
                 set->header.name, chunk);
        /* Test for someone scribbling on unused space in chunk */
        if (chunk->requested_size < GetChunkSizeFromFreeListIdx(fidx))
            if (!sentinel_ok(pointer, chunk->requested_size))
                elog(WARNING, "detected write past chunk end in %s %p",
                     set->header.name, chunk);
#endif
 
#ifdef CLOBBER_FREED_MEMORY
        wipe_mem(pointer, GetChunkSizeFromFreeListIdx(fidx));
#endif
        /* push this chunk onto the top of the free list */
        VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
        link->next = set->freelist[fidx];
        VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
        set->freelist[fidx] = chunk;
 
#ifdef MEMORY_CONTEXT_CHECKING
 
        /*
         * Reset requested_size to InvalidAllocSize in chunks that are on free
         * list.
         */
        chunk->requested_size = InvalidAllocSize;
#endif
    }
}

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocBlockData::aset, Assert, AllocSetContext::blocks, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, fb(), free, AllocSetContext::freelist, FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, AllocSetContext::header, InvalidAllocSize, MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, unlikely, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MEMPOOL_FREE, and WARNING.

Referenced by AllocSetRealloc().

AllocSetGetChunkContext()

MemoryContext AllocSetGetChunkContext ( void *  pointer )

extern

Definition at line 1514 of file aset.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    AllocBlock  block;
    AllocSet    set;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
        block = ExternalChunkGetBlock(chunk);
    else
        block = (AllocBlock) MemoryChunkGetBlock(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
    Assert(AllocBlockIsValid(block));
    set = block->aset;
 
    return &set->header;
}

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocBlockData::aset, Assert, ExternalChunkGetBlock, AllocSetContext::header, MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetGetChunkSpace()

Size AllocSetGetChunkSpace ( void *  pointer )

extern

Definition at line 1543 of file aset.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    int         fidx;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        AllocBlock  block = ExternalChunkGetBlock(chunk);
 
        /* Disallow access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
        Assert(AllocBlockIsValid(block));
 
        return block->endptr - (char *) chunk;
    }
 
    fidx = MemoryChunkGetValue(chunk);
    Assert(FreeListIdxIsValid(fidx));
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
    return GetChunkSizeFromFreeListIdx(fidx) + ALLOC_CHUNKHDRSZ;
}

References ALLOC_CHUNKHDRSZ, AllocBlockIsValid, Assert, AllocBlockData::endptr, ExternalChunkGetBlock, fb(), FreeListIdxIsValid, GetChunkSizeFromFreeListIdx, MemoryChunkGetValue(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetIsEmpty()

bool AllocSetIsEmpty ( MemoryContext  context )

extern

Definition at line 1577 of file aset.c.

{
    Assert(AllocSetIsValid(context));
 
    /*
     * For now, we say "empty" only if the context is new or just reset. We
     * could examine the freelists to determine if all space has been freed,
     * but it's not really worth the trouble for present uses of this
     * functionality.
     */
    if (context->isReset)
        return true;
    return false;
}

References AllocSetIsValid, Assert, and MemoryContextData::isReset.

AllocSetRealloc()

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

extern

Definition at line 1237 of file aset.c.

{
    AllocBlock  block;
    AllocSet    set;
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    Size        oldchksize;
    int         fidx;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        /*
         * The chunk must have been allocated as a single-chunk block.  Use
         * realloc() to make the containing block bigger, or smaller, with
         * minimum space wastage.
         */
        AllocBlock  newblock;
        Size        chksize;
        Size        blksize;
        Size        oldblksize;
 
        block = ExternalChunkGetBlock(chunk);
 
        /*
         * Try to verify that we have a sane block pointer: the block header
         * should reference an aset and the freeptr should match the endptr.
         */
        if (!AllocBlockIsValid(block) || block->freeptr != block->endptr)
            elog(ERROR, "could not find block containing chunk %p", chunk);
 
        set = block->aset;
 
        /* only check size in paths where the limits could be hit */
        MemoryContextCheckSize((MemoryContext) set, size, flags);
 
        oldchksize = block->endptr - (char *) pointer;
 
#ifdef MEMORY_CONTEXT_CHECKING
        /* Test for someone scribbling on unused space in chunk */
        Assert(chunk->requested_size < oldchksize);
        if (!sentinel_ok(pointer, chunk->requested_size))
            elog(WARNING, "detected write past chunk end in %s %p",
                 set->header.name, chunk);
#endif
 
#ifdef MEMORY_CONTEXT_CHECKING
        /* ensure there's always space for the sentinel byte */
        chksize = MAXALIGN(size + 1);
#else
        chksize = MAXALIGN(size);
#endif
 
        /* Do the realloc */
        blksize = chksize + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
        oldblksize = block->endptr - ((char *) block);
 
        newblock = (AllocBlock) realloc(block, blksize);
        if (newblock == NULL)
        {
            /* Disallow access to the chunk header. */
            VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
            return MemoryContextAllocationFailure(&set->header, size, flags);
        }
 
        /*
         * Move the block-header vchunk explicitly.  (mcxt.c will take care of
         * moving the vchunk for the user data.)
         */
        VALGRIND_MEMPOOL_CHANGE(set, block, newblock, ALLOC_BLOCKHDRSZ);
        block = newblock;
 
        /* updated separately, not to underflow when (oldblksize > blksize) */
        set->header.mem_allocated -= oldblksize;
        set->header.mem_allocated += blksize;
 
        block->freeptr = block->endptr = ((char *) block) + blksize;
 
        /* Update pointers since block has likely been moved */
        chunk = (MemoryChunk *) (((char *) block) + ALLOC_BLOCKHDRSZ);
        pointer = MemoryChunkGetPointer(chunk);
        if (block->prev)
            block->prev->next = block;
        else
            set->blocks = block;
        if (block->next)
            block->next->prev = block;
 
#ifdef MEMORY_CONTEXT_CHECKING
#ifdef RANDOMIZE_ALLOCATED_MEMORY
 
        /*
         * We can only randomize the extra space if we know the prior request.
         * When using Valgrind, randomize_mem() also marks memory UNDEFINED.
         */
        if (size > chunk->requested_size)
            randomize_mem((char *) pointer + chunk->requested_size,
                          size - chunk->requested_size);
#else
 
        /*
         * If this is an increase, realloc() will have marked any
         * newly-allocated part (from oldchksize to chksize) UNDEFINED, but we
         * also need to adjust trailing bytes from the old allocation (from
         * chunk->requested_size to oldchksize) as they are marked NOACCESS.
         * Make sure not to mark too many bytes in case chunk->requested_size
         * < size < oldchksize.
         */
#ifdef USE_VALGRIND
        if (Min(size, oldchksize) > chunk->requested_size)
            VALGRIND_MAKE_MEM_UNDEFINED((char *) pointer + chunk->requested_size,
                                        Min(size, oldchksize) - chunk->requested_size);
#endif
#endif
 
        chunk->requested_size = size;
        /* set mark to catch clobber of "unused" space */
        Assert(size < chksize);
        set_sentinel(pointer, size);
#else                           /* !MEMORY_CONTEXT_CHECKING */
 
        /*
         * We may need to adjust marking of bytes from the old allocation as
         * some of them may be marked NOACCESS.  We don't know how much of the
         * old chunk size was the requested size; it could have been as small
         * as one byte.  We have to be conservative and just mark the entire
         * old portion DEFINED.  Make sure not to mark memory beyond the new
         * allocation in case it's smaller than the old one.
         */
        VALGRIND_MAKE_MEM_DEFINED(pointer, Min(size, oldchksize));
#endif
 
        /* Ensure any padding bytes are marked NOACCESS. */
        VALGRIND_MAKE_MEM_NOACCESS((char *) pointer + size, chksize - size);
 
        /* Disallow access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
        return pointer;
    }
 
    block = MemoryChunkGetBlock(chunk);
 
    /*
     * In this path, for speed reasons we just Assert that the referenced
     * block is good. We can also Assert that the value field is sane. Future
     * field experience may show that these Asserts had better become regular
     * runtime test-and-elog checks.
     */
    Assert(AllocBlockIsValid(block));
    set = block->aset;
 
    fidx = MemoryChunkGetValue(chunk);
    Assert(FreeListIdxIsValid(fidx));
    oldchksize = GetChunkSizeFromFreeListIdx(fidx);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* See comments in AllocSetFree about uses of ERROR and WARNING here */
    /* Test for previously-freed chunk */
    if (unlikely(chunk->requested_size == InvalidAllocSize))
        elog(ERROR, "detected realloc of freed chunk in %s %p",
             set->header.name, chunk);
    /* Test for someone scribbling on unused space in chunk */
    if (chunk->requested_size < oldchksize)
        if (!sentinel_ok(pointer, chunk->requested_size))
            elog(WARNING, "detected write past chunk end in %s %p",
                 set->header.name, chunk);
#endif
 
    /*
     * Chunk sizes are aligned to power of 2 in AllocSetAlloc().  Maybe the
     * allocated area already is >= the new size.  (In particular, we will
     * fall out here if the requested size is a decrease.)
     */
    if (oldchksize >= 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,
                                       oldchksize - size);
 
        /* set mark to catch clobber of "unused" space */
        if (size < oldchksize)
            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, oldchksize);
        VALGRIND_MAKE_MEM_DEFINED(pointer, size);
#endif
 
        /* Disallow access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
        return pointer;
    }
    else
    {
        /*
         * Enlarge-a-small-chunk case.  We just do this by brute force, ie,
         * allocate a new chunk and copy the data.  Since we know the existing
         * data isn't huge, this won't involve any great memcpy expense, so
         * it's not worth being smarter.  (At one time we tried to avoid
         * memcpy when it was possible to enlarge the chunk in-place, but that
         * turns out to misbehave unpleasantly for repeated cycles of
         * palloc/repalloc/pfree: the eventually freed chunks go into the
         * wrong freelist for the next initial palloc request, and so we leak
         * memory indefinitely.  See pgsql-hackers archives for 2007-08-11.)
         */
        AllocPointer newPointer;
        Size        oldsize;
 
        /* allocate new chunk (this also checks size is valid) */
        newPointer = AllocSetAlloc((MemoryContext) set, size, flags);
 
        /* leave immediately if request was not completed */
        if (newPointer == NULL)
        {
            /* Disallow access to the chunk header. */
            VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
            return MemoryContextAllocationFailure((MemoryContext) set, size, flags);
        }
 
        /*
         * AllocSetAlloc() 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
        oldsize = oldchksize;
        VALGRIND_MAKE_MEM_DEFINED(pointer, oldsize);
#endif
 
        /* transfer existing data (certain to fit) */
        memcpy(newPointer, pointer, oldsize);
 
        /* free old chunk */
        AllocSetFree(pointer);
 
        return newPointer;
    }
}

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, AllocBlockIsValid, AllocSetAlloc(), AllocSetFree(), AllocBlockData::aset, Assert, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, fb(), FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, AllocSetContext::header, InvalidAllocSize, MAXALIGN, MemoryContextData::mem_allocated, memcpy(), MemoryChunkGetBlock(), MemoryChunkGetPointer, MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextAllocationFailure(), MemoryContextCheckSize(), Min, MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, realloc, unlikely, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, VALGRIND_MEMPOOL_CHANGE, and WARNING.

AllocSetReset()

void AllocSetReset ( MemoryContext  context )

extern

Definition at line 546 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    AllocBlock  block;
    Size        keepersize PG_USED_FOR_ASSERTS_ONLY;
 
    Assert(AllocSetIsValid(set));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    AllocSetCheck(context);
#endif
 
    /* Remember keeper block size for Assert below */
    keepersize = KeeperBlock(set)->endptr - ((char *) set);
 
    /* Clear chunk freelists */
    MemSetAligned(set->freelist, 0, sizeof(set->freelist));
 
    block = set->blocks;
 
    /* New blocks list will be just the keeper block */
    set->blocks = KeeperBlock(set);
 
    while (block != NULL)
    {
        AllocBlock  next = block->next;
 
        if (IsKeeperBlock(set, block))
        {
            /* Reset the block, but don't return it to malloc */
            char       *datastart = ((char *) block) + ALLOC_BLOCKHDRSZ;
 
#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
            block->freeptr = datastart;
            block->prev = NULL;
            block->next = NULL;
        }
        else
        {
            /* Normal case, release the block */
            context->mem_allocated -= block->endptr - ((char *) block);
 
#ifdef CLOBBER_FREED_MEMORY
            wipe_mem(block, block->freeptr - ((char *) block));
#endif
 
            /*
             * We need to free the block header's vchunk explicitly, although
             * the user-data vchunks within will go away in the TRIM below.
             * Otherwise Valgrind complains about leaked allocations.
             */
            VALGRIND_MEMPOOL_FREE(set, block);
 
            free(block);
        }
        block = next;
    }
 
    Assert(context->mem_allocated == keepersize);
 
    /*
     * Instruct Valgrind to throw away all the vchunks associated with this
     * context, except for the one covering the AllocSetContext 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;
}

References ALLOC_BLOCKHDRSZ, AllocSetIsValid, Assert, AllocSetContext::blocks, AllocBlockData::endptr, fb(), FIRST_BLOCKHDRSZ, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::initBlockSize, IsKeeperBlock, KeeperBlock, MemoryContextData::mem_allocated, MemSetAligned, next, AllocBlockData::next, AllocSetContext::nextBlockSize, PG_USED_FOR_ASSERTS_ONLY, AllocBlockData::prev, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MEMPOOL_FREE, and VALGRIND_MEMPOOL_TRIM.

AllocSetStats()

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

extern

Definition at line 1602 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    Size        nblocks = 0;
    Size        freechunks = 0;
    Size        totalspace;
    Size        freespace = 0;
    AllocBlock  block;
    int         fidx;
 
    Assert(AllocSetIsValid(set));
 
    /* Include context header in totalspace */
    totalspace = MAXALIGN(sizeof(AllocSetContext));
 
    for (block = set->blocks; block != NULL; block = block->next)
    {
        nblocks++;
        totalspace += block->endptr - ((char *) block);
        freespace += block->endptr - block->freeptr;
    }
    for (fidx = 0; fidx < ALLOCSET_NUM_FREELISTS; fidx++)
    {
        Size        chksz = GetChunkSizeFromFreeListIdx(fidx);
        MemoryChunk *chunk = set->freelist[fidx];
 
        while (chunk != NULL)
        {
            AllocFreeListLink *link = GetFreeListLink(chunk);
 
            /* Allow access to the chunk header. */
            VALGRIND_MAKE_MEM_DEFINED(chunk, ALLOC_CHUNKHDRSZ);
            Assert(MemoryChunkGetValue(chunk) == fidx);
            VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
            freechunks++;
            freespace += chksz + ALLOC_CHUNKHDRSZ;
 
            VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
            chunk = link->next;
            VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
        }
    }
 
    if (printfunc)
    {
        char        stats_string[200];
 
        snprintf(stats_string, sizeof(stats_string),
                 "%zu total in %zu blocks; %zu free (%zu chunks); %zu used",
                 totalspace, nblocks, freespace, freechunks,
                 totalspace - freespace);
        printfunc(context, passthru, stats_string, print_to_stderr);
    }
 
    if (totals)
    {
        totals->nblocks += nblocks;
        totals->freechunks += freechunks;
        totals->totalspace += totalspace;
        totals->freespace += freespace;
    }
}

References ALLOC_CHUNKHDRSZ, ALLOCSET_NUM_FREELISTS, AllocSetIsValid, Assert, AllocSetContext::blocks, AllocBlockData::endptr, fb(), AllocSetContext::freelist, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, MAXALIGN, MemoryChunkGetValue(), AllocBlockData::next, snprintf, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

BumpAlloc()

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

extern

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.

BumpDelete()

void BumpDelete ( MemoryContext  context )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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  )

extern

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 )

extern

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  )

extern

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.

GenerationAlloc()

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

extern

Definition at line 553 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    GenerationBlock *block;
    Size        chunk_size;
    Size        required_size;
 
    Assert(GenerationIsValid(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
     * GenerationAllocLarge().
     */
    if (chunk_size > set->allocChunkLimit)
        return GenerationAllocLarge(context, size, flags);
 
    required_size = chunk_size + Generation_CHUNKHDRSZ;
 
    /*
     * 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 empty freeblock has enough space.  We
     * don't try reusing the keeper block.  If it's become empty we'll reuse
     * that again only if the context is reset.
     *
     * We only try reusing the freeblock if we've no space for this allocation
     * on the current block.  When a freeblock exists, we'll switch to it once
     * the first time we can't fit an allocation in the current block.  We
     * avoid ping-ponging between the two as we need to be careful not to
     * fragment differently sized consecutive allocations between several
     * blocks.  Going between the two could cause fragmentation for FIFO
     * workloads, which generation is meant to be good at.
     */
    block = set->block;
 
    if (unlikely(GenerationBlockFreeBytes(block) < required_size))
    {
        GenerationBlock *freeblock = set->freeblock;
 
        /* freeblock, if set, must be empty */
        Assert(freeblock == NULL || GenerationBlockIsEmpty(freeblock));
 
        /* check if we have a freeblock and if it's big enough */
        if (freeblock != NULL &&
            GenerationBlockFreeBytes(freeblock) >= required_size)
        {
            /* make the freeblock the current block */
            set->freeblock = NULL;
            set->block = freeblock;
 
            return GenerationAllocChunkFromBlock(context,
                                                 freeblock,
                                                 size,
                                                 chunk_size);
        }
        else
        {
            /*
             * No freeblock, or it's not big enough for this allocation.  Make
             * a new block.
             */
            return GenerationAllocFromNewBlock(context, size, flags, chunk_size);
        }
    }
 
    /* The current block has space, so just allocate chunk there. */
    return GenerationAllocChunkFromBlock(context, block, size, chunk_size);
}

References GenerationContext::allocChunkLimit, Assert, GenerationContext::block, fb(), GenerationContext::freeblock, Generation_CHUNKHDRSZ, GenerationAllocChunkFromBlock(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationBlockFreeBytes(), GenerationBlockIsEmpty, GenerationIsValid, MAXALIGN, and unlikely.

Referenced by GenerationRealloc().

GenerationDelete()

void GenerationDelete ( MemoryContext  context )

extern

Definition at line 344 of file generation.c.

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

References free, GenerationReset(), and VALGRIND_DESTROY_MEMPOOL.

GenerationFree()

void GenerationFree ( void *  pointer )

extern

Definition at line 718 of file generation.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    GenerationBlock *block;
    GenerationContext *set;
#if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
    || defined(CLOBBER_FREED_MEMORY)
    Size        chunksize;
#endif
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        block = ExternalChunkGetBlock(chunk);
 
        /*
         * Try to verify that we have a sane block pointer: the block header
         * should reference a generation context.
         */
        if (!GenerationBlockIsValid(block))
            elog(ERROR, "could not find block containing chunk %p", chunk);
 
#if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
    || defined(CLOBBER_FREED_MEMORY)
        chunksize = block->endptr - (char *) pointer;
#endif
    }
    else
    {
        block = MemoryChunkGetBlock(chunk);
 
        /*
         * In this path, for speed reasons we just Assert that the referenced
         * block is good.  Future field experience may show that this Assert
         * had better become a regular runtime test-and-elog check.
         */
        Assert(GenerationBlockIsValid(block));
 
#if (defined(MEMORY_CONTEXT_CHECKING) && defined(USE_ASSERT_CHECKING)) \
    || defined(CLOBBER_FREED_MEMORY)
        chunksize = MemoryChunkGetValue(chunk);
#endif
    }
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* See comments in AllocSetFree about uses of ERROR and WARNING here */
    /* Test for previously-freed chunk */
    if (unlikely(chunk->requested_size == InvalidAllocSize))
        elog(ERROR, "detected double pfree in %s %p",
             ((MemoryContext) block->context)->name, chunk);
    /* Test for someone scribbling on unused space in chunk */
    Assert(chunk->requested_size < chunksize);
    if (!sentinel_ok(pointer, chunk->requested_size))
        elog(WARNING, "detected write past chunk end in %s %p",
             ((MemoryContext) block->context)->name, chunk);
#endif
 
#ifdef CLOBBER_FREED_MEMORY
    wipe_mem(pointer, chunksize);
#endif
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Reset requested_size to InvalidAllocSize in freed chunks */
    chunk->requested_size = InvalidAllocSize;
#endif
 
    block->nfree += 1;
 
    Assert(block->nchunks > 0);
    Assert(block->nfree <= block->nchunks);
    Assert(block != block->context->freeblock);
 
    /* If there are still allocated chunks in the block, we're done. */
    if (likely(block->nfree < block->nchunks))
        return;
 
    set = block->context;
 
    /*-----------------------
     * The block this allocation was on has now become completely empty of
     * chunks.  In the general case, we can now return the memory for this
     * block back to malloc.  However, there are cases where we don't want to
     * do that:
     *
     * 1)   If it's the keeper block.  This block was malloc'd in the same
     *      allocation as the context itself and can't be free'd without
     *      freeing the context.
     * 2)   If it's the current block.  We could free this, but doing so would
     *      leave us nothing to set the current block to, so we just mark the
     *      block as empty so new allocations can reuse it again.
     * 3)   If we have no "freeblock" set, then we save a single block for
     *      future allocations to avoid having to malloc a new block again.
     *      This is useful for FIFO workloads as it avoids continual
     *      free/malloc cycles.
     */
    if (IsKeeperBlock(set, block) || set->block == block)
        GenerationBlockMarkEmpty(block);    /* case 1 and 2 */
    else if (set->freeblock == NULL)
    {
        /* case 3 */
        GenerationBlockMarkEmpty(block);
        set->freeblock = block;
    }
    else
        GenerationBlockFree(set, block);    /* Otherwise, free it */
}

References Assert, GenerationContext::block, GenerationBlock::context, elog, GenerationBlock::endptr, ERROR, ExternalChunkGetBlock, fb(), GenerationContext::freeblock, Generation_CHUNKHDRSZ, GenerationBlockFree(), GenerationBlockIsValid, GenerationBlockMarkEmpty(), InvalidAllocSize, IsKeeperBlock, likely, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), GenerationBlock::nchunks, GenerationBlock::nfree, PointerGetMemoryChunk, unlikely, VALGRIND_MAKE_MEM_DEFINED, and WARNING.

Referenced by GenerationRealloc().

GenerationGetChunkContext()

MemoryContext GenerationGetChunkContext ( void *  pointer )

extern

Definition at line 986 of file generation.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    GenerationBlock *block;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
        block = ExternalChunkGetBlock(chunk);
    else
        block = (GenerationBlock *) MemoryChunkGetBlock(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
 
    Assert(GenerationBlockIsValid(block));
    return &block->context->header;
}

References Assert, GenerationBlock::context, ExternalChunkGetBlock, Generation_CHUNKHDRSZ, GenerationBlockIsValid, GenerationContext::header, MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

GenerationGetChunkSpace()

Size GenerationGetChunkSpace ( void *  pointer )

extern

Definition at line 1012 of file generation.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    Size        chunksize;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        GenerationBlock *block = ExternalChunkGetBlock(chunk);
 
        Assert(GenerationBlockIsValid(block));
        chunksize = block->endptr - (char *) pointer;
    }
    else
        chunksize = MemoryChunkGetValue(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
 
    return Generation_CHUNKHDRSZ + chunksize;
}

References Assert, GenerationBlock::endptr, ExternalChunkGetBlock, fb(), Generation_CHUNKHDRSZ, GenerationBlockIsValid, MemoryChunkGetValue(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

GenerationIsEmpty()

bool GenerationIsEmpty ( MemoryContext  context )

extern

Definition at line 1041 of file generation.c.

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

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

GenerationRealloc()

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

extern

Definition at line 834 of file generation.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    GenerationContext *set;
    GenerationBlock *block;
    GenerationPointer newPointer;
    Size        oldsize;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Generation_CHUNKHDRSZ);
 
    if (MemoryChunkIsExternal(chunk))
    {
        block = ExternalChunkGetBlock(chunk);
 
        /*
         * Try to verify that we have a sane block pointer: the block header
         * should reference a generation context.
         */
        if (!GenerationBlockIsValid(block))
            elog(ERROR, "could not find block containing chunk %p", chunk);
 
        oldsize = block->endptr - (char *) pointer;
    }
    else
    {
        block = MemoryChunkGetBlock(chunk);
 
        /*
         * In this path, for speed reasons we just Assert that the referenced
         * block is good.  Future field experience may show that this Assert
         * had better become a regular runtime test-and-elog check.
         */
        Assert(GenerationBlockIsValid(block));
 
        oldsize = MemoryChunkGetValue(chunk);
    }
 
    set = block->context;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* See comments in AllocSetFree about uses of ERROR and WARNING here */
    /* Test for previously-freed chunk */
    if (unlikely(chunk->requested_size == InvalidAllocSize))
        elog(ERROR, "detected realloc of freed chunk in %s %p",
             ((MemoryContext) set)->name, chunk);
    /* Test for someone scribbling on unused space in chunk */
    Assert(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 big enough.  (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()?
     */
#ifdef MEMORY_CONTEXT_CHECKING
    /* With MEMORY_CONTEXT_CHECKING, we need an extra byte for the sentinel */
    if (oldsize > size)
#else
    if (oldsize >= size)
#endif
    {
#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 */
        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 access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
 
        return pointer;
    }
 
    /* allocate new chunk (this also checks size is valid) */
    newPointer = GenerationAlloc((MemoryContext) set, size, flags);
 
    /* leave immediately if request was not completed */
    if (newPointer == NULL)
    {
        /* Disallow access to the chunk header. */
        VALGRIND_MAKE_MEM_NOACCESS(chunk, Generation_CHUNKHDRSZ);
        return MemoryContextAllocationFailure((MemoryContext) set, size, flags);
    }
 
    /*
     * 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(pointer);
 
    return newPointer;
}

References Assert, GenerationBlock::context, elog, GenerationBlock::endptr, ERROR, ExternalChunkGetBlock, fb(), Generation_CHUNKHDRSZ, GenerationAlloc(), GenerationBlockIsValid, GenerationFree(), InvalidAllocSize, memcpy(), MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextAllocationFailure(), name, PointerGetMemoryChunk, unlikely, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

GenerationReset()

void GenerationReset ( MemoryContext  context )

extern

Definition at line 291 of file generation.c.

{
    GenerationContext *set = (GenerationContext *) context;
    dlist_mutable_iter miter;
 
    Assert(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 (IsKeeperBlock(set, block))
            GenerationBlockMarkEmpty(block);
        else
            GenerationBlockFree(set, block);
    }
 
    /*
     * Instruct Valgrind to throw away all the vchunks associated with this
     * context, except for the one covering the GenerationContext 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);
 
    /* set it so new allocations to make use of the keeper block */
    set->block = KeeperBlock(set);
 
    /* 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, GenerationContext::block, GenerationContext::blocks, dlist_container, dlist_foreach_modify, dlist_has_next(), dlist_head_node(), dlist_is_empty(), fb(), FIRST_BLOCKHDRSZ, GenerationContext::freeblock, GenerationBlockFree(), GenerationBlockMarkEmpty(), GenerationIsValid, GenerationContext::initBlockSize, IsKeeperBlock, KeeperBlock, GenerationContext::nextBlockSize, and VALGRIND_MEMPOOL_TRIM.

Referenced by GenerationDelete().

GenerationStats()

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

extern

Definition at line 1072 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;
 
    Assert(GenerationIsValid(set));
 
    /* 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 Assert, GenerationBlock::blksize, GenerationContext::blocks, dlist_iter::cur, dlist_container, dlist_foreach, GenerationBlock::endptr, fb(), GenerationBlock::freeptr, GenerationIsValid, MAXALIGN, GenerationBlock::nchunks, GenerationBlock::nfree, and snprintf.

MemoryContextAllocationFailure()

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

extern

Definition at line 1198 of file mcxt.c.

{
    if ((flags & MCXT_ALLOC_NO_OOM) == 0)
    {
        if (TopMemoryContext)
            MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed on request of size %zu in memory context \"%s\".",
                           size, context->name)));
    }
    return NULL;
}

References ereport, errcode(), errdetail(), errmsg, ERROR, fb(), MCXT_ALLOC_NO_OOM, MemoryContextStats(), MemoryContextData::name, and TopMemoryContext.

Referenced by AlignedAllocRealloc(), AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetRealloc(), BumpAllocFromNewBlock(), BumpAllocLarge(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationRealloc(), and SlabAllocFromNewBlock().

MemoryContextCheckSize()

static void MemoryContextCheckSize ( MemoryContext  context, Size  size, int  flags  )

inlinestatic

Definition at line 167 of file memutils_internal.h.

{
    if (unlikely(!AllocSizeIsValid(size)))
    {
        if (!(flags & MCXT_ALLOC_HUGE) || !AllocHugeSizeIsValid(size))
            MemoryContextSizeFailure(context, size, flags);
    }
}

References AllocHugeSizeIsValid, AllocSizeIsValid, MCXT_ALLOC_HUGE, MemoryContextSizeFailure(), and unlikely.

Referenced by AllocSetAllocLarge(), AllocSetRealloc(), BumpAllocLarge(), and GenerationAllocLarge().

MemoryContextCreate()

void MemoryContextCreate ( MemoryContext  node, NodeTag  tag, MemoryContextMethodID  method_id, MemoryContext  parent, const char *  name  )

extern

Definition at line 1149 of file mcxt.c.

{
    /* Creating new memory contexts is not allowed in a critical section */
    Assert(CritSectionCount == 0);
 
    /* Validate parent, to help prevent crazy context linkages */
    Assert(parent == NULL || MemoryContextIsValid(parent));
    Assert(node != parent);
 
    /* Initialize all standard fields of memory context header */
    node->type = tag;
    node->isReset = true;
    node->methods = &mcxt_methods[method_id];
    node->parent = parent;
    node->firstchild = NULL;
    node->mem_allocated = 0;
    node->prevchild = NULL;
    node->name = name;
    node->ident = NULL;
    node->reset_cbs = NULL;
 
    /* OK to link node into context tree */
    if (parent)
    {
        node->nextchild = parent->firstchild;
        if (parent->firstchild != NULL)
            parent->firstchild->prevchild = node;
        parent->firstchild = node;
        /* inherit allowInCritSection flag from parent */
        node->allowInCritSection = parent->allowInCritSection;
    }
    else
    {
        node->nextchild = NULL;
        node->allowInCritSection = false;
    }
}

References MemoryContextData::allowInCritSection, Assert, CritSectionCount, fb(), MemoryContextData::firstchild, MemoryContextData::ident, MemoryContextData::isReset, mcxt_methods, MemoryContextData::mem_allocated, MemoryContextIsValid, MemoryContextData::methods, name, MemoryContextData::name, MemoryContextData::nextchild, MemoryContextData::parent, MemoryContextData::prevchild, and MemoryContextData::reset_cbs.

Referenced by AllocSetContextCreateInternal(), BumpContextCreate(), GenerationContextCreate(), and SlabContextCreate().

MemoryContextSizeFailure()

pg_noreturn void MemoryContextSizeFailure ( MemoryContext  context, Size  size, int  flags  )

extern

Definition at line 1219 of file mcxt.c.

{
    elog(ERROR, "invalid memory alloc request size %zu", size);
}

References elog, and ERROR.

Referenced by MemoryContextCheckSize().

SlabAlloc()

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

extern

Definition at line 659 of file slab.c.

{
    SlabContext *slab = (SlabContext *) context;
    SlabBlock  *block;
    MemoryChunk *chunk;
 
    Assert(SlabIsValid(slab));
 
    /* sanity check that this is pointing to a valid blocklist */
    Assert(slab->curBlocklistIndex >= 0);
    Assert(slab->curBlocklistIndex <= SlabBlocklistIndex(slab, slab->chunksPerBlock));
 
    /*
     * Make sure we only allow correct request size.  This doubles as the
     * MemoryContextCheckSize check.
     */
    if (unlikely(size != slab->chunkSize))
        SlabAllocInvalidSize(context, size);
 
    if (unlikely(slab->curBlocklistIndex == 0))
    {
        /*
         * Handle the case when there are no partially filled blocks
         * available.  This happens either when the last allocation took the
         * last chunk in the block, or when SlabFree() free'd the final block.
         */
        return SlabAllocFromNewBlock(context, size, flags);
    }
    else
    {
        dlist_head *blocklist = &slab->blocklist[slab->curBlocklistIndex];
        int         new_blocklist_idx;
 
        Assert(!dlist_is_empty(blocklist));
 
        /* grab the block from the blocklist */
        block = dlist_head_element(SlabBlock, node, blocklist);
 
        /* make sure we actually got a valid block, with matching nfree */
        Assert(block != NULL);
        Assert(slab->curBlocklistIndex == SlabBlocklistIndex(slab, block->nfree));
        Assert(block->nfree > 0);
 
        /* fetch the next chunk from this block */
        chunk = SlabGetNextFreeChunk(slab, block);
 
        /* get the new blocklist index based on the new free chunk count */
        new_blocklist_idx = SlabBlocklistIndex(slab, block->nfree);
 
        /*
         * Handle the case where the blocklist index changes.  This also deals
         * with blocks becoming full as only full blocks go at index 0.
         */
        if (unlikely(slab->curBlocklistIndex != new_blocklist_idx))
        {
            dlist_delete_from(blocklist, &block->node);
            dlist_push_head(&slab->blocklist[new_blocklist_idx], &block->node);
 
            if (dlist_is_empty(blocklist))
                slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
        }
    }
 
    return SlabAllocSetupNewChunk(context, block, chunk, size);
}

References Assert, SlabContext::blocklist, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dlist_delete_from(), dlist_head_element, dlist_is_empty(), dlist_push_head(), fb(), SlabBlock::nfree, SlabBlock::node, SlabAllocFromNewBlock(), SlabAllocInvalidSize(), SlabAllocSetupNewChunk(), SlabBlocklistIndex(), SlabFindNextBlockListIndex(), SlabGetNextFreeChunk(), SlabIsValid, and unlikely.

SlabDelete()

void SlabDelete ( MemoryContext  context )

extern

Definition at line 506 of file slab.c.

{
    /* Reset to release all the SlabBlocks */
    SlabReset(context);
 
    /* Destroy the vpool -- see notes in aset.c */
    VALGRIND_DESTROY_MEMPOOL(context);
 
    /* And free the context header */
    free(context);
}

References free, SlabReset(), and VALGRIND_DESTROY_MEMPOOL.

SlabFree()

void SlabFree ( void *  pointer )

extern

Definition at line 730 of file slab.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    SlabBlock  *block;
    SlabContext *slab;
    int         curBlocklistIdx;
    int         newBlocklistIdx;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
 
    block = MemoryChunkGetBlock(chunk);
 
    /*
     * For speed reasons we just Assert that the referenced block is good.
     * Future field experience may show that this Assert had better become a
     * regular runtime test-and-elog check.
     */
    Assert(SlabBlockIsValid(block));
    slab = block->slab;
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* See comments in AllocSetFree about uses of ERROR and WARNING here */
    /* Test for previously-freed chunk */
    if (unlikely(chunk->requested_size == InvalidAllocSize))
        elog(ERROR, "detected double pfree in %s %p",
             slab->header.name, chunk);
    /* Test for someone scribbling on unused space in chunk */
    Assert(slab->chunkSize < (slab->fullChunkSize - Slab_CHUNKHDRSZ));
    if (!sentinel_ok(pointer, slab->chunkSize))
        elog(WARNING, "detected write past chunk end in %s %p",
             slab->header.name, chunk);
    /* Reset requested_size to InvalidAllocSize in free chunks */
    chunk->requested_size = InvalidAllocSize;
#endif
 
    /* push this chunk onto the head of the block's free list */
    *(MemoryChunk **) pointer = block->freehead;
    block->freehead = chunk;
 
    block->nfree++;
 
    Assert(block->nfree > 0);
    Assert(block->nfree <= slab->chunksPerBlock);
 
#ifdef CLOBBER_FREED_MEMORY
    /* don't wipe the free list MemoryChunk pointer stored in the chunk */
    wipe_mem((char *) pointer + sizeof(MemoryChunk *),
             slab->chunkSize - sizeof(MemoryChunk *));
#endif
 
    curBlocklistIdx = SlabBlocklistIndex(slab, block->nfree - 1);
    newBlocklistIdx = SlabBlocklistIndex(slab, block->nfree);
 
    /*
     * Check if the block needs to be moved to another element on the
     * blocklist based on it now having 1 more free chunk.
     */
    if (unlikely(curBlocklistIdx != newBlocklistIdx))
    {
        /* do the move */
        dlist_delete_from(&slab->blocklist[curBlocklistIdx], &block->node);
        dlist_push_head(&slab->blocklist[newBlocklistIdx], &block->node);
 
        /*
         * The blocklist[curBlocklistIdx] may now be empty or we may now be
         * able to use a lower-element blocklist.  We'll need to redetermine
         * what the slab->curBlocklistIndex is if the current blocklist was
         * changed or if a lower element one was changed.  We must ensure we
         * use the list with the fullest block(s).
         */
        if (slab->curBlocklistIndex >= curBlocklistIdx)
        {
            slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
 
            /*
             * We know there must be a block with at least 1 unused chunk as
             * we just pfree'd one.  Ensure curBlocklistIndex reflects this.
             */
            Assert(slab->curBlocklistIndex > 0);
        }
    }
 
    /* Handle when a block becomes completely empty */
    if (unlikely(block->nfree == slab->chunksPerBlock))
    {
        /* remove the block */
        dlist_delete_from(&slab->blocklist[newBlocklistIdx], &block->node);
 
        /*
         * To avoid thrashing malloc/free, we keep a list of empty blocks that
         * we can reuse again instead of having to malloc a new one.
         */
        if (dclist_count(&slab->emptyblocks) < SLAB_MAXIMUM_EMPTY_BLOCKS)
            dclist_push_head(&slab->emptyblocks, &block->node);
        else
        {
            /*
             * When we have enough empty blocks stored already, we actually
             * free the block.
             */
#ifdef CLOBBER_FREED_MEMORY
            wipe_mem(block, slab->blockSize);
#endif
 
            /* As in aset.c, free block-header vchunks explicitly */
            VALGRIND_MEMPOOL_FREE(slab, block);
 
            free(block);
            slab->header.mem_allocated -= slab->blockSize;
        }
 
        /*
         * Check if we need to reset the blocklist index.  This is required
         * when the blocklist this block is on has become completely empty.
         */
        if (slab->curBlocklistIndex == newBlocklistIdx &&
            dlist_is_empty(&slab->blocklist[newBlocklistIdx]))
            slab->curBlocklistIndex = SlabFindNextBlockListIndex(slab);
    }
}

References Assert, SlabContext::blocklist, SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dclist_count(), dclist_push_head(), dlist_delete_from(), dlist_is_empty(), dlist_push_head(), elog, SlabContext::emptyblocks, ERROR, fb(), free, SlabBlock::freehead, SlabContext::fullChunkSize, SlabContext::header, InvalidAllocSize, MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryContextData::name, SlabBlock::nfree, SlabBlock::node, PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SLAB_MAXIMUM_EMPTY_BLOCKS, SlabBlockIsValid, SlabBlocklistIndex(), SlabFindNextBlockListIndex(), unlikely, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MEMPOOL_FREE, and WARNING.

SlabGetChunkContext()

MemoryContext SlabGetChunkContext ( void *  pointer )

extern

Definition at line 903 of file slab.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    SlabBlock  *block;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
 
    block = MemoryChunkGetBlock(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
 
    Assert(SlabBlockIsValid(block));
 
    return &block->slab->header;
}

References Assert, SlabContext::header, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabGetChunkSpace()

Size SlabGetChunkSpace ( void *  pointer )

extern

Definition at line 927 of file slab.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    SlabBlock  *block;
    SlabContext *slab;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
 
    block = MemoryChunkGetBlock(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
 
    Assert(SlabBlockIsValid(block));
    slab = block->slab;
 
    return slab->fullChunkSize;
}

References Assert, SlabContext::fullChunkSize, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabIsEmpty()

bool SlabIsEmpty ( MemoryContext  context )

extern

Definition at line 952 of file slab.c.

{
    Assert(SlabIsValid((SlabContext *) context));
 
    return (context->mem_allocated == 0);
}

References Assert, MemoryContextData::mem_allocated, and SlabIsValid.

SlabRealloc()

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

extern

Definition at line 866 of file slab.c.

{
    MemoryChunk *chunk = PointerGetMemoryChunk(pointer);
    SlabBlock  *block;
    SlabContext *slab;
 
    /* Allow access to the chunk header. */
    VALGRIND_MAKE_MEM_DEFINED(chunk, Slab_CHUNKHDRSZ);
 
    block = MemoryChunkGetBlock(chunk);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
 
    /*
     * Try to verify that we have a sane block pointer: the block header
     * should reference a slab context.  (We use a test-and-elog, not just
     * Assert, because it seems highly likely that we're here in error in the
     * first place.)
     */
    if (!SlabBlockIsValid(block))
        elog(ERROR, "could not find block containing chunk %p", chunk);
    slab = block->slab;
 
    /* can't do actual realloc with slab, but let's try to be gentle */
    if (size == slab->chunkSize)
        return pointer;
 
    elog(ERROR, "slab allocator does not support realloc()");
    return NULL;                /* keep compiler quiet */
}

References SlabContext::chunkSize, elog, ERROR, fb(), MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabReset()

void SlabReset ( MemoryContext  context )

extern

Definition at line 436 of file slab.c.

{
    SlabContext *slab = (SlabContext *) context;
    dlist_mutable_iter miter;
    int         i;
 
    Assert(SlabIsValid(slab));
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* Check for corruption and leaks before freeing */
    SlabCheck(context);
#endif
 
    /* release any retained empty blocks */
    dclist_foreach_modify(miter, &slab->emptyblocks)
    {
        SlabBlock  *block = dlist_container(SlabBlock, node, miter.cur);
 
        dclist_delete_from(&slab->emptyblocks, miter.cur);
 
#ifdef CLOBBER_FREED_MEMORY
        wipe_mem(block, slab->blockSize);
#endif
 
        /* As in aset.c, free block-header vchunks explicitly */
        VALGRIND_MEMPOOL_FREE(slab, block);
 
        free(block);
        context->mem_allocated -= slab->blockSize;
    }
 
    /* walk over blocklist and free the blocks */
    for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
    {
        dlist_foreach_modify(miter, &slab->blocklist[i])
        {
            SlabBlock  *block = dlist_container(SlabBlock, node, miter.cur);
 
            dlist_delete(miter.cur);
 
#ifdef CLOBBER_FREED_MEMORY
            wipe_mem(block, slab->blockSize);
#endif
 
            /* As in aset.c, free block-header vchunks explicitly */
            VALGRIND_MEMPOOL_FREE(slab, block);
 
            free(block);
            context->mem_allocated -= slab->blockSize;
        }
    }
 
    /*
     * Instruct Valgrind to throw away all the vchunks associated with this
     * context, except for the one covering the SlabContext.  This gets rid of
     * the vchunks for whatever user data is getting discarded by the context
     * reset.
     */
    VALGRIND_MEMPOOL_TRIM(slab, slab, sizeof(SlabContext));
 
    slab->curBlocklistIndex = 0;
 
    Assert(context->mem_allocated == 0);
}

References Assert, SlabContext::blocklist, SlabContext::blockSize, SlabContext::curBlocklistIndex, dclist_delete_from(), dclist_foreach_modify, dlist_container, dlist_delete(), dlist_foreach_modify, SlabContext::emptyblocks, fb(), free, i, MemoryContextData::mem_allocated, SLAB_BLOCKLIST_COUNT, SlabIsValid, VALGRIND_MEMPOOL_FREE, and VALGRIND_MEMPOOL_TRIM.

Referenced by SlabDelete().

SlabStats()

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

extern

Definition at line 969 of file slab.c.

{
    SlabContext *slab = (SlabContext *) context;
    Size        nblocks = 0;
    Size        freechunks = 0;
    Size        totalspace;
    Size        freespace = 0;
    int         i;
 
    Assert(SlabIsValid(slab));
 
    /* Include context header in totalspace */
    totalspace = Slab_CONTEXT_HDRSZ(slab->chunksPerBlock);
 
    /* Add the space consumed by blocks in the emptyblocks list */
    totalspace += dclist_count(&slab->emptyblocks) * slab->blockSize;
 
    for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
    {
        dlist_iter  iter;
 
        dlist_foreach(iter, &slab->blocklist[i])
        {
            SlabBlock  *block = dlist_container(SlabBlock, node, iter.cur);
 
            nblocks++;
            totalspace += slab->blockSize;
            freespace += slab->fullChunkSize * block->nfree;
            freechunks += block->nfree;
        }
    }
 
    if (printfunc)
    {
        char        stats_string[200];
 
        /* XXX should we include free chunks on empty blocks? */
        snprintf(stats_string, sizeof(stats_string),
                 "%zu total in %zu blocks; %u empty blocks; %zu free (%zu chunks); %zu used",
                 totalspace, nblocks, dclist_count(&slab->emptyblocks),
                 freespace, freechunks, totalspace - freespace);
        printfunc(context, passthru, stats_string, print_to_stderr);
    }
 
    if (totals)
    {
        totals->nblocks += nblocks;
        totals->freechunks += freechunks;
        totals->totalspace += totalspace;
        totals->freespace += freespace;
    }
}

References Assert, SlabContext::blocklist, SlabContext::blockSize, SlabContext::chunksPerBlock, dlist_iter::cur, dclist_count(), dlist_container, dlist_foreach, SlabContext::emptyblocks, fb(), SlabContext::fullChunkSize, i, SlabBlock::nfree, SLAB_BLOCKLIST_COUNT, Slab_CONTEXT_HDRSZ, SlabIsValid, and snprintf.