aset.c File Reference

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

Include dependency graph for aset.c:

Go to the source code of this file.

Data Structures
struct	AllocFreeListLink
struct	AllocSetContext
struct	AllocBlockData
struct	AllocSetFreeList

Macros
#define	ALLOC_MINBITS   3 /* smallest chunk size is 8 bytes */
#define	ALLOCSET_NUM_FREELISTS   11
#define	ALLOC_CHUNK_LIMIT   (1 << (ALLOCSET_NUM_FREELISTS-1+ALLOC_MINBITS))
#define	ALLOC_CHUNK_FRACTION   4
#define	ALLOC_BLOCKHDRSZ   MAXALIGN(sizeof(AllocBlockData))
#define	ALLOC_CHUNKHDRSZ   sizeof(MemoryChunk)
#define	GetFreeListLink(chkptr)    (AllocFreeListLink *) ((char *) (chkptr) + ALLOC_CHUNKHDRSZ)
#define	FreeListIdxIsValid(fidx)    ((fidx) >= 0 && (fidx) < ALLOCSET_NUM_FREELISTS)
#define	GetChunkSizeFromFreeListIdx(fidx)    ((((Size) 1) << ALLOC_MINBITS) << (fidx))
#define	AllocPointerIsValid(pointer)   PointerIsValid(pointer)
#define	AllocSetIsValid(set)    (PointerIsValid(set) && IsA(set, AllocSetContext))
#define	AllocBlockIsValid(block)    (PointerIsValid(block) && AllocSetIsValid((block)->aset))
#define	ExternalChunkGetBlock(chunk)    (AllocBlock) ((char *) chunk - ALLOC_BLOCKHDRSZ)
#define	MAX_FREE_CONTEXTS   100 /* arbitrary limit on freelist length */
#define	KeeperBlock(set)    ((AllocBlock) (((char *) set) + MAXALIGN(sizeof(AllocSetContext))))
#define	IsKeeperBlock(set, block)   ((block) == (KeeperBlock(set)))

Typedefs
typedef struct AllocBlockData *	AllocBlock
typedef void *	AllocPointer
typedef struct AllocFreeListLink	AllocFreeListLink
typedef struct AllocSetContext	AllocSetContext
typedef AllocSetContext *	AllocSet
typedef struct AllocBlockData	AllocBlockData
typedef struct AllocSetFreeList	AllocSetFreeList

Functions
static int	AllocSetFreeIndex (Size size)
MemoryContext	AllocSetContextCreateInternal (MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
void	AllocSetReset (MemoryContext context)
void	AllocSetDelete (MemoryContext context)
static pg_noinline void *	AllocSetAllocLarge (MemoryContext context, Size size, int flags)
static void *	AllocSetAllocChunkFromBlock (MemoryContext context, AllocBlock block, Size size, Size chunk_size, int fidx)
static pg_noinline void *	AllocSetAllocFromNewBlock (MemoryContext context, Size size, int flags, int fidx)
void *	AllocSetAlloc (MemoryContext context, Size size, int flags)
void	AllocSetFree (void *pointer)
void *	AllocSetRealloc (void *pointer, Size size, int flags)
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)

Variables
static AllocSetFreeList	context_freelists [2]

Macro Definition Documentation

ALLOC_BLOCKHDRSZ

#define ALLOC_BLOCKHDRSZ   MAXALIGN(sizeof(AllocBlockData))

Definition at line 104 of file aset.c.

ALLOC_CHUNK_FRACTION

#define ALLOC_CHUNK_FRACTION   4

Definition at line 87 of file aset.c.

ALLOC_CHUNK_LIMIT

#define ALLOC_CHUNK_LIMIT   (1 << (ALLOCSET_NUM_FREELISTS-1+ALLOC_MINBITS))

Definition at line 85 of file aset.c.

ALLOC_CHUNKHDRSZ

#define ALLOC_CHUNKHDRSZ   sizeof(MemoryChunk)

Definition at line 105 of file aset.c.

ALLOC_MINBITS

#define ALLOC_MINBITS   3 /* smallest chunk size is 8 bytes */

Definition at line 83 of file aset.c.

AllocBlockIsValid

#define AllocBlockIsValid

(

block

)

(PointerIsValid(block) && AllocSetIsValid((block)->aset))

Definition at line 207 of file aset.c.

AllocPointerIsValid

#define AllocPointerIsValid

