slab.c File Reference

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

Include dependency graph for slab.c:

Go to the source code of this file.

Data Structures
struct	SlabContext
struct	SlabBlock

Macros
#define	Slab_BLOCKHDRSZ   MAXALIGN(sizeof(SlabBlock))
#define	Slab_CONTEXT_HDRSZ(chunksPerBlock)   sizeof(SlabContext)
#define	SLAB_BLOCKLIST_COUNT   3
#define	SLAB_MAXIMUM_EMPTY_BLOCKS   10
#define	Slab_CHUNKHDRSZ   sizeof(MemoryChunk)
#define	SlabChunkGetPointer(chk)    ((void *) (((char *) (chk)) + sizeof(MemoryChunk)))
#define	SlabBlockGetChunk(slab, block, n)
#define	SlabIsValid(set)   (PointerIsValid(set) && IsA(set, SlabContext))
#define	SlabBlockIsValid(block)    (PointerIsValid(block) && SlabIsValid((block)->slab))

Typedefs
typedef struct SlabContext	SlabContext
typedef struct SlabBlock	SlabBlock

Functions
static int32	SlabBlocklistIndex (SlabContext *slab, int nfree)
static int32	SlabFindNextBlockListIndex (SlabContext *slab)
static MemoryChunk *	SlabGetNextFreeChunk (SlabContext *slab, SlabBlock *block)
MemoryContext	SlabContextCreate (MemoryContext parent, const char *name, Size blockSize, Size chunkSize)
void	SlabReset (MemoryContext context)
void	SlabDelete (MemoryContext context)
static void *	SlabAllocSetupNewChunk (MemoryContext context, SlabBlock *block, MemoryChunk *chunk, Size size)
static pg_noinline void *	SlabAllocFromNewBlock (MemoryContext context, Size size, int flags)
static pg_noinline void	pg_attribute_noreturn () SlabAllocInvalidSize(MemoryContext context
	elog (ERROR, "unexpected alloc chunk size %zu (expected %u)", size, slab->chunkSize)
void *	SlabAlloc (MemoryContext context, Size size, int flags)
void	SlabFree (void *pointer)
void *	SlabRealloc (void *pointer, Size size, int flags)
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)

Variables
static pg_noinline void Size	size

Macro Definition Documentation

Slab_BLOCKHDRSZ

#define Slab_BLOCKHDRSZ   MAXALIGN(sizeof(SlabBlock))

Definition at line 77 of file slab.c.

SLAB_BLOCKLIST_COUNT

#define SLAB_BLOCKLIST_COUNT   3

Definition at line 95 of file slab.c.

Slab_CHUNKHDRSZ

#define Slab_CHUNKHDRSZ   sizeof(MemoryChunk)

Definition at line 157 of file slab.c.

Slab_CONTEXT_HDRSZ

#define Slab_CONTEXT_HDRSZ

(

chunksPerBlock

)

sizeof(SlabContext)

Definition at line 88 of file slab.c.

SLAB_MAXIMUM_EMPTY_BLOCKS

#define SLAB_MAXIMUM_EMPTY_BLOCKS   10

Definition at line 98 of file slab.c.

SlabBlockGetChunk

#define SlabBlockGetChunk	(		slab,
			block,
			n
	)

Value:

    ((MemoryChunk *) ((char *) (block) + Slab_BLOCKHDRSZ    \
                    + ((n) * (slab)->fullChunkSize)))

Definition at line 165 of file slab.c.

SlabBlockIsValid

#define SlabBlockIsValid

(

block

)

(PointerIsValid(block) && SlabIsValid((block)->slab))

Definition at line 202 of file slab.c.

SlabChunkGetPointer

#define SlabChunkGetPointer

(

chk

)

((void *) (((char *) (chk)) + sizeof(MemoryChunk)))

Definition at line 158 of file slab.c.

SlabIsValid

#define SlabIsValid

(

set

)

(PointerIsValid(set) && IsA(set, SlabContext))

Definition at line 196 of file slab.c.

Typedef Documentation

SlabBlock

typedef struct SlabBlock SlabBlock

SlabContext

typedef struct SlabContext SlabContext

Function Documentation

