alignedalloc.c File Reference

#include "postgres.h"
#include "utils/memdebug.h"
#include "utils/memutils_memorychunk.h"

Include dependency graph for alignedalloc.c:

Go to the source code of this file.

Functions
void	AlignedAllocFree (void *pointer)
void *	AlignedAllocRealloc (void *pointer, Size size, int flags)
MemoryContext	AlignedAllocGetChunkContext (void *pointer)
Size	AlignedAllocGetChunkSpace (void *pointer)

Function Documentation

AlignedAllocFree()

void AlignedAllocFree

(

void *

pointer

)

Definition at line 29 of file alignedalloc.c.

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

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

AlignedAllocGetChunkContext()

MemoryContext AlignedAllocGetChunkContext

(

void *

pointer

)

Definition at line 154 of file alignedalloc.c.

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

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

AlignedAllocGetChunkSpace()

Size AlignedAllocGetChunkSpace

(

void *

pointer

)

Definition at line 176 of file alignedalloc.c.

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

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

AlignedAllocRealloc()

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

Definition at line 70 of file alignedalloc.c.

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

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