(

pointer

)

PointerIsValid(pointer)

Definition at line 194 of file aset.c.

ALLOCSET_NUM_FREELISTS

#define ALLOCSET_NUM_FREELISTS   11

Definition at line 84 of file aset.c.

AllocSetIsValid

#define AllocSetIsValid

(

set

)

(PointerIsValid(set) && IsA(set, AllocSetContext))

Definition at line 200 of file aset.c.

ExternalChunkGetBlock

#define ExternalChunkGetBlock

(

chunk

)

(AllocBlock) ((char *) chunk - ALLOC_BLOCKHDRSZ)

Definition at line 215 of file aset.c.

FreeListIdxIsValid

#define FreeListIdxIsValid

(

fidx

)

((fidx) >= 0 && (fidx) < ALLOCSET_NUM_FREELISTS)

Definition at line 136 of file aset.c.

GetChunkSizeFromFreeListIdx

#define GetChunkSizeFromFreeListIdx

(

fidx

)

((((Size) 1) << ALLOC_MINBITS) << (fidx))

Definition at line 140 of file aset.c.

GetFreeListLink

#define GetFreeListLink

(

chkptr

)

(AllocFreeListLink *) ((char *) (chkptr) + ALLOC_CHUNKHDRSZ)

Definition at line 132 of file aset.c.

IsKeeperBlock

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

Definition at line 248 of file aset.c.

KeeperBlock

#define KeeperBlock

(

set

)

((AllocBlock) (((char *) set) + MAXALIGN(sizeof(AllocSetContext))))

Definition at line 244 of file aset.c.

MAX_FREE_CONTEXTS

#define MAX_FREE_CONTEXTS   100 /* arbitrary limit on freelist length */

Definition at line 241 of file aset.c.

Typedef Documentation

AllocBlock

typedef struct AllocBlockData* AllocBlock

Definition at line 107 of file aset.c.

AllocBlockData

typedef struct AllocBlockData AllocBlockData

AllocFreeListLink

typedef struct AllocFreeListLink AllocFreeListLink

AllocPointer

typedef void* AllocPointer

Definition at line 113 of file aset.c.

AllocSet

typedef AllocSetContext* AllocSet

Definition at line 167 of file aset.c.

AllocSetContext

typedef struct AllocSetContext AllocSetContext

AllocSetFreeList

typedef struct AllocSetFreeList AllocSetFreeList

Function Documentation

AllocSetAlloc()

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

Definition at line 967 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, chunk, context, AllocBlockData::endptr, AllocSetContext::freelist, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, MemoryChunkGetPointer, MemoryChunkGetValue(), size, unlikely, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by AllocSetRealloc().

AllocSetAllocChunkFromBlock()

static void* AllocSetAllocChunkFromBlock ( MemoryContext  context, AllocBlock  block, Size  size, Size  chunk_size, int  fidx  )

inlinestatic

Definition at line 774 of file aset.c.