elog()

elog	(	ERROR	,
		"unexpected alloc chunk size %zu (expected %u)"	,
		size	,
		slab->	chunkSize
	)

Referenced by SlabContextCreate(), SlabFree(), and SlabRealloc().

pg_attribute_noreturn()

static pg_noinline void pg_attribute_noreturn ( )

static

SlabAlloc()

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

Definition at line 630 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, chunk, SlabContext::chunkSize, SlabContext::chunksPerBlock, context, SlabContext::curBlocklistIndex, dlist_delete_from(), dlist_head_element, dlist_is_empty(), dlist_push_head(), SlabBlock::nfree, SlabBlock::node, size, SlabAllocFromNewBlock(), SlabAllocSetupNewChunk(), SlabBlocklistIndex(), SlabFindNextBlockListIndex(), SlabGetNextFreeChunk(), SlabIsValid, and unlikely.

SlabAllocFromNewBlock()

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

static

Definition at line 539 of file slab.c.

{
    SlabContext *slab = (SlabContext *) context;
    SlabBlock  *block;
    MemoryChunk *chunk;
    dlist_head *blocklist;
    int         blocklist_idx;
 
    /* to save allocating a new one, first check the empty blocks list */
    if (dclist_count(&slab->emptyblocks) > 0)
    {
        dlist_node *node = dclist_pop_head_node(&slab->emptyblocks);
 
        block = dlist_container(SlabBlock, node, node);
 
        /*
         * SlabFree() should have left this block in a valid state with all
         * chunks free.  Ensure that's the case.
         */
        Assert(block->nfree == slab->chunksPerBlock);
 
        /* fetch the next chunk from this block */
        chunk = SlabGetNextFreeChunk(slab, block);
    }
    else
    {
        block = (SlabBlock *) malloc(slab->blockSize);
 
        if (unlikely(block == NULL))
            return MemoryContextAllocationFailure(context, size, flags);
 
        block->slab = slab;
        context->mem_allocated += slab->blockSize;
 
        /* use the first chunk in the new block */
        chunk = SlabBlockGetChunk(slab, block, 0);
 
        block->nfree = slab->chunksPerBlock - 1;
        block->unused = SlabBlockGetChunk(slab, block, 1);
        block->freehead = NULL;
        block->nunused = slab->chunksPerBlock - 1;
    }
 
    /* find the blocklist element for storing blocks with 1 used chunk */
    blocklist_idx = SlabBlocklistIndex(slab, block->nfree);
    blocklist = &slab->blocklist[blocklist_idx];
 
    /* this better be empty.  We just added a block thinking it was */
    Assert(dlist_is_empty(blocklist));
 
    dlist_push_head(blocklist, &block->node);
 
    slab->curBlocklistIndex = blocklist_idx;
 
    return SlabAllocSetupNewChunk(context, block, chunk, size);
}

References Assert, SlabContext::blocklist, SlabContext::blockSize, chunk, SlabContext::chunksPerBlock, context, SlabContext::curBlocklistIndex, dclist_count(), dclist_pop_head_node(), dlist_container, dlist_is_empty(), dlist_push_head(), SlabContext::emptyblocks, SlabBlock::freehead, malloc, MemoryContextAllocationFailure(), SlabBlock::nfree, SlabBlock::node, SlabBlock::nunused, size, SlabBlock::slab, SlabAllocSetupNewChunk(), SlabBlockGetChunk, SlabBlocklistIndex(), SlabGetNextFreeChunk(), unlikely, and SlabBlock::unused.

Referenced by SlabAlloc().

SlabAllocSetupNewChunk()

static void* SlabAllocSetupNewChunk ( MemoryContext  context, SlabBlock *  block, MemoryChunk *  chunk, Size  size  )

inlinestatic

Definition at line 498 of file slab.c.

