1/*-------------------------------------------------------------------------
4 * Allocator functions to implement palloc_aligned
6 * This is not a fully-fledged MemoryContext type as there is no means to
7 * create a MemoryContext of this type. The code here only serves to allow
8 * operations such as pfree() and repalloc() to work correctly on a memory
9 * chunk that was allocated by palloc_aligned().
11 * Portions Copyright (c) 2022-2025, PostgreSQL Global Development Group
14 * src/backend/utils/mmgr/alignedalloc.c
16 *-------------------------------------------------------------------------
26* Frees allocated memory; memory is removed from its owning context.
38 /* obtain the original (unaligned) allocated pointer */
41#ifdef MEMORY_CONTEXT_CHECKING
42 /* Test for someone scribbling on unused space in chunk */
43 if (!sentinel_ok(pointer, chunk->requested_size))
44 elog(
WARNING,
"detected write past chunk end in %s %p",
49 * Create a dummy vchunk covering the start of the unaligned chunk, but
50 * not overlapping the aligned chunk. This will be freed while pfree'ing
51 * the unaligned chunk, keeping Valgrind happy. Then when we return to
52 * the outer pfree, that will clean up the vchunk for the aligned chunk.
55 (
char *) pointer - (
char *) unaligned);
57 /* Recursively pfree the unaligned chunk */
63 * Change the allocated size of a chunk and return possibly a different
64 * pointer to a memory address aligned to the same boundary as the
65 * originally requested alignment. The contents of 'pointer' will be
66 * copied into the returned pointer up until 'size'. Any additional
67 * memory will be uninitialized.
84 /* sanity check this is a power of 2 value */
85 Assert((alignto & (alignto - 1)) == 0);
88 * Determine the size of the original allocation. We can't determine this
89 * exactly as GetMemoryChunkSpace() returns the total space used for the
90 * allocation, which for contexts like aset includes rounding up to the
91 * next power of 2. However, this value is just used to memcpy() the old
92 * data into the new allocation, so we only need to concern ourselves with
93 * not reading beyond the end of the original allocation's memory. The
94 * drawback here is that we may copy more bytes than we need to, which
95 * only amounts to wasted effort. We can safely subtract the extra bytes
96 * that we requested to allow us to align the pointer. We must also
97 * subtract the space for the unaligned pointer's MemoryChunk since
98 * GetMemoryChunkSpace should have included that. This does assume that
99 * all context types use MemoryChunk as a chunk header.
104#ifdef MEMORY_CONTEXT_CHECKING
105 /* check that GetMemoryChunkSpace returned something realistic */
106 Assert(old_size >= redirchunk->requested_size);
110 * To keep things simple, we always allocate a new aligned chunk and copy
111 * data into it. Because of the above inaccuracy, this may end in copying
112 * more data than was in the original allocation request size, but that
118 /* Cope cleanly with OOM */
126 * We may memcpy more than the original allocation request size, which
127 * would result in trying to copy trailing bytes that the original
128 * MemoryContextAllocAligned call marked NOACCESS. So we must mark the
129 * entire old_size as defined. That's slightly annoying, but probably not
133 memcpy(newptr, pointer,
Min(size, old_size));
136 * Create a dummy vchunk covering the start of the old unaligned chunk,
137 * but not overlapping the aligned chunk. This will be freed while
138 * pfree'ing the old unaligned chunk, keeping Valgrind happy. Then when
139 * we return to repalloc, it will move the vchunk for the aligned chunk.
142 (
char *) pointer - (
char *) unaligned);
150 * AlignedAllocGetChunkContext
151 * Return the MemoryContext that 'pointer' belongs to.
171 * AlignedAllocGetChunkSpace
172 * Given a currently-allocated chunk, determine the total space
173 * it occupies (including all memory-allocation overhead).
MemoryContext AlignedAllocGetChunkContext(void *pointer)
void * AlignedAllocRealloc(void *pointer, Size size, int flags)
Size AlignedAllocGetChunkSpace(void *pointer)
void AlignedAllocFree(void *pointer)
Assert(PointerIsAligned(start, uint64))
void pfree(void *pointer)
Size GetMemoryChunkSpace(void *pointer)
void * MemoryContextAllocAligned(MemoryContext context, Size size, Size alignto, int flags)
MemoryContext GetMemoryChunkContext(void *pointer)
void * MemoryContextAllocationFailure(MemoryContext context, Size size, int flags)
#define VALGRIND_MAKE_MEM_DEFINED(addr, size)
#define VALGRIND_MEMPOOL_ALLOC(context, addr, size)
#define VALGRIND_MAKE_MEM_NOACCESS(addr, size)
#define PallocAlignedExtraBytes(alignto)
static Size MemoryChunkGetValue(MemoryChunk *chunk)
static bool MemoryChunkIsExternal(MemoryChunk *chunk)
static void * MemoryChunkGetBlock(MemoryChunk *chunk)
struct MemoryChunk MemoryChunk
#define PointerGetMemoryChunk(p)