{
    MemoryChunk *chunk;
 
    chunk = (MemoryChunk *) (block->freeptr);
 
    /* Prepare to initialize the chunk header. */
    VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
 
    block->freeptr += (chunk_size + ALLOC_CHUNKHDRSZ);
    Assert(block->freeptr <= block->endptr);
 
    /* store the free list index in the value field */
    MemoryChunkSetHdrMask(chunk, block, fidx, MCTX_ASET_ID);
 
#ifdef MEMORY_CONTEXT_CHECKING
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    if (size < chunk_size)
        set_sentinel(MemoryChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
}

References ALLOC_CHUNKHDRSZ, Assert, chunk, AllocBlockData::endptr, AllocBlockData::freeptr, MCTX_ASET_ID, MemoryChunkGetPointer, MemoryChunkSetHdrMask(), size, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by AllocSetAlloc(), and AllocSetAllocFromNewBlock().

AllocSetAllocFromNewBlock()

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

static

Definition at line 819 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    AllocBlock  block;
    Size        availspace;
    Size        blksize;
    Size        required_size;
    Size        chunk_size;
 
    /* due to the keeper block set->blocks should always be valid */
    Assert(set->blocks != NULL);
    block = set->blocks;
    availspace = block->endptr - block->freeptr;
 
    /*
     * The existing active (top) block does not have enough room for the
     * requested allocation, but it might still have a useful amount of space
     * in it.  Once we push it down in the block list, we'll never try to
     * allocate more space from it. So, before we do that, carve up its free
     * space into chunks that we can put on the set's freelists.
     *
     * Because we can only get here when there's less than ALLOC_CHUNK_LIMIT
     * left in the block, this loop cannot iterate more than
     * ALLOCSET_NUM_FREELISTS-1 times.
     */
    while (availspace >= ((1 << ALLOC_MINBITS) + ALLOC_CHUNKHDRSZ))
    {
        AllocFreeListLink *link;
        MemoryChunk *chunk;
        Size        availchunk = availspace - ALLOC_CHUNKHDRSZ;
        int         a_fidx = AllocSetFreeIndex(availchunk);
 
        /*
         * In most cases, we'll get back the index of the next larger freelist
         * than the one we need to put this chunk on.  The exception is when
         * availchunk is exactly a power of 2.
         */
        if (availchunk != GetChunkSizeFromFreeListIdx(a_fidx))
        {
            a_fidx--;
            Assert(a_fidx >= 0);
            availchunk = GetChunkSizeFromFreeListIdx(a_fidx);
        }
 
        chunk = (MemoryChunk *) (block->freeptr);
 
        /* Prepare to initialize the chunk header. */
        VALGRIND_MAKE_MEM_UNDEFINED(chunk, ALLOC_CHUNKHDRSZ);
        block->freeptr += (availchunk + ALLOC_CHUNKHDRSZ);
        availspace -= (availchunk + ALLOC_CHUNKHDRSZ);
 
        /* store the freelist index in the value field */
        MemoryChunkSetHdrMask(chunk, block, a_fidx, MCTX_ASET_ID);
#ifdef MEMORY_CONTEXT_CHECKING
        chunk->requested_size = InvalidAllocSize;   /* mark it free */
#endif
        /* push this chunk onto the free list */
        link = GetFreeListLink(chunk);
 
        VALGRIND_MAKE_MEM_DEFINED(link, sizeof(AllocFreeListLink));
        link->next = set->freelist[a_fidx];
        VALGRIND_MAKE_MEM_NOACCESS(link, sizeof(AllocFreeListLink));
 
        set->freelist[a_fidx] = chunk;
    }
 
    /*
     * The first such block has size initBlockSize, and we double the space in
     * each succeeding block, but not more than maxBlockSize.
     */
    blksize = set->nextBlockSize;
    set->nextBlockSize <<= 1;
    if (set->nextBlockSize > set->maxBlockSize)
        set->nextBlockSize = set->maxBlockSize;
 
    /* Choose the actual chunk size to allocate */
    chunk_size = GetChunkSizeFromFreeListIdx(fidx);
    Assert(chunk_size >= size);
 
    /*
     * If initBlockSize is less than ALLOC_CHUNK_LIMIT, we could need more
     * space... but try to keep it a power of 2.
     */
    required_size = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
    while (blksize < required_size)
        blksize <<= 1;
 
    /* Try to allocate it */
    block = (AllocBlock) malloc(blksize);
 
    /*
     * We could be asking for pretty big blocks here, so cope if malloc fails.
     * But give up if there's less than 1 MB or so available...
     */
    while (block == NULL && blksize > 1024 * 1024)
    {
        blksize >>= 1;
        if (blksize < required_size)
            break;
        block = (AllocBlock) malloc(blksize);
    }
 
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    context->mem_allocated += blksize;
 
    block->aset = set;
    block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
    block->endptr = ((char *) block) + blksize;
 
    /* Mark unallocated space NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS(block->freeptr,
                               blksize - ALLOC_BLOCKHDRSZ);
 
    block->prev = NULL;
    block->next = set->blocks;
    if (block->next)
        block->next->prev = block;
    set->blocks = block;
 
    return AllocSetAllocChunkFromBlock(context, block, size, chunk_size, fidx);
}

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, ALLOC_MINBITS, AllocSetAllocChunkFromBlock(), AllocSetFreeIndex(), AllocBlockData::aset, Assert, AllocSetContext::blocks, chunk, context, AllocBlockData::endptr, AllocSetContext::freelist, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, InvalidAllocSize, link(), malloc, AllocSetContext::maxBlockSize, MCTX_ASET_ID, MemoryChunkSetHdrMask(), MemoryContextAllocationFailure(), AllocBlockData::next, AllocSetContext::nextBlockSize, AllocBlockData::prev, size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by AllocSetAlloc().

AllocSetAllocLarge()

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

static

Definition at line 696 of file aset.c.

{
    AllocSet    set = (AllocSet) context;
    AllocBlock  block;
    MemoryChunk *chunk;
    Size        chunk_size;
    Size        blksize;
 
    /* validate 'size' is within the limits for the given 'flags' */
    MemoryContextCheckSize(context, size, flags);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    chunk_size = MAXALIGN(size + 1);
#else
    chunk_size = MAXALIGN(size);
#endif
 
    blksize = chunk_size + ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
    block = (AllocBlock) malloc(blksize);
    if (block == NULL)
        return MemoryContextAllocationFailure(context, size, flags);
 
    context->mem_allocated += blksize;
 
    block->aset = set;
    block->freeptr = block->endptr = ((char *) block) + blksize;
 
    chunk = (MemoryChunk *) (((char *) block) + ALLOC_BLOCKHDRSZ);
 
    /* mark the MemoryChunk as externally managed */
    MemoryChunkSetHdrMaskExternal(chunk, MCTX_ASET_ID);
 
#ifdef MEMORY_CONTEXT_CHECKING
    chunk->requested_size = size;
    /* set mark to catch clobber of "unused" space */
    Assert(size < chunk_size);
    set_sentinel(MemoryChunkGetPointer(chunk), size);
#endif
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /*
     * Stick the new block underneath the active allocation block, if any, so
     * that we don't lose the use of the space remaining therein.
     */
    if (set->blocks != NULL)
    {
        block->prev = set->blocks;
        block->next = set->blocks->next;
        if (block->next)
            block->next->prev = block;
        set->blocks->next = block;
    }
    else
    {
        block->prev = NULL;
        block->next = NULL;
        set->blocks = block;
    }
 
    /* Ensure any padding bytes are marked NOACCESS. */
    VALGRIND_MAKE_MEM_NOACCESS((char *) MemoryChunkGetPointer(chunk) + size,
                               chunk_size - size);
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
}

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNKHDRSZ, AllocBlockData::aset, Assert, AllocSetContext::blocks, chunk, context, AllocBlockData::endptr, AllocBlockData::freeptr, malloc, MAXALIGN, MCTX_ASET_ID, MemoryChunkGetPointer, MemoryChunkSetHdrMaskExternal(), MemoryContextAllocationFailure(), MemoryContextCheckSize(), AllocBlockData::next, AllocBlockData::prev, size, and VALGRIND_MAKE_MEM_NOACCESS.