{
    SlabContext *slab = (SlabContext *) context;
 
    /*
     * Check that the chunk pointer is actually somewhere on the block and is
     * aligned as expected.
     */
    Assert(chunk >= SlabBlockGetChunk(slab, block, 0));
    Assert(chunk <= SlabBlockGetChunk(slab, block, slab->chunksPerBlock - 1));
    Assert(SlabChunkMod(slab, block, chunk) == 0);
 
    /* Prepare to initialize the chunk header. */
    VALGRIND_MAKE_MEM_UNDEFINED(chunk, Slab_CHUNKHDRSZ);
 
    MemoryChunkSetHdrMask(chunk, block, MAXALIGN(slab->chunkSize), MCTX_SLAB_ID);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* slab mark to catch clobber of "unused" space */
    Assert(slab->chunkSize < (slab->fullChunkSize - Slab_CHUNKHDRSZ));
    set_sentinel(MemoryChunkGetPointer(chunk), size);
    VALGRIND_MAKE_MEM_NOACCESS(((char *) chunk) + Slab_CHUNKHDRSZ +
                               slab->chunkSize,
                               slab->fullChunkSize -
                               (slab->chunkSize + Slab_CHUNKHDRSZ));
#endif
 
#ifdef RANDOMIZE_ALLOCATED_MEMORY
    /* fill the allocated space with junk */
    randomize_mem((char *) MemoryChunkGetPointer(chunk), size);
#endif
 
    /* Disallow access to the chunk header. */
    VALGRIND_MAKE_MEM_NOACCESS(chunk, Slab_CHUNKHDRSZ);
 
    return MemoryChunkGetPointer(chunk);
}

References Assert, chunk, SlabContext::chunkSize, SlabContext::chunksPerBlock, context, SlabContext::fullChunkSize, MAXALIGN, MCTX_SLAB_ID, MemoryChunkGetPointer, MemoryChunkSetHdrMask(), size, Slab_CHUNKHDRSZ, SlabBlockGetChunk, VALGRIND_MAKE_MEM_NOACCESS, and VALGRIND_MAKE_MEM_UNDEFINED.

Referenced by SlabAlloc(), and SlabAllocFromNewBlock().

SlabBlocklistIndex()

static int32 SlabBlocklistIndex ( SlabContext *  slab, int  nfree  )

inlinestatic

Definition at line 211 of file slab.c.

{
    int32       index;
    int32       blocklist_shift = slab->blocklist_shift;
 
    Assert(nfree >= 0 && nfree <= slab->chunksPerBlock);
 
    /*
     * Determine the blocklist index based on the number of free chunks.  We
     * must ensure that 0 free chunks is dedicated to index 0.  Everything
     * else must be >= 1 and < SLAB_BLOCKLIST_COUNT.
     *
     * To make this as efficient as possible, we exploit some two's complement
     * arithmetic where we reverse the sign before bit shifting.  This results
     * in an nfree of 0 using index 0 and anything non-zero staying non-zero.
     * This is exploiting 0 and -0 being the same in two's complement.  When
     * we're done, we just need to flip the sign back over again for a
     * positive index.
     */
    index = -((-nfree) >> blocklist_shift);
 
    if (nfree == 0)
        Assert(index == 0);
    else
        Assert(index >= 1 && index < SLAB_BLOCKLIST_COUNT);
 
    return index;
}

References Assert, SlabContext::blocklist_shift, and SLAB_BLOCKLIST_COUNT.

Referenced by SlabAlloc(), SlabAllocFromNewBlock(), and SlabFree().

SlabContextCreate()

MemoryContext SlabContextCreate	(	MemoryContext	parent,
		const char *	name,
		Size	blockSize,
		Size	chunkSize
	)

Definition at line 322 of file slab.c.

{
    int         chunksPerBlock;
    Size        fullChunkSize;
    SlabContext *slab;
    int         i;
 
    /* ensure MemoryChunk's size is properly maxaligned */
    StaticAssertDecl(Slab_CHUNKHDRSZ == MAXALIGN(Slab_CHUNKHDRSZ),
                     "sizeof(MemoryChunk) is not maxaligned");
    Assert(blockSize <= MEMORYCHUNK_MAX_BLOCKOFFSET);
 
    /*
     * Ensure there's enough space to store the pointer to the next free chunk
     * in the memory of the (otherwise) unused allocation.
     */
    if (chunkSize < sizeof(MemoryChunk *))
        chunkSize = sizeof(MemoryChunk *);
 
    /* length of the maxaligned chunk including the chunk header  */
#ifdef MEMORY_CONTEXT_CHECKING
    /* ensure there's always space for the sentinel byte */
    fullChunkSize = Slab_CHUNKHDRSZ + MAXALIGN(chunkSize + 1);
#else
    fullChunkSize = Slab_CHUNKHDRSZ + MAXALIGN(chunkSize);
#endif
 
    Assert(fullChunkSize <= MEMORYCHUNK_MAX_VALUE);
 
    /* compute the number of chunks that will fit on each block */
    chunksPerBlock = (blockSize - Slab_BLOCKHDRSZ) / fullChunkSize;
 
    /* Make sure the block can store at least one chunk. */
    if (chunksPerBlock == 0)
        elog(ERROR, "block size %zu for slab is too small for %zu-byte chunks",
             blockSize, chunkSize);
 
 
 
    slab = (SlabContext *) malloc(Slab_CONTEXT_HDRSZ(chunksPerBlock));
    if (slab == NULL)
    {
        MemoryContextStats(TopMemoryContext);
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("out of memory"),
                 errdetail("Failed while creating memory context \"%s\".",
                           name)));
    }
 
    /*
     * Avoid writing code that can fail between here and MemoryContextCreate;
     * we'd leak the header if we ereport in this stretch.
     */
 
    /* Fill in SlabContext-specific header fields */
    slab->chunkSize = (uint32) chunkSize;
    slab->fullChunkSize = (uint32) fullChunkSize;
    slab->blockSize = (uint32) blockSize;
    slab->chunksPerBlock = chunksPerBlock;
    slab->curBlocklistIndex = 0;
 
    /*
     * Compute a shift that guarantees that shifting chunksPerBlock with it is
     * < SLAB_BLOCKLIST_COUNT - 1.  The reason that we subtract 1 from
     * SLAB_BLOCKLIST_COUNT in this calculation is that we reserve the 0th
     * blocklist element for blocks which have no free chunks.
     *
     * We calculate the number of bits to shift by rather than a divisor to
     * divide by as performing division each time we need to find the
     * blocklist index would be much slower.
     */
    slab->blocklist_shift = 0;
    while ((slab->chunksPerBlock >> slab->blocklist_shift) >= (SLAB_BLOCKLIST_COUNT - 1))
        slab->blocklist_shift++;
 
    /* initialize the list to store empty blocks to be reused */
    dclist_init(&slab->emptyblocks);
 
    /* initialize each blocklist slot */
    for (i = 0; i < SLAB_BLOCKLIST_COUNT; i++)
        dlist_init(&slab->blocklist[i]);
 
#ifdef MEMORY_CONTEXT_CHECKING
    /* set the isChunkFree pointer right after the end of the context */
    slab->isChunkFree = (bool *) ((char *) slab + sizeof(SlabContext));
#endif
 
    /* Finally, do the type-independent part of context creation */
    MemoryContextCreate((MemoryContext) slab,
                        T_SlabContext,
                        MCTX_SLAB_ID,
                        parent,
                        name);
 
    return (MemoryContext) slab;
}

References Assert, SlabContext::blocklist, SlabContext::blocklist_shift, SlabContext::blockSize, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dclist_init(), dlist_init(), elog(), SlabContext::emptyblocks, ereport, errcode(), errdetail(), errmsg(), ERROR, SlabContext::fullChunkSize, i, malloc, MAXALIGN, MCTX_SLAB_ID, MEMORYCHUNK_MAX_BLOCKOFFSET, MEMORYCHUNK_MAX_VALUE, MemoryContextCreate(), MemoryContextStats(), name, Slab_BLOCKHDRSZ, SLAB_BLOCKLIST_COUNT, Slab_CHUNKHDRSZ, Slab_CONTEXT_HDRSZ, StaticAssertDecl, and TopMemoryContext.

Referenced by for(), and ReorderBufferAllocate().

SlabDelete()

void SlabDelete

(

MemoryContext

context

)

Definition at line 485 of file slab.c.

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

References context, free, and SlabReset().

SlabFindNextBlockListIndex()

static int32 SlabFindNextBlockListIndex ( SlabContext *  slab )