Referenced by AllocSetAlloc().

AllocSetContextCreateInternal()

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

Definition at line 347 of file aset.c.

{
    int         freeListIndex;
    Size        firstBlockSize;
    AllocSet    set;
    AllocBlock  block;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(ALLOC_CHUNKHDRSZ == MAXALIGN(ALLOC_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    /* check we have enough space to store the freelist link */
    StaticAssertDecl(sizeof(AllocFreeListLink) <= (1 << ALLOC_MINBITS),
                     "sizeof(AllocFreeListLink) larger than minimum allocation size");
 
    /*
     * First, validate allocation parameters.  Once these were regular runtime
     * tests and elog's, but in practice Asserts seem sufficient because
     * nobody varies their parameters at runtime.  We somewhat arbitrarily
     * enforce a minimum 1K block size.  We restrict the maximum block size to
     * MEMORYCHUNK_MAX_BLOCKOFFSET as MemoryChunks are limited to this in
     * regards to addressing the offset between the chunk and the block that
     * the chunk is stored on.  We would be unable to store the offset between
     * the chunk and block for any chunks that were beyond
     * MEMORYCHUNK_MAX_BLOCKOFFSET bytes into the block if the block was to be
     * larger than this.
     */
    Assert(initBlockSize == MAXALIGN(initBlockSize) &&
           initBlockSize >= 1024);
    Assert(maxBlockSize == MAXALIGN(maxBlockSize) &&
           maxBlockSize >= initBlockSize &&
           AllocHugeSizeIsValid(maxBlockSize)); /* must be safe to double */
    Assert(minContextSize == 0 ||
           (minContextSize == MAXALIGN(minContextSize) &&
            minContextSize >= 1024 &&
            minContextSize <= maxBlockSize));
    Assert(maxBlockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
 
    /*
     * Check whether the parameters match either available freelist.  We do
     * not need to demand a match of maxBlockSize.
     */
    if (minContextSize == ALLOCSET_DEFAULT_MINSIZE &&
        initBlockSize == ALLOCSET_DEFAULT_INITSIZE)
        freeListIndex = 0;
    else if (minContextSize == ALLOCSET_SMALL_MINSIZE &&
             initBlockSize == ALLOCSET_SMALL_INITSIZE)
        freeListIndex = 1;
    else
        freeListIndex = -1;
 
    /*
     * If a suitable freelist entry exists, just recycle that context.
     */
    if (freeListIndex >= 0)
    {
        AllocSetFreeList *freelist = &context_freelists[freeListIndex];
 
        if (freelist->first_free != NULL)
        {
            /* Remove entry from freelist */
            set = freelist->first_free;
            freelist->first_free = (AllocSet) set->header.nextchild;
            freelist->num_free--;
 
            /* Update its maxBlockSize; everything else should be OK */
            set->maxBlockSize = maxBlockSize;
 
            /* Reinitialize its header, installing correct name and parent */
            MemoryContextCreate((MemoryContext) set,
                                T_AllocSetContext,
                                MCTX_ASET_ID,
                                parent,
                                name);
 
            ((MemoryContext) set)->mem_allocated =
                KeeperBlock(set)->endptr - ((char *) set);
 
            return (MemoryContext) set;
        }
    }
 
    /* Determine size of initial block */
    firstBlockSize = MAXALIGN(sizeof(AllocSetContext)) +
        ALLOC_BLOCKHDRSZ + ALLOC_CHUNKHDRSZ;
    if (minContextSize != 0)
        firstBlockSize = Max(firstBlockSize, minContextSize);
    else
        firstBlockSize = Max(firstBlockSize, initBlockSize);
 
    /*
     * Allocate the initial block.  Unlike other aset.c blocks, it starts with
     * the context header and its block header follows that.
     */
    set = (AllocSet) malloc(firstBlockSize);
    if (set == NULL)
    {
        if (TopMemoryContext)
            MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed while creating memory context \"%s\".",
                           name)));
    }
 
    /*
     * Avoid writing code that can fail between here and MemoryContextCreate;
     * we'd leak the header/initial block if we ereport in this stretch.
     */
 
    /* Fill in the initial block's block header */
    block = KeeperBlock(set);
    block->aset = set;
    block->freeptr = ((char *) block) + ALLOC_BLOCKHDRSZ;
    block->endptr = ((char *) set) + firstBlockSize;
    block->prev = NULL;
    block->next = NULL;
 
    /* Mark unallocated space NOACCESS; leave the block header alone. */
    VALGRIND_MAKE_MEM_NOACCESS(block->freeptr, block->endptr - block->freeptr);
 
    /* Remember block as part of block list */
    set->blocks = block;
 
    /* Finish filling in aset-specific parts of the context header */
    MemSetAligned(set->freelist, 0, sizeof(set->freelist));
 
    set->initBlockSize = (uint32) initBlockSize;
    set->maxBlockSize = (uint32) maxBlockSize;
    set->nextBlockSize = (uint32) initBlockSize;
    set->freeListIndex = freeListIndex;
 
    /*
     * Compute the allocation chunk size limit for this context.  It can't be
     * more than ALLOC_CHUNK_LIMIT because of the fixed number of freelists.
     * If maxBlockSize is small then requests exceeding the maxBlockSize, or
     * even a significant fraction of it, should be treated as large chunks
     * too.  For the typical case of maxBlockSize a power of 2, the chunk size
     * limit will be at most 1/8th maxBlockSize, so that given a stream of
     * requests that are all the maximum chunk size we will waste at most
     * 1/8th of the allocated space.
     *
     * Also, allocChunkLimit must not exceed ALLOCSET_SEPARATE_THRESHOLD.
     */
    StaticAssertStmt(ALLOC_CHUNK_LIMIT == ALLOCSET_SEPARATE_THRESHOLD,
                     "ALLOC_CHUNK_LIMIT != ALLOCSET_SEPARATE_THRESHOLD");
 
    /*
     * Determine the maximum size that a chunk can be before we allocate an
     * entire AllocBlock dedicated for that chunk.  We set the absolute limit
     * of that size as ALLOC_CHUNK_LIMIT but we reduce it further so that we
     * can fit about ALLOC_CHUNK_FRACTION chunks this size on a maximally
     * sized block.  (We opt to keep allocChunkLimit a power-of-2 value
     * primarily for legacy reasons rather than calculating it so that exactly
     * ALLOC_CHUNK_FRACTION chunks fit on a maximally sized block.)
     */
    set->allocChunkLimit = ALLOC_CHUNK_LIMIT;
    while ((Size) (set->allocChunkLimit + ALLOC_CHUNKHDRSZ) >
           (Size) ((maxBlockSize - ALLOC_BLOCKHDRSZ) / ALLOC_CHUNK_FRACTION))
        set->allocChunkLimit >>= 1;
 
    /* Finally, do the type-independent part of context creation */
    MemoryContextCreate((MemoryContext) set,
                        T_AllocSetContext,
                        MCTX_ASET_ID,
                        parent,
                        name);
 
    ((MemoryContext) set)->mem_allocated = firstBlockSize;
 
    return (MemoryContext) set;
}