static

Definition at line 251 of file slab.c.

{
    /* start at 1 as blocklist[0] is for full blocks. */
    for (int i = 1; i < SLAB_BLOCKLIST_COUNT; i++)
    {
        /* return the first found non-empty index */
        if (!dlist_is_empty(&slab->blocklist[i]))
            return i;
    }
 
    /* no blocks with free space */
    return 0;
}

References SlabContext::blocklist, dlist_is_empty(), i, and SLAB_BLOCKLIST_COUNT.

Referenced by SlabAlloc(), and SlabFree().

SlabFree()

void SlabFree

(

void *

pointer

)

Definition at line 701 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
    /* 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);
#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
            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, chunk, SlabContext::chunkSize, SlabContext::chunksPerBlock, SlabContext::curBlocklistIndex, dclist_count(), dclist_push_head(), dlist_delete_from(), dlist_is_empty(), dlist_push_head(), elog(), SlabContext::emptyblocks, free, SlabBlock::freehead, SlabContext::fullChunkSize, SlabContext::header, 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, and WARNING.

SlabGetChunkContext()

MemoryContext SlabGetChunkContext

(

void *

pointer

)

Definition at line 863 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, chunk, SlabContext::header, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabGetChunkSpace()

Size SlabGetChunkSpace

(

void *

pointer

)

Definition at line 887 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, chunk, SlabContext::fullChunkSize, MemoryChunkGetBlock(), PointerGetMemoryChunk, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabGetNextFreeChunk()

static MemoryChunk* SlabGetNextFreeChunk ( SlabContext *  slab, SlabBlock *  block  )

inlinestatic

Definition at line 271 of file slab.c.

{
    MemoryChunk *chunk;
 
    Assert(block->nfree > 0);
 
    if (block->freehead != NULL)
    {
        chunk = block->freehead;
 
        /*
         * Pop the chunk from the linked list of free chunks.  The pointer to
         * the next free chunk is stored in the chunk itself.
         */
        VALGRIND_MAKE_MEM_DEFINED(SlabChunkGetPointer(chunk), sizeof(MemoryChunk *));
        block->freehead = *(MemoryChunk **) SlabChunkGetPointer(chunk);
 
        /* check nothing stomped on the free chunk's memory */
        Assert(block->freehead == NULL ||
               (block->freehead >= SlabBlockGetChunk(slab, block, 0) &&
                block->freehead <= SlabBlockGetChunk(slab, block, slab->chunksPerBlock - 1) &&
                SlabChunkMod(slab, block, block->freehead) == 0));
    }
    else
    {
        Assert(block->nunused > 0);
 
        chunk = block->unused;
        block->unused = (MemoryChunk *) (((char *) block->unused) + slab->fullChunkSize);
        block->nunused--;
    }
 
    block->nfree--;
 
    return chunk;
}

References Assert, chunk, SlabContext::chunksPerBlock, SlabBlock::freehead, SlabContext::fullChunkSize, SlabBlock::nfree, SlabBlock::nunused, SlabBlockGetChunk, SlabChunkGetPointer, SlabBlock::unused, and VALGRIND_MAKE_MEM_DEFINED.

Referenced by SlabAlloc(), and SlabAllocFromNewBlock().

SlabIsEmpty()

bool SlabIsEmpty

(

MemoryContext

context

)

Definition at line 912 of file slab.c.

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

References Assert, context, and SlabIsValid.

SlabRealloc()

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

Definition at line 826 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 chunk, SlabContext::chunkSize, elog(), ERROR, MemoryChunkGetBlock(), PointerGetMemoryChunk, size, SlabBlock::slab, Slab_CHUNKHDRSZ, SlabBlockIsValid, VALGRIND_MAKE_MEM_DEFINED, and VALGRIND_MAKE_MEM_NOACCESS.

SlabReset()

void SlabReset

(

MemoryContext

context

)

Definition at line 431 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
        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
            free(block);
            context->mem_allocated -= slab->blockSize;
        }
    }
 
    slab->curBlocklistIndex = 0;
 
    Assert(context->mem_allocated == 0);
}