References ALLOC_BLOCKHDRSZ, ALLOC_CHUNK_FRACTION, ALLOC_CHUNK_LIMIT, ALLOC_CHUNKHDRSZ, ALLOC_MINBITS, AllocSetContext::allocChunkLimit, AllocHugeSizeIsValid, ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MINSIZE, ALLOCSET_SEPARATE_THRESHOLD, ALLOCSET_SMALL_INITSIZE, ALLOCSET_SMALL_MINSIZE, AllocBlockData::aset, Assert, AllocSetContext::blocks, context_freelists, AllocBlockData::endptr, ereport, errcode(), errdetail(), errmsg(), ERROR, AllocSetFreeList::first_free, AllocSetContext::freelist, AllocSetContext::freeListIndex, AllocBlockData::freeptr, AllocSetContext::header, AllocSetContext::initBlockSize, KeeperBlock, malloc, Max, MAXALIGN, AllocSetContext::maxBlockSize, MCTX_ASET_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MemoryContextCreate(), MemoryContextStats(), MemSetAligned, name, AllocBlockData::next, AllocSetContext::nextBlockSize, MemoryContextData::nextchild, AllocSetFreeList::num_free, AllocBlockData::prev, StaticAssertDecl, StaticAssertStmt, TopMemoryContext, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetDelete()