References Assert, SlabContext::blocklist, SlabContext::blockSize, context, dlist_mutable_iter::cur, SlabContext::curBlocklistIndex, dclist_delete_from(), dclist_foreach_modify, dlist_container, dlist_delete(), dlist_foreach_modify, SlabContext::emptyblocks, free, i, SLAB_BLOCKLIST_COUNT, and SlabIsValid.

Referenced by SlabDelete().

SlabStats()

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

Definition at line 929 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, context, dlist_iter::cur, dclist_count(), dlist_container, dlist_foreach, SlabContext::emptyblocks, MemoryContextCounters::freechunks, MemoryContextCounters::freespace, SlabContext::fullChunkSize, i, MemoryContextCounters::nblocks, SlabBlock::nfree, SLAB_BLOCKLIST_COUNT, Slab_CONTEXT_HDRSZ, SlabIsValid, snprintf, and MemoryContextCounters::totalspace.

Variable Documentation

size

pg_noinline void Size size

Initial value:

{
    SlabContext *slab = (SlabContext *) context

Definition at line 606 of file slab.c.

Referenced by _bt_pageinit(), _crypt_blowfish_rn(), _crypt_gensalt_blowfish_rn(), _crypt_gensalt_extended_rn(), _crypt_gensalt_md5_rn(), _crypt_gensalt_traditional_rn(), _hash_pageinit(), _intbig_alloc(), _ltree_union(), _pglstat64(), _pgstat64(), add_file_to_manifest(), AddFileToBackupManifest(), addOrReplaceTuple(), ahwrite(), AlignedAllocRealloc(), alloc_object(), allocacl(), allocate_reloption(), allocateReloptStruct(), AllocSetAlloc(), AllocSetAllocChunkFromBlock(), AllocSetAllocFromNewBlock(), AllocSetAllocLarge(), AllocSetFreeIndex(), AllocSetRealloc(), AppendJumble(), ApplyLauncherShmemSize(), array_agg_array_combine(), array_agg_array_deserialize(), ASN1_STRING_to_text(), AsyncShmemInit(), AsyncShmemSize(), AutoVacuumShmemSize(), BackendStatusShmemInit(), BackendStatusShmemSize(), BackgroundWorkerShmemSize(), BF_decode(), BF_encode(), bms_copy(), box_poly(), brin_form_placeholder_tuple(), brin_form_tuple(), bringetbitmap(), brinGetTupleForHeapBlock(), bsearch_arg(), BTreeShmemSize(), BufferManagerShmemSize(), BufFileRead(), BufFileReadCommon(), BufFileReadExact(), BufFileReadMaybeEOF(), BufFileWrite(), BufTableShmemSize(), build_hash_table(), BumpAlloc(), BumpAllocChunkFromBlock(), BumpAllocFromNewBlock(), BumpAllocLarge(), calc_rank_and(), calc_rank_or(), calcstrlen(), calculate_indexes_size(), calculate_table_size(), calculate_toast_table_size(), calculate_total_relation_size(), CalculateShmemSize(), check_synchronized_standby_slots(), checkdig(), CheckpointerShmemInit(), CheckpointerShmemSize(), chooseNextStatEntry(), circle_poly(), combinebackup_per_file_cb(), compact_palloc0(), CopyIndexTuple(), CopyMultiInsertBufferFlush(), CopySnapshot(), count_usable_fds(), crc32_sz(), create_internal(), CreateAnonymousSegment(), CreateSharedMemoryAndSemaphores(), cube_a_f8(), cube_a_f8_f8(), cube_c_f8(), cube_c_f8_f8(), cube_enlarge(), cube_f8(), cube_f8_f8(), cube_inter(), cube_subset(), cube_union_v0(), datumGetSize(), decoct(), DecodeXLogRecordRequiredSpace(), dense_alloc(), digestControlFile(), doPickSplit(), dsa_allocate_extended(), dsa_create_in_place_ext(), dsa_free(), dsa_get_total_size(), dsa_minimum_size(), dshash_destroy(), dshash_memcmp(), dshash_memcpy(), dshash_memhash(), dshash_strcmp(), dshash_strcpy(), dshash_strhash(), dsm_create(), dsm_impl_posix_resize(), dsm_shmem_init(), dummy_ssl_passwd_cb(), DynaHashAlloc(), ecpg_alloc(), ecpg_auto_alloc(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_get_data(), ecpg_realloc(), ecpg_sqlda_align_add_size(), ECPGdump_a_simple(), ECPGmake_array_type(), ECPGmake_simple_type(), emalloc(), entrySplitPage(), erealloc(), estimate_variable_size(), EstimateClientConnectionInfoSpace(), EstimateComboCIDStateSpace(), EstimateGUCStateSpace(), EstimateLibraryStateSpace(), EstimateSnapshotSpace(), EstimateTransactionStateSpace(), evalStandardFunc(), ExecAggEstimate(), ExecAggInitializeDSM(), ExecAggRetrieveInstrumentation(), ExecBitmapHeapEstimate(), ExecBitmapHeapInitializeDSM(), ExecBitmapHeapRetrieveInstrumentation(), ExecHashEstimate(), ExecHashInitializeDSM(), ExecHashRetrieveInstrumentation(), ExecIncrementalSortEstimate(), ExecIncrementalSortInitializeDSM(), ExecIncrementalSortRetrieveInstrumentation(), ExecMemoizeEstimate(), ExecMemoizeInitializeDSM(), ExecMemoizeRetrieveInstrumentation(), ExecParallelHashIncreaseNumBuckets(), ExecParallelHashTupleAlloc(), ExecParallelHashTuplePrealloc(), ExecSortEstimate(), ExecSortInitializeDSM(), ExecSortRetrieveInstrumentation(), executeItemOptUnwrapTarget(), fill_buffer(), fillRelOptions(), filter_get_keyword(), filter_read_item(), findoprnd(), form_and_insert_tuple(), form_and_spill_tuple(), g_int_union(), g_intbig_union(), gbt_bit_union(), gbt_bytea_union(), gbt_numeric_union(), gbt_text_union(), gbt_var_union(), GenerationAlloc(), GenerationAllocChunkFromBlock(), GenerationAllocFromNewBlock(), GenerationAllocLarge(), GenerationRealloc(), get_decomposed_size(), get_object_type(), GetFileBackupMethod(), GetNamedDSMSegment(), GetPermutation(), gets_none(), GetSessionDsmHandle(), ghstore_alloc(), ghstore_union(), gimme_pool_size(), gistfitpage(), gistnospace(), gtrgm_alloc(), gtrgm_union(), gtsquery_union(), gtsvector_alloc(), gtsvector_union(), guc_malloc(), guc_realloc(), hash_estimate_size(), index_form_tuple_context(), inet_cidr_ntop_ipv4(), inet_cidr_ntop_ipv6(), inet_cidr_pton_ipv4(), inet_cidr_pton_ipv6(), inet_net_ntop_ipv4(), inet_net_ntop_ipv6(), inet_net_pton_ipv4(), InitBufTable(), initStringInfo(), injection_shmem_request(), internal_size(), InternalIpcMemoryCreate(), json_manifest_finalize_file(), json_parse_manifest(), json_parse_manifest_incremental_chunk(), len_utf8(), LockManagerShmemSize(), LogicalTapeBackspace(), LogicalTapeRead(), LogicalTapeWrite(), LogLogicalMessage(), lrq_alloc(), ltree_crc32_sz(), ltree_gist_alloc(), ltree_union(), LWLockShmemSize(), main(), make_multirange(), makeParamList(), makeSublist(), manifest_process_file(), memcpyInnerDatum(), MemoryContextAlloc(), MemoryContextAllocAligned(), MemoryContextAllocationFailure(), MemoryContextAllocExtended(), MemoryContextAllocHuge(), MemoryContextAllocZero(), MemoryContextCheckSize(), MemoryContextSizeFailure(), mm_alloc(), moveLeafs(), multirange_size_estimate(), MultiXactShmemSize(), mXactCacheGetById(), my_sock_read(), my_sock_write(), newNode(), open_walfile(), PageAddItemExtended(), PageIndexMultiDelete(), PageIndexTupleDelete(), PageIndexTupleDeleteNoCompact(), PageSetPageSizeAndVersion(), pagetable_allocate(), palloc(), palloc0(), palloc_aligned(), palloc_extended(), path_add(), path_in(), path_poly(), path_recv(), perform_rewind(), permute(), pg_database_size_name(), pg_database_size_oid(), pg_indexes_size(), pg_inet_cidr_ntop(), pg_inet_net_ntop(), pg_inet_net_pton(), pg_malloc(), pg_malloc0(), pg_malloc_extended(), pg_malloc_internal(), pg_pread(), pg_pwrite(), pg_pwrite_zeros(), pg_realloc(), pg_relation_size(), pg_size_pretty(), pg_size_pretty_numeric(), pg_table_size(), pg_tablespace_size_name(), pg_tablespace_size_oid(), pg_total_relation_size(), PgArchShmemSize(), PGSharedMemoryCreate(), pgss_memsize(), pgstat_cmp_hash_key(), pgstat_hash_hash_key(), pgtypes_alloc(), PGTYPESnumeric_from_long(), PLyBytes_FromBytea(), PLyObject_ToBytea(), PLyUnicode_FromStringAndSize(), PMSignalShmemSize(), pnstrdup(), poly_in(), poly_path(), poly_recv(), pq_getkeepalivescount(), pq_getkeepalivesidle(), pq_getkeepalivesinterval(), pq_gettcpusertimeout(), PQdefaultSSLKeyPassHook_OpenSSL(), PQssl_passwd_cb(), PredicateLockShmemSize(), ProcArrayShmemSize(), process_source_file(), process_target_file(), ProcGlobalShmemSize(), ProcSignalShmemInit(), ProcSignalShmemSize(), random_init_pool(), range_search(), rbt_populate(), read_gucstate_binary(), read_none(), read_stream_begin_impl(), ReorderBufferCopySnap(), ReorderBufferRestoreChange(), ReorderBufferSerializeChange(), ReorderBufferSerializeTXN(), repalloc(), repalloc0(), repalloc_extended(), repalloc_huge(), ReplicationOriginShmemSize(), ReplicationSlotsShmemSize(), ReportTemporaryFileUsage(), RequestAddinShmemSpace(), ReserveXLogInsertLocation(), ReserveXLogSwitch(), resize(), RestoreSnapshot(), rot13_passphrase(), rt__int_size(), rt_cube_size(), rt_seg_size(), run_ssl_passphrase_command(), sendDir(), sendTablespace(), SerializeParamExecParams(), SerializeUncommittedEnums(), setup_simple_rel_arrays(), SharedInvalShmemSize(), shm_mq_create(), ShmemAlloc(), ShmemAllocNoError(), ShmemAllocRaw(), ShmemAllocUnlocked(), ShmemInitStruct(), sizebitvec(), SlabAlloc(), SlabAllocFromNewBlock(), SlabAllocSetupNewChunk(), SlabRealloc(), SlotSyncShmemInit(), SN_set_current(), SnapBuildRestoreContents(), SortAndUniqItems(), spgFormInnerTuple(), spgFormLeafTuple(), spgFormNodeTuple(), SpGistGetInnerTypeSize(), SpGistGetLeafTupleSize(), SpGistPageAddNewItem(), SPI_palloc(), SPI_repalloc(), ssl_external_passwd_cb(), StrategyShmemSize(), sts_flush_chunk(), sts_puttuple(), sts_read_tuple(), test_rb_tree(), testdelete(), testfind(), testfindltgt(), testleftmost(), testleftright(), testrightleft(), transfer_single_new_db(), tsqueryrecv(), tsvector_concat(), tuplesort_putbrintuple(), TwoPhaseShmemSize(), unicode_assigned(), unicode_is_normalized(), unicode_normalize_func(), verify_manifest_checksum(), verifybackup_per_file_cb(), WaitLSNShmemSize(), WalRcvShmemSize(), WalSndShmemSize(), weight_checkdig(), write_none(), write_target_range(), writeListPage(), writeTimeLineHistoryFile(), X509_NAME_to_cstring(), XLogReaderSetDecodeBuffer(), XLogRecoveryShmemSize(), and XLOGShmemSize().