void AllocSetDelete

(

MemoryContext

context

)

Definition at line 607 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--;
 
                /* 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))
            free(block);
 
        block = next;
    }
 
    Assert(context->mem_allocated == keepersize);
 
    /* Finally, free the context header, including the keeper block */
    free(set);
}

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

AllocSetFree()

void AllocSetFree

(

void *

pointer

)

Definition at line 1062 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
        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);
 
#ifdef MEMORY_CONTEXT_CHECKING
        /* 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, chunk, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, free, AllocSetContext::freelist, FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, GetFreeListLink, AllocSetContext::header, InvalidAllocSize, link(), MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, and WARNING.

Referenced by AllocSetRealloc().

AllocSetFreeIndex()

static int AllocSetFreeIndex ( Size  size )

inlinestatic

Definition at line 277 of file aset.c.

{
    int         idx;
 
    if (size > (1 << ALLOC_MINBITS))
    {
        /*----------
         * At this point we must compute ceil(log2(size >> ALLOC_MINBITS)).
         * This is the same as
         *      pg_leftmost_one_pos32((size - 1) >> ALLOC_MINBITS) + 1
         * or equivalently
         *      pg_leftmost_one_pos32(size - 1) - ALLOC_MINBITS + 1
         *
         * However, for platforms without intrinsic support, we duplicate the
         * logic here, allowing an additional optimization.  It's reasonable
         * to assume that ALLOC_CHUNK_LIMIT fits in 16 bits, so we can unroll
         * the byte-at-a-time loop in pg_leftmost_one_pos32 and just handle
         * the last two bytes.
         *
         * Yes, this function is enough of a hot-spot to make it worth this
         * much trouble.
         *----------
         */
#ifdef HAVE_BITSCAN_REVERSE
        idx = pg_leftmost_one_pos32((uint32) size - 1) - ALLOC_MINBITS + 1;
#else
        uint32      t,
                    tsize;
 
        /* Statically assert that we only have a 16-bit input value. */
        StaticAssertDecl(ALLOC_CHUNK_LIMIT < (1 << 16),
                         "ALLOC_CHUNK_LIMIT must be less than 64kB");
 
        tsize = size - 1;
        t = tsize >> 8;
        idx = t ? pg_leftmost_one_pos[t] + 8 : pg_leftmost_one_pos[tsize];
        idx -= ALLOC_MINBITS - 1;
#endif
 
        Assert(idx < ALLOCSET_NUM_FREELISTS);
    }
    else
        idx = 0;
 
    return idx;
}

References ALLOC_CHUNK_LIMIT, ALLOC_MINBITS, ALLOCSET_NUM_FREELISTS, Assert, idx(), pg_leftmost_one_pos, pg_leftmost_one_pos32(), size, and StaticAssertDecl.

Referenced by AllocSetAlloc(), and AllocSetAllocFromNewBlock().

AllocSetGetChunkContext()

MemoryContext AllocSetGetChunkContext

(

void *

pointer

)

Definition at line 1433 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, chunk, ExternalChunkGetBlock, AllocSetContext::header, MemoryChunkGetBlock(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetGetChunkSpace()

Size AllocSetGetChunkSpace

(

void *

pointer

)

Definition at line 1462 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, chunk, AllocBlockData::endptr, ExternalChunkGetBlock, FreeListIdxIsValid, GetChunkSizeFromFreeListIdx, MemoryChunkGetValue(), MemoryChunkIsExternal(), PointerGetMemoryChunk, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetIsEmpty()

bool AllocSetIsEmpty

(

MemoryContext

context

)

Definition at line 1496 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 context.

AllocSetRealloc()

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

Definition at line 1169 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.
         */
        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);
 
        block = (AllocBlock) realloc(block, blksize);
        if (block == NULL)
        {
            /* Disallow access to the chunk header. */
            VALGRIND_MAKE_MEM_NOACCESS(chunk, ALLOC_CHUNKHDRSZ);
            return MemoryContextAllocationFailure(&set->header, size, flags);
        }
 
        /* 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
    /* 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, chunk, elog, AllocBlockData::endptr, ERROR, ExternalChunkGetBlock, FreeListIdxIsValid, AllocBlockData::freeptr, GetChunkSizeFromFreeListIdx, AllocSetContext::header, MAXALIGN, MemoryContextData::mem_allocated, MemoryChunkGetBlock(), MemoryChunkGetPointer, MemoryChunkGetValue(), MemoryChunkIsExternal(), MemoryContextAllocationFailure(), MemoryContextCheckSize(), Min, MemoryContextData::name, AllocBlockData::next, PointerGetMemoryChunk, AllocBlockData::prev, realloc, size, VALGRIND_MAKE_MEM_DEFINED, VALGRIND_MAKE_MEM_NOACCESS, VALGRIND_MAKE_MEM_UNDEFINED, and WARNING.

AllocSetReset()

void AllocSetReset

(

MemoryContext

context

)

Definition at line 537 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
            free(block);
        }
        block = next;
    }
 
    Assert(context->mem_allocated == keepersize);
 
    /* Reset block size allocation sequence, too */
    set->nextBlockSize = set->initBlockSize;
}

References ALLOC_BLOCKHDRSZ, AllocSetIsValid, Assert, AllocSetContext::blocks, context, AllocBlockData::endptr, free, AllocSetContext::freelist, AllocBlockData::freeptr, AllocSetContext::initBlockSize, IsKeeperBlock, KeeperBlock, MemSetAligned, next, AllocBlockData::next, AllocSetContext::nextBlockSize, PG_USED_FOR_ASSERTS_ONLY, AllocBlockData::prev, and VALGRIND_MAKE_MEM_NOACCESS.

AllocSetStats()

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

Definition at line 1521 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, chunk, context, AllocBlockData::endptr, MemoryContextCounters::freechunks, AllocSetContext::freelist, AllocBlockData::freeptr, MemoryContextCounters::freespace, GetChunkSizeFromFreeListIdx, GetFreeListLink, MAXALIGN, MemoryChunkGetValue(), MemoryContextCounters::nblocks, AllocBlockData::next, snprintf, MemoryContextCounters::totalspace, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

Variable Documentation

context_freelists

AllocSetFreeList context_freelists[2]

static

Initial value:

=
{
    {
        0, NULL
    },
    {
        0, NULL
    }
}

Definition at line 257 of file aset.c.

Referenced by AllocSetContextCreateInternal(), and AllocSetDelete().