Hi,
On 2017-02-21 01:43:46 +0100, Tomas Vondra wrote:
> Attached is v9 of this patch series. This addresses most of the points
> raised in the review, namely:
Cool, thanks.
> 3) get rid of the block-level bitmap tracking free chunks
>
> Instead of the bitmap, I've used a simple singly-linked list, using int32
> chunk indexes. Perhaps it could use the slist instead, but I'm not quite
> sure MAXALIGN is guaranteed to be greater than pointer.
I'm pretty sure it's guaranteed to be >= sizeof(void*). But this seems
ok, so ...
Attached are changes I made on the path to committing the patch. These
look large enough that I wanted to give you a chance to comment:
- The AllocFreeInfo changes aren't correct for 32bit systems with 64bit,
longs (like linux, unlike windows) - using %zu is better (z is code
for size_t sized)
- Split off the reorderbuffer changes
- Removed SlabBlock/SlabChunk / renamed SlabBlockData
-
+#ifdef MEMORY_CONTEXT_CHECKING
+#define SLAB_CHUNK_USED \
+ (offsetof(SlabChunkData, requested_size) + sizeof(Size))
+#else
doesn't work anymore, because requested_size isn't a top-level
field. I first redefined it as (without surrounding ifdef)
#define SLAB_CHUNK_USED \
(offsetof(SlabChunkData, header) + sizeof(StandardChunkHeader))
but I'm not really sure there's a whole lot of point in the define
rather than just using sizeof() on the whole thing - there's no trailing
padding?
- SLAB_CHUNK_PUBLIC and SLAB_BLOCKHDRSZ are unused?
- renamed 'set' variables (and comments) to slab.
- used castNode(SlabContext, context) instead of manual casts
- I rephrased
+ *
+ * We cache indexes of the first empty chunk on each block
(firstFreeChunk),
+ * and freelist index for blocks with least free chunks (minFreeChunks), so
+ * that we don't have to search the freelist and block on every SlabAlloc()
+ * call, which is quite expensive.
so it's not referencing firstFreeChunk anymore, since that seems to
make less sense now that firstFreeChunk is essentially just the head
of the list of free chunks.
- added typedefs.list entries and pgindented slab.c
- "mark the chunk as unused (zero the bit)" referenced non-existant
bitmap afaics.
- valgrind was triggering on
block->firstFreeChunk = *(int32 *) SlabChunkGetPointer(chunk);
because that was previously marked as NOACCESS (via
wipe_mem). Explicitly marking as DEFINED solves that.
- removed
* XXX Perhaps we should not be gentle at all and simply fails in all cases,
* to eliminate the (mostly pointless) uncertainty.
- you'd included MemoryContext tup_context; in 0002, but it's not really
useful yet (and the comments above it in reorderbuffer.h don't apply)
- SlabFreeInfo/SlabAllocInfo didn't actually compile w/ HAVE_ALLOCINFO
defined (pre StandardChunkHeader def)
- some minor stuff.
I'm kinda inclined to drop SlabFreeInfo/SlabAllocInfo.
I've not yet looked a lot at the next type of context - I want to get
this much committed first...
I plan to give this another pass sometime this weekend and then push
soon.
- Andres
>From cec3f8372137d2392ff7ac0ab1b2db11fc96e8b3 Mon Sep 17 00:00:00 2001
From: Andres Freund <and...@anarazel.de>
Date: Thu, 23 Feb 2017 22:35:44 -0800
Subject: [PATCH 1/3] Make useful infrastructure from aset.c generally
available.
An upcoming patch introduces a new type of memory context. To avoid
duplicating debugging infrastructure with aset.c move useful pieces to
memdebug.[ch].
While touching aset.c, fix printf format AllocFree* debug macros.
Author: Tomas Vondra
Reviewed-By: Andres Freund
Discussion: https://postgr.es/m/b3b2245c-b37a-e1e5-ebc4-857c914bc...@2ndquadrant.com
---
src/backend/utils/mmgr/Makefile | 2 +-
src/backend/utils/mmgr/aset.c | 115 +-------------------------------------
src/backend/utils/mmgr/memdebug.c | 93 ++++++++++++++++++++++++++++++
src/include/utils/memdebug.h | 48 ++++++++++++++++
4 files changed, 144 insertions(+), 114 deletions(-)
create mode 100644 src/backend/utils/mmgr/memdebug.c
diff --git a/src/backend/utils/mmgr/Makefile b/src/backend/utils/mmgr/Makefile
index 1842bae386..fc5f793b7f 100644
--- a/src/backend/utils/mmgr/Makefile
+++ b/src/backend/utils/mmgr/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/utils/mmgr
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
-OBJS = aset.o dsa.o freepage.o mcxt.o portalmem.o
+OBJS = aset.o dsa.o freepage.o mcxt.o memdebug.o portalmem.o
include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/utils/mmgr/aset.c b/src/backend/utils/mmgr/aset.c
index 4dfc3ec260..8056c00ae4 100644
--- a/src/backend/utils/mmgr/aset.c
+++ b/src/backend/utils/mmgr/aset.c
@@ -41,46 +41,6 @@
* chunks as chunks. Anything "large" is passed off to malloc(). Change
* the number of freelists to change the small/large boundary.
*
- *
- * About CLOBBER_FREED_MEMORY:
- *
- * If this symbol is defined, all freed memory is overwritten with 0x7F's.
- * This is useful for catching places that reference already-freed memory.
- *
- * About MEMORY_CONTEXT_CHECKING:
- *
- * Since we usually round request sizes up to the next power of 2, there
- * is often some unused space immediately after a requested data area.
- * Thus, if someone makes the common error of writing past what they've
- * requested, the problem is likely to go unnoticed ... until the day when
- * there *isn't* any wasted space, perhaps because of different memory
- * alignment on a new platform, or some other effect. To catch this sort
- * of problem, the MEMORY_CONTEXT_CHECKING option stores 0x7E just beyond
- * the requested space whenever the request is less than the actual chunk
- * size, and verifies that the byte is undamaged when the chunk is freed.
- *
- *
- * About USE_VALGRIND and Valgrind client requests:
- *
- * Valgrind provides "client request" macros that exchange information with
- * the host Valgrind (if any). Under !USE_VALGRIND, memdebug.h stubs out
- * currently-used macros.
- *
- * When running under Valgrind, we want a NOACCESS memory region both before
- * and after the allocation. The chunk header is tempting as the preceding
- * region, but mcxt.c expects to able to examine the standard chunk header
- * fields. Therefore, we use, when available, the requested_size field and
- * any subsequent padding. requested_size is made NOACCESS before returning
- * a chunk pointer to a caller. However, to reduce client request traffic,
- * it is kept DEFINED in chunks on the free list.
- *
- * The rounded-up capacity of the chunk usually acts as a post-allocation
- * NOACCESS region. If the request consumes precisely the entire chunk,
- * there is no such region; another chunk header may immediately follow. In
- * that case, Valgrind will not detect access beyond the end of the chunk.
- *
- * See also the cooperating Valgrind client requests in mcxt.c.
- *
*-------------------------------------------------------------------------
*/
@@ -296,10 +256,10 @@ static const unsigned char LogTable256[256] =
*/
#ifdef HAVE_ALLOCINFO
#define AllocFreeInfo(_cxt, _chunk) \
- fprintf(stderr, "AllocFree: %s: %p, %d\n", \
+ fprintf(stderr, "AllocFree: %s: %p, %zu\n", \
(_cxt)->header.name, (_chunk), (_chunk)->size)
#define AllocAllocInfo(_cxt, _chunk) \
- fprintf(stderr, "AllocAlloc: %s: %p, %d\n", \
+ fprintf(stderr, "AllocAlloc: %s: %p, %zu\n", \
(_cxt)->header.name, (_chunk), (_chunk)->size)
#else
#define AllocFreeInfo(_cxt, _chunk)
@@ -345,77 +305,6 @@ AllocSetFreeIndex(Size size)
return idx;
}
-#ifdef CLOBBER_FREED_MEMORY
-
-/* Wipe freed memory for debugging purposes */
-static void
-wipe_mem(void *ptr, size_t size)
-{
- VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
- memset(ptr, 0x7F, size);
- VALGRIND_MAKE_MEM_NOACCESS(ptr, size);
-}
-#endif
-
-#ifdef MEMORY_CONTEXT_CHECKING
-static void
-set_sentinel(void *base, Size offset)
-{
- char *ptr = (char *) base + offset;
-
- VALGRIND_MAKE_MEM_UNDEFINED(ptr, 1);
- *ptr = 0x7E;
- VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
-}
-
-static bool
-sentinel_ok(const void *base, Size offset)
-{
- const char *ptr = (const char *) base + offset;
- bool ret;
-
- VALGRIND_MAKE_MEM_DEFINED(ptr, 1);
- ret = *ptr == 0x7E;
- VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
-
- return ret;
-}
-#endif
-
-#ifdef RANDOMIZE_ALLOCATED_MEMORY
-
-/*
- * Fill a just-allocated piece of memory with "random" data. It's not really
- * very random, just a repeating sequence with a length that's prime. What
- * we mainly want out of it is to have a good probability that two palloc's
- * of the same number of bytes start out containing different data.
- *
- * The region may be NOACCESS, so make it UNDEFINED first to avoid errors as
- * we fill it. Filling the region makes it DEFINED, so make it UNDEFINED
- * again afterward. Whether to finally make it UNDEFINED or NOACCESS is
- * fairly arbitrary. UNDEFINED is more convenient for AllocSetRealloc(), and
- * other callers have no preference.
- */
-static void
-randomize_mem(char *ptr, size_t size)
-{
- static int save_ctr = 1;
- size_t remaining = size;
- int ctr;
-
- ctr = save_ctr;
- VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
- while (remaining-- > 0)
- {
- *ptr++ = ctr;
- if (++ctr > 251)
- ctr = 1;
- }
- VALGRIND_MAKE_MEM_UNDEFINED(ptr - size, size);
- save_ctr = ctr;
-}
-#endif /* RANDOMIZE_ALLOCATED_MEMORY */
-
/*
* Public routines
diff --git a/src/backend/utils/mmgr/memdebug.c b/src/backend/utils/mmgr/memdebug.c
new file mode 100644
index 0000000000..5f603d29a7
--- /dev/null
+++ b/src/backend/utils/mmgr/memdebug.c
@@ -0,0 +1,93 @@
+/*-------------------------------------------------------------------------
+ *
+ * memdebug.c
+ * Declarations used in memory context implementations, not part of the
+ * public API of the memory management subsystem.
+ *
+ *
+ * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/backend/utils/memdebug.c
+ *
+ *
+ * About CLOBBER_FREED_MEMORY:
+ *
+ * If this symbol is defined, all freed memory is overwritten with 0x7F's.
+ * This is useful for catching places that reference already-freed memory.
+ *
+ * About MEMORY_CONTEXT_CHECKING:
+ *
+ * Since we usually round request sizes up to the next power of 2, there
+ * is often some unused space immediately after a requested data area.
+ * Thus, if someone makes the common error of writing past what they've
+ * requested, the problem is likely to go unnoticed ... until the day when
+ * there *isn't* any wasted space, perhaps because of different memory
+ * alignment on a new platform, or some other effect. To catch this sort
+ * of problem, the MEMORY_CONTEXT_CHECKING option stores 0x7E just beyond
+ * the requested space whenever the request is less than the actual chunk
+ * size, and verifies that the byte is undamaged when the chunk is freed.
+ *
+ *
+ * About USE_VALGRIND and Valgrind client requests:
+ *
+ * Valgrind provides "client request" macros that exchange information with
+ * the host Valgrind (if any). Under !USE_VALGRIND, memdebug.h stubs out
+ * currently-used macros.
+ *
+ * When running under Valgrind, we want a NOACCESS memory region both before
+ * and after the allocation. The chunk header is tempting as the preceding
+ * region, but mcxt.c expects to able to examine the standard chunk header
+ * fields. Therefore, we use, when available, the requested_size field and
+ * any subsequent padding. requested_size is made NOACCESS before returning
+ * a chunk pointer to a caller. However, to reduce client request traffic,
+ * it is kept DEFINED in chunks on the free list.
+ *
+ * The rounded-up capacity of the chunk usually acts as a post-allocation
+ * NOACCESS region. If the request consumes precisely the entire chunk,
+ * there is no such region; another chunk header may immediately follow. In
+ * that case, Valgrind will not detect access beyond the end of the chunk.
+ *
+ * See also the cooperating Valgrind client requests in mcxt.c.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "utils/memdebug.h"
+
+#ifdef RANDOMIZE_ALLOCATED_MEMORY
+
+/*
+ * Fill a just-allocated piece of memory with "random" data. It's not really
+ * very random, just a repeating sequence with a length that's prime. What
+ * we mainly want out of it is to have a good probability that two palloc's
+ * of the same number of bytes start out containing different data.
+ *
+ * The region may be NOACCESS, so make it UNDEFINED first to avoid errors as
+ * we fill it. Filling the region makes it DEFINED, so make it UNDEFINED
+ * again afterward. Whether to finally make it UNDEFINED or NOACCESS is
+ * fairly arbitrary. UNDEFINED is more convenient for SlabRealloc(), and
+ * other callers have no preference.
+ */
+void
+randomize_mem(char *ptr, size_t size)
+{
+ static int save_ctr = 1;
+ size_t remaining = size;
+ int ctr;
+
+ ctr = save_ctr;
+ VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
+ while (remaining-- > 0)
+ {
+ *ptr++ = ctr;
+ if (++ctr > 251)
+ ctr = 1;
+ }
+ VALGRIND_MAKE_MEM_UNDEFINED(ptr - size, size);
+ save_ctr = ctr;
+}
+
+#endif /* RANDOMIZE_ALLOCATED_MEMORY */
diff --git a/src/include/utils/memdebug.h b/src/include/utils/memdebug.h
index 90eb926ddf..206e6ce002 100644
--- a/src/include/utils/memdebug.h
+++ b/src/include/utils/memdebug.h
@@ -31,4 +31,52 @@
#define VALGRIND_MEMPOOL_CHANGE(context, optr, nptr, size) do {} while (0)
#endif
+
+#ifdef CLOBBER_FREED_MEMORY
+
+/* Wipe freed memory for debugging purposes */
+static inline void
+wipe_mem(void *ptr, size_t size)
+{
+ VALGRIND_MAKE_MEM_UNDEFINED(ptr, size);
+ memset(ptr, 0x7F, size);
+ VALGRIND_MAKE_MEM_NOACCESS(ptr, size);
+}
+
+#endif /* CLOBBER_FREED_MEMORY */
+
+#ifdef MEMORY_CONTEXT_CHECKING
+
+static inline void
+set_sentinel(void *base, Size offset)
+{
+ char *ptr = (char *) base + offset;
+
+ VALGRIND_MAKE_MEM_UNDEFINED(ptr, 1);
+ *ptr = 0x7E;
+ VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
+}
+
+static inline bool
+sentinel_ok(const void *base, Size offset)
+{
+ const char *ptr = (const char *) base + offset;
+ bool ret;
+
+ VALGRIND_MAKE_MEM_DEFINED(ptr, 1);
+ ret = *ptr == 0x7E;
+ VALGRIND_MAKE_MEM_NOACCESS(ptr, 1);
+
+ return ret;
+}
+
+#endif /* MEMORY_CONTEXT_CHECKING */
+
+#ifdef RANDOMIZE_ALLOCATED_MEMORY
+
+void randomize_mem(char *ptr, size_t size);
+
+#endif /* RANDOMIZE_ALLOCATED_MEMORY */
+
+
#endif /* MEMDEBUG_H */
--
2.11.0.22.g8d7a455.dirty
>From e7b4ed53e67974663f5ea6863bb83bfcb76ada80 Mon Sep 17 00:00:00 2001
From: Andres Freund <and...@anarazel.de>
Date: Fri, 24 Feb 2017 13:51:44 -0800
Subject: [PATCH 2/3] Add "Slab" MemoryContext implementation for efficient
equal-sized allocations.
Author: Tomas Vondra, editorialized by Andres Freund
Reviewed-By: Andres Freund, Petr Jelinek, Robert Haas, Jim Nasby,
Discussion: https://postgr.es/m/d15dff83-0b37-28ed-0809-95a5cc729...@2ndquadrant.com
---
src/backend/utils/mmgr/Makefile | 2 +-
src/backend/utils/mmgr/slab.c | 790 +++++++++++++++++++++++++++++++++++++++
src/include/nodes/memnodes.h | 2 +-
src/include/nodes/nodes.h | 1 +
src/include/utils/memutils.h | 9 +
src/tools/pgindent/typedefs.list | 3 +
6 files changed, 805 insertions(+), 2 deletions(-)
create mode 100644 src/backend/utils/mmgr/slab.c
diff --git a/src/backend/utils/mmgr/Makefile b/src/backend/utils/mmgr/Makefile
index fc5f793b7f..cd0e803253 100644
--- a/src/backend/utils/mmgr/Makefile
+++ b/src/backend/utils/mmgr/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/utils/mmgr
top_builddir = ../../../..
include $(top_builddir)/src/Makefile.global
-OBJS = aset.o dsa.o freepage.o mcxt.o memdebug.o portalmem.o
+OBJS = aset.o dsa.o freepage.o mcxt.o memdebug.o portalmem.o slab.o
include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/utils/mmgr/slab.c b/src/backend/utils/mmgr/slab.c
new file mode 100644
index 0000000000..c9e99c12b2
--- /dev/null
+++ b/src/backend/utils/mmgr/slab.c
@@ -0,0 +1,790 @@
+/*-------------------------------------------------------------------------
+ *
+ * slab.c
+ * SLAB allocator definitions.
+ *
+ * SLAB is a MemoryContext implementation designed for cases where large
+ * numbers of equally-sized objects are allocated (and freed).
+ *
+ *
+ * Portions Copyright (c) 2017, PostgreSQL Global Development Group
+ *
+ * IDENTIFICATION
+ * src/backend/utils/mmgr/slab.c
+ *
+ *
+ * NOTE:
+ * The constant allocation size allows significant simplification and various
+ * optimizations over more general purpose allocators. The blocks are carved
+ * into chunks of exactly the right size (plus alignment), not wasting any
+ * memory.
+ *
+ * The information about free chunks is maintained both at the block level and
+ * global (context) level. This is possible as the chunk size (and thus also
+ * the number of chunks per block) is fixed.
+ *
+ * On each block, free chunks are tracked in a simple linked list. Contents
+ * of free chunks is replaced with an index of the next free chunk, forming
+ * a very simple linked list. Each block also contains a counter of free
+ * chunks. Combined with the local block-level freelist, it makes it trivial
+ * to eventually free the whole block.
+ *
+ * At the context level, we use 'freelist' to track blocks ordered by number
+ * of free chunks, starting with blocks having a single allocated chunk, and
+ * with completely full blocks on the tail.
+ *
+ * This also allows various optimizations - for example when searching for
+ * free chunk, the allocator reuses space from the fullest blocks first, in
+ * the hope that some of the less full blocks will get completely empty (and
+ * returned back to the OS).
+ *
+ * For each block, we maintain pointer to the first free chunk - this is quite
+ * cheap and allows us to skip all the preceding used chunks, eliminating
+ * a significant number of lookups in many common usage patters. In the worst
+ * case this performs as if the pointer was not maintained.
+ *
+ * We cache the freelist index for the blocks with the fewest free chunks
+ * (minFreeChunks), so that we don't have to search the freelist on every
+ * SlabAlloc() call, which is quite expensive.
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "utils/memdebug.h"
+#include "utils/memutils.h"
+#include "lib/ilist.h"
+
+
+#define SLAB_CHUNKHDRSZ MAXALIGN(sizeof(SlabChunk))
+
+/* Portion of SLAB_CHUNKHDRSZ excluding trailing padding. */
+#define SLAB_CHUNK_USED \
+ (offsetof(SlabChunk, header) + sizeof(StandardChunkHeader))
+
+/*
+ * SlabContext is a specialized implementation of MemoryContext.
+ */
+typedef struct SlabContext
+{
+ MemoryContextData header; /* Standard memory-context fields */
+ /* Allocation parameters for this context: */
+ Size chunkSize; /* chunk size */
+ Size fullChunkSize; /* chunk size including header and alignment */
+ Size blockSize; /* block size */
+ int chunksPerBlock; /* number of chunks per block */
+ int minFreeChunks; /* min number of free chunks in any block */
+ int nblocks; /* number of blocks allocated */
+ /* blocks with free space, grouped by number of free chunks: */
+ dlist_head freelist[FLEXIBLE_ARRAY_MEMBER];
+} SlabContext;
+
+/*
+ * SlabBlock
+ * Structure of a single block in SLAB allocator.
+ *
+ * node: doubly-linked list of blocks in global freelist
+ * nfree: number of free chunks in this block
+ * firstFreeChunk: index of the first free chunk
+ */
+typedef struct SlabBlock
+{
+ dlist_node node; /* doubly-linked list */
+ int nfree; /* number of free chunks */
+ int firstFreeChunk; /* index of the first free chunk in the block */
+} SlabBlock;
+
+/*
+ * SlabChunk
+ * The prefix of each piece of memory in an SlabBlock
+ */
+typedef struct SlabChunk
+{
+ /* block owning this chunk */
+ void *block;
+
+ /* include StandardChunkHeader because mcxt.c expects that */
+ StandardChunkHeader header;
+
+} SlabChunk;
+
+
+#define SlabPointerGetChunk(ptr) \
+ ((SlabChunk *)(((char *)(ptr)) - SLAB_CHUNKHDRSZ))
+#define SlabChunkGetPointer(chk) \
+ ((void *)(((char *)(chk)) + SLAB_CHUNKHDRSZ))
+#define SlabBlockGetChunk(slab, block, idx) \
+ ((SlabChunk *) ((char *) (block) + sizeof(SlabBlock) \
+ + (idx * slab->fullChunkSize)))
+#define SlabBlockStart(block) \
+ ((char *) block + sizeof(SlabBlock))
+#define SlabChunkIndex(slab, block, chunk) \
+ (((char *) chunk - SlabBlockStart(block)) / slab->fullChunkSize)
+
+/*
+ * These functions implement the MemoryContext API for Slab contexts.
+ */
+static void *SlabAlloc(MemoryContext context, Size size);
+static void SlabFree(MemoryContext context, void *pointer);
+static void *SlabRealloc(MemoryContext context, void *pointer, Size size);
+static void SlabInit(MemoryContext context);
+static void SlabReset(MemoryContext context);
+static void SlabDelete(MemoryContext context);
+static Size SlabGetChunkSpace(MemoryContext context, void *pointer);
+static bool SlabIsEmpty(MemoryContext context);
+static void SlabStats(MemoryContext context, int level, bool print,
+ MemoryContextCounters *totals);
+#ifdef MEMORY_CONTEXT_CHECKING
+static void SlabCheck(MemoryContext context);
+#endif
+
+/*
+ * This is the virtual function table for Slab contexts.
+ */
+static MemoryContextMethods SlabMethods = {
+ SlabAlloc,
+ SlabFree,
+ SlabRealloc,
+ SlabInit,
+ SlabReset,
+ SlabDelete,
+ SlabGetChunkSpace,
+ SlabIsEmpty,
+ SlabStats
+#ifdef MEMORY_CONTEXT_CHECKING
+ ,SlabCheck
+#endif
+};
+
+/* ----------
+ * Debug macros
+ * ----------
+ */
+#ifdef HAVE_ALLOCINFO
+#define SlabFreeInfo(_cxt, _chunk) \
+ fprintf(stderr, "SlabFree: %s: %p, %zu\n", \
+ (_cxt)->header.name, (_chunk), (_chunk)->header.size)
+#define SlabAllocInfo(_cxt, _chunk) \
+ fprintf(stderr, "SlabAlloc: %s: %p, %zu\n", \
+ (_cxt)->header.name, (_chunk), (_chunk)->header.size)
+#else
+#define SlabFreeInfo(_cxt, _chunk)
+#define SlabAllocInfo(_cxt, _chunk)
+#endif
+
+
+/*
+ * SlabContextCreate
+ * Create a new Slab context.
+ *
+ * parent: parent context, or NULL if top-level context
+ * name: name of context (for debugging --- string will be copied)
+ * blockSize: allocation block size
+ * chunkSize: allocation chunk size
+ *
+ * The chunkSize may not exceed:
+ * MAXALIGN_DOWN(SIZE_MAX) - MAXALIGN(sizeof(SlabBlock)) - SLAB_CHUNKHDRSZ
+ *
+ */
+MemoryContext
+SlabContextCreate(MemoryContext parent,
+ const char *name,
+ Size blockSize,
+ Size chunkSize)
+{
+ int chunksPerBlock;
+ Size fullChunkSize;
+ Size freelistSize;
+ SlabContext *slab;
+
+ /* otherwise the linked list inside freed chunk isn't guaranteed to fit */
+ StaticAssertStmt(MAXIMUM_ALIGNOF >= sizeof(int),
+ "MAXALIGN too small to fit int32");
+
+ /* chunk, including SLAB header (both addresses nicely aligned) */
+ fullChunkSize = MAXALIGN(sizeof(SlabChunk) + MAXALIGN(chunkSize));
+
+ /* Make sure the block can store at least one chunk. */
+ if (blockSize - sizeof(SlabBlock) < fullChunkSize)
+ elog(ERROR, "block size %ld for slab is too small for %ld chunks",
+ blockSize, chunkSize);
+
+ /* Compute maximum number of chunks per block */
+ chunksPerBlock = (blockSize - sizeof(SlabBlock)) / fullChunkSize;
+
+ /* The freelist starts with 0, ends with chunksPerBlock. */
+ freelistSize = sizeof(dlist_head) * (chunksPerBlock + 1);
+
+ /* if we can't fit at least one chunk into the block, we're hosed */
+ Assert(chunksPerBlock > 0);
+
+ /* make sure the chunks actually fit on the block */
+ Assert((fullChunkSize * chunksPerBlock) + sizeof(SlabBlock) <= blockSize);
+
+ /* Do the type-independent part of context creation */
+ slab = (SlabContext *)
+ MemoryContextCreate(T_SlabContext,
+ (offsetof(SlabContext, freelist) +freelistSize),
+ &SlabMethods,
+ parent,
+ name);
+
+ slab->blockSize = blockSize;
+ slab->chunkSize = chunkSize;
+ slab->fullChunkSize = fullChunkSize;
+ slab->chunksPerBlock = chunksPerBlock;
+ slab->nblocks = 0;
+ slab->minFreeChunks = 0;
+
+ return (MemoryContext) slab;
+}
+
+/*
+ * SlabInit
+ * Context-type-specific initialization routine.
+ */
+static void
+SlabInit(MemoryContext context)
+{
+ int i;
+ SlabContext *slab = castNode(SlabContext, context);
+
+ Assert(slab);
+
+ /* initialize the freelist slots */
+ for (i = 0; i < (slab->chunksPerBlock + 1); i++)
+ dlist_init(&slab->freelist[i]);
+}
+
+/*
+ * SlabReset
+ * Frees all memory which is allocated in the given set.
+ *
+ * The code simply frees all the blocks in the context - we don't keep any
+ * keeper blocks or anything like that.
+ */
+static void
+SlabReset(MemoryContext context)
+{
+ int i;
+ SlabContext *slab = castNode(SlabContext, context);
+
+ Assert(slab);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+ /* Check for corruption and leaks before freeing */
+ SlabCheck(context);
+#endif
+
+ /* walk over freelists and free the blocks */
+ for (i = 0; i <= slab->chunksPerBlock; i++)
+ {
+ dlist_mutable_iter miter;
+
+ dlist_foreach_modify(miter, &slab->freelist[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);
+ slab->nblocks--;
+ }
+ }
+
+ slab->minFreeChunks = 0;
+
+ Assert(slab->nblocks == 0);
+}
+
+/*
+ * SlabDelete
+ * Frees all memory which is allocated in the given slab, in preparation
+ * for deletion of the slab. We simply call SlabReset().
+ */
+static void
+SlabDelete(MemoryContext context)
+{
+ /* just reset the context */
+ SlabReset(context);
+}
+
+/*
+ * SlabAlloc
+ * Returns pointer to allocated memory of given size or NULL if
+ * request could not be completed; memory is added to the slab.
+ */
+static void *
+SlabAlloc(MemoryContext context, Size size)
+{
+ SlabContext *slab = castNode(SlabContext, context);
+ SlabBlock *block;
+ SlabChunk *chunk;
+ int idx;
+
+ Assert(slab);
+
+ Assert((slab->minFreeChunks >= 0) &&
+ (slab->minFreeChunks < slab->chunksPerBlock));
+
+ /* make sure we only allow correct request size */
+ if (size != slab->chunkSize)
+ elog(ERROR, "unexpected alloc chunk size %ld (expected %ld)",
+ size, slab->chunkSize);
+
+ /*
+ * If there are no free chunks in any existing block, create a new block
+ * and put it to the last freelist bucket.
+ *
+ * slab->minFreeChunks == 0 means there are no blocks with free chunks,
+ * thanks to how minFreeChunks is updated at the end of SlabAlloc().
+ */
+ if (slab->minFreeChunks == 0)
+ {
+ block = (SlabBlock *) malloc(slab->blockSize);
+
+ if (block == NULL)
+ return NULL;
+
+ block->nfree = slab->chunksPerBlock;
+ block->firstFreeChunk = 0;
+
+ /*
+ * Put all the chunks on a freelist. Walk the chunks and point each
+ * one to the next one.
+ */
+ for (idx = 0; idx < slab->chunksPerBlock; idx++)
+ {
+ chunk = SlabBlockGetChunk(slab, block, idx);
+ *(int32 *) SlabChunkGetPointer(chunk) = (idx + 1);
+ }
+
+ /*
+ * And add it to the last freelist with all chunks empty.
+ *
+ * XXX We know there are no blocks in the freelist, otherwise we
+ * wouldn't need a new block.
+ */
+ Assert(dlist_is_empty(&slab->freelist[slab->chunksPerBlock]));
+
+ dlist_push_head(&slab->freelist[slab->chunksPerBlock], &block->node);
+
+ slab->minFreeChunks = slab->chunksPerBlock;
+ slab->nblocks += 1;
+ }
+
+ /* grab the block from the freelist (even the new block is there) */
+ block = dlist_head_element(SlabBlock, node,
+ &slab->freelist[slab->minFreeChunks]);
+
+ /* make sure we actually got a valid block, with matching nfree */
+ Assert(block != NULL);
+ Assert(slab->minFreeChunks == block->nfree);
+ Assert(block->nfree > 0);
+
+ /* we know index of the first free chunk in the block */
+ idx = block->firstFreeChunk;
+
+ /* make sure the chunk index is valid, and that it's marked as empty */
+ Assert((idx >= 0) && (idx < slab->chunksPerBlock));
+
+ /* compute the chunk location block start (after the block header) */
+ chunk = SlabBlockGetChunk(slab, block, idx);
+
+ /*
+ * Update the block nfree count, and also the minFreeChunks as we've
+ * decreased nfree for a block with the minimum number of free chunks
+ * (because that's how we chose the block).
+ */
+ block->nfree--;
+ slab->minFreeChunks = block->nfree;
+
+ /*
+ * Remove the chunk from the freelist head. The index of the next free
+ * chunk is stored in the chunk itself.
+ */
+ VALGRIND_MAKE_MEM_DEFINED(chunk, SlabChunkGetPointer(chunk));
+ block->firstFreeChunk = *(int32 *) SlabChunkGetPointer(chunk);
+
+ Assert(block->firstFreeChunk >= 0);
+ Assert(block->firstFreeChunk <= slab->chunksPerBlock);
+
+ Assert((block->nfree != 0 &&
+ block->firstFreeChunk < slab->chunksPerBlock) ||
+ (block->nfree == 0 &&
+ block->firstFreeChunk == slab->chunksPerBlock));
+
+ /* move the whole block to the right place in the freelist */
+ dlist_delete(&block->node);
+ dlist_push_head(&slab->freelist[block->nfree], &block->node);
+
+ /*
+ * And finally update minFreeChunks, i.e. the index to the block with the
+ * lowest number of free chunks. We only need to do that when the block
+ * got full (otherwise we know the current block is the right one). We'll
+ * simply walk the freelist until we find a non-empty entry.
+ */
+ if (slab->minFreeChunks == 0)
+ {
+ for (idx = 1; idx <= slab->chunksPerBlock; idx++)
+ {
+ if (dlist_is_empty(&slab->freelist[idx]))
+ continue;
+
+ /* found a non-empty freelist */
+ slab->minFreeChunks = idx;
+ break;
+ }
+ }
+
+ if (slab->minFreeChunks == slab->chunksPerBlock)
+ slab->minFreeChunks = 0;
+
+ /* Prepare to initialize the chunk header. */
+ VALGRIND_MAKE_MEM_UNDEFINED(chunk, SLAB_CHUNK_USED);
+
+ chunk->block = (void *) block;
+
+ chunk->header.context = (MemoryContext) slab;
+ chunk->header.size = MAXALIGN(size);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+ chunk->header.requested_size = size;
+ VALGRIND_MAKE_MEM_NOACCESS(&chunk->header.requested_size,
+ sizeof(chunk->header.requested_size));
+ /* slab mark to catch clobber of "unused" space */
+ if (size < chunk->header.size)
+ set_sentinel(SlabChunkGetPointer(chunk), size);
+#endif
+#ifdef RANDOMIZE_ALLOCATED_MEMORY
+ /* fill the allocated space with junk */
+ randomize_mem((char *) SlabChunkGetPointer(chunk), size);
+#endif
+
+ SlabAllocInfo(slab, chunk);
+ return SlabChunkGetPointer(chunk);
+}
+
+/*
+ * SlabFree
+ * Frees allocated memory; memory is removed from the slab.
+ */
+static void
+SlabFree(MemoryContext context, void *pointer)
+{
+ int idx;
+ SlabContext *slab = castNode(SlabContext, context);
+ SlabChunk *chunk = SlabPointerGetChunk(pointer);
+ SlabBlock *block = chunk->block;
+
+ SlabFreeInfo(slab, chunk);
+
+#ifdef MEMORY_CONTEXT_CHECKING
+ VALGRIND_MAKE_MEM_DEFINED(&chunk->header.requested_size,
+ sizeof(chunk->header.requested_size));
+ /* Test for someone scribbling on unused space in chunk */
+ if (chunk->header.requested_size < chunk->header.size)
+ if (!sentinel_ok(pointer, chunk->header.requested_size))
+ elog(WARNING, "detected write past chunk end in %s %p",
+ slab->header.name, chunk);
+#endif
+
+ /* compute index of the chunk with respect to block start */
+ idx = SlabChunkIndex(slab, block, chunk);
+
+ /* add chunk to freelist, and update block nfree count */
+ *(int32 *) pointer = block->firstFreeChunk;
+ block->firstFreeChunk = idx;
+ block->nfree++;
+
+ Assert(block->nfree > 0);
+ Assert(block->nfree <= slab->chunksPerBlock);
+
+#ifdef CLOBBER_FREED_MEMORY
+ /* XXX don't wipe the int32 index, used for block-level freelist */
+ wipe_mem((char *) pointer + sizeof(int32),
+ chunk->header.size - sizeof(int32));
+#endif
+
+#ifdef MEMORY_CONTEXT_CHECKING
+ /* Reset requested_size to 0 in chunks that are on freelist */
+ chunk->header.requested_size = 0;
+#endif
+
+ /* remove the block from a freelist */
+ dlist_delete(&block->node);
+
+ /*
+ * See if we need to update the minFreeChunks field for the slab - we only
+ * need to do that if there the block had that number of free chunks
+ * before we freed one. In that case, we check if there still are blocks
+ * in the original freelist and we either keep the current value (if there
+ * still are blocks) or increment it by one (the new block is still the
+ * one with minimum free chunks).
+ *
+ * The one exception is when the block will get completely free - in that
+ * case we will free it, se we can't use it for minFreeChunks. It however
+ * means there are no more blocks with free chunks.
+ */
+ if (slab->minFreeChunks == (block->nfree - 1))
+ {
+ /* Have we removed the last chunk from the freelist? */
+ if (dlist_is_empty(&slab->freelist[slab->minFreeChunks]))
+ {
+ /* but if we made the block entirely free, we'll free it */
+ if (block->nfree == slab->chunksPerBlock)
+ slab->minFreeChunks = 0;
+ else
+ slab->minFreeChunks++;
+ }
+ }
+
+ /* If the block is now completely empty, free it. */
+ if (block->nfree == slab->chunksPerBlock)
+ {
+ free(block);
+ slab->nblocks--;
+ }
+ else
+ dlist_push_head(&slab->freelist[block->nfree], &block->node);
+
+ Assert(slab->nblocks >= 0);
+}
+
+/*
+ * SlabRealloc
+ * As Slab is designed for allocating equally-sized chunks of memory, it
+ * can't really do an actual realloc.
+ *
+ * We try to be gentle and allow calls with exactly the same size as in that
+ * case we can simply return the same chunk. When the size differs, we fail
+ * with assert failure or return NULL.
+ *
+ * We might be even support cases with (size < chunkSize). That however seems
+ * rather pointless - Slab is meant for chunks of constant size, and moreover
+ * realloc is usually used to enlarge the chunk.
+ */
+static void *
+SlabRealloc(MemoryContext context, void *pointer, Size size)
+{
+ SlabContext *slab = castNode(SlabContext, context);
+
+ Assert(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()");
+}
+
+/*
+ * SlabGetChunkSpace
+ * Given a currently-allocated chunk, determine the total space
+ * it occupies (including all memory-allocation overhead).
+ */
+static Size
+SlabGetChunkSpace(MemoryContext context, void *pointer)
+{
+ SlabChunk *chunk = SlabPointerGetChunk(pointer);
+
+ return chunk->header.size + SLAB_CHUNKHDRSZ;
+}
+
+/*
+ * SlabIsEmpty
+ * Is an Slab empty of any allocated space?
+ */
+static bool
+SlabIsEmpty(MemoryContext context)
+{
+ SlabContext *slab = castNode(SlabContext, context);
+
+ Assert(slab);
+
+ return (slab->nblocks == 0);
+}
+
+/*
+ * SlabStats
+ * Compute stats about memory consumption of an Slab.
+ *
+ * level: recursion level (0 at top level); used for print indentation.
+ * print: true to print stats to stderr.
+ * totals: if not NULL, add stats about this Slab into *totals.
+ */
+static void
+SlabStats(MemoryContext context, int level, bool print,
+ MemoryContextCounters *totals)
+{
+ SlabContext *slab = castNode(SlabContext, context);
+ Size nblocks = 0;
+ Size freechunks = 0;
+ Size totalspace = 0;
+ Size freespace = 0;
+ int i;
+
+ Assert(slab);
+
+ for (i = 0; i <= slab->chunksPerBlock; i++)
+ {
+ dlist_iter iter;
+
+ dlist_foreach(iter, &slab->freelist[i])
+ {
+ SlabBlock *block = dlist_container(SlabBlock, node, iter.cur);
+
+ nblocks++;
+ totalspace += slab->blockSize;
+ freespace += slab->fullChunkSize * block->nfree;
+ freechunks += block->nfree;
+ }
+ }
+
+ if (print)
+ {
+ for (i = 0; i < level; i++)
+ fprintf(stderr, " ");
+ fprintf(stderr,
+ "Slab: %s: %zu total in %zd blocks; %zu free (%zd chunks); %zu used\n",
+ slab->header.name, totalspace, nblocks, freespace, freechunks,
+ totalspace - freespace);
+ }
+
+ if (totals)
+ {
+ totals->nblocks += nblocks;
+ totals->freechunks += freechunks;
+ totals->totalspace += totalspace;
+ totals->freespace += freespace;
+ }
+}
+
+
+#ifdef MEMORY_CONTEXT_CHECKING
+
+/*
+ * SlabCheck
+ * Walk through chunks and check consistency of memory.
+ *
+ * NOTE: report errors as WARNING, *not* ERROR or FATAL. Otherwise you'll
+ * find yourself in an infinite loop when trouble occurs, because this
+ * routine will be entered again when elog cleanup tries to release memory!
+ */
+static void
+SlabCheck(MemoryContext context)
+{
+ int i;
+ SlabContext *slab = castNode(SlabContext, context);
+ char *name = slab->header.name;
+ char *freechunks;
+
+ Assert(slab);
+ Assert(slab->chunksPerBlock > 0);
+
+ /* bitmap of free chunks on a block */
+ freechunks = palloc(slab->chunksPerBlock * sizeof(bool));
+
+ /* walk all the freelists */
+ for (i = 0; i <= slab->chunksPerBlock; i++)
+ {
+ int j,
+ nfree;
+ dlist_iter iter;
+
+ /* walk all blocks on this freelist */
+ dlist_foreach(iter, &slab->freelist[i])
+ {
+ int idx;
+ SlabBlock *block = dlist_container(SlabBlock, node, iter.cur);
+
+ /*
+ * Make sure the number of free chunks (in the block header)
+ * matches position in the freelist.
+ */
+ if (block->nfree != i)
+ elog(WARNING, "problem in slab %s: number of free chunks %d in block %p does not match freelist %d",
+ name, block->nfree, block, i);
+
+ /* reset the bitmap of free chunks for this block */
+ memset(freechunks, 0, (slab->chunksPerBlock * sizeof(bool)));
+ idx = block->firstFreeChunk;
+
+ /*
+ * Now walk through the chunks, count the free ones and also
+ * perform some additional checks for the used ones. As the chunk
+ * freelist is stored within the chunks themselves, we have to
+ * walk through the chunks and construct our own bitmap.
+ */
+
+ nfree = 0;
+ while (idx < slab->chunksPerBlock)
+ {
+ SlabChunk *chunk;
+
+ /* count the chunk as free, add it to the bitmap */
+ nfree++;
+ freechunks[idx] = true;
+
+ /* read index of the next free chunk */
+ chunk = SlabBlockGetChunk(slab, block, idx);
+ idx = *(int32 *) SlabChunkGetPointer(chunk);
+ }
+
+ for (j = 0; j < slab->chunksPerBlock; j++)
+ {
+ /* non-zero bit in the bitmap means chunk the chunk is used */
+ if (!freechunks[j])
+ {
+ SlabChunk *chunk = SlabBlockGetChunk(slab, block, j);
+
+ VALGRIND_MAKE_MEM_DEFINED(&chunk->header.requested_size,
+ sizeof(chunk->header.requested_size));
+
+ /* we're in a no-freelist branch */
+ VALGRIND_MAKE_MEM_NOACCESS(&chunk->header.requested_size,
+ sizeof(chunk->header.requested_size));
+
+ /* chunks have both block and slab pointers, so check both */
+ if (chunk->block != block)
+ elog(WARNING, "problem in slab %s: bogus block link in block %p, chunk %p",
+ name, block, chunk);
+
+ if (chunk->header.context != (MemoryContext) slab)
+ elog(WARNING, "problem in slab %s: bogus slab link in block %p, chunk %p",
+ name, block, chunk);
+
+ /* now make sure the chunk size is correct */
+ if (chunk->header.size != MAXALIGN(slab->chunkSize))
+ elog(WARNING, "problem in slab %s: bogus chunk size in block %p, chunk %p",
+ name, block, chunk);
+
+ /* now make sure the chunk size is correct */
+ if (chunk->header.requested_size != slab->chunkSize)
+ elog(WARNING, "problem in slab %s: bogus chunk requested size in block %p, chunk %p",
+ name, block, chunk);
+
+ /* there might be sentinel (thanks to alignment) */
+ if (chunk->header.requested_size < chunk->header.size &&
+ !sentinel_ok(chunk, SLAB_CHUNKHDRSZ + chunk->header.requested_size))
+ elog(WARNING, "problem in slab %s: detected write past chunk end in block %p, chunk %p",
+ name, block, chunk);
+ }
+ }
+
+ /*
+ * Make sure we got the expected number of free chunks (as tracked
+ * in the block header).
+ */
+ if (nfree != block->nfree)
+ elog(WARNING, "problem in slab %s: number of free chunks %d in block %p does not match bitmap %d",
+ name, block->nfree, block, nfree);
+ }
+ }
+}
+
+#endif /* MEMORY_CONTEXT_CHECKING */
diff --git a/src/include/nodes/memnodes.h b/src/include/nodes/memnodes.h
index e487d172fc..fe6bc903b3 100644
--- a/src/include/nodes/memnodes.h
+++ b/src/include/nodes/memnodes.h
@@ -96,6 +96,6 @@ typedef struct MemoryContextData
*/
#define MemoryContextIsValid(context) \
((context) != NULL && \
- (IsA((context), AllocSetContext)))
+ (IsA((context), AllocSetContext) || IsA((context), SlabContext)))
#endif /* MEMNODES_H */
diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
index 95dd8baadd..28aca928a8 100644
--- a/src/include/nodes/nodes.h
+++ b/src/include/nodes/nodes.h
@@ -278,6 +278,7 @@ typedef enum NodeTag
*/
T_MemoryContext,
T_AllocSetContext,
+ T_SlabContext,
/*
* TAGS FOR VALUE NODES (value.h)
diff --git a/src/include/utils/memutils.h b/src/include/utils/memutils.h
index 1d1035e374..5223a4da39 100644
--- a/src/include/utils/memutils.h
+++ b/src/include/utils/memutils.h
@@ -135,6 +135,12 @@ extern MemoryContext AllocSetContextCreate(MemoryContext parent,
Size initBlockSize,
Size maxBlockSize);
+/* slab.c */
+extern MemoryContext SlabContextCreate(MemoryContext parent,
+ const char *name,
+ Size blockSize,
+ Size chunkSize);
+
/*
* Recommended default alloc parameters, suitable for "ordinary" contexts
* that might hold quite a lot of data.
@@ -171,4 +177,7 @@ extern MemoryContext AllocSetContextCreate(MemoryContext parent,
*/
#define ALLOCSET_SEPARATE_THRESHOLD 8192
+#define SLAB_DEFAULT_BLOCK_SIZE (8 * 1024)
+#define SLAB_LARGE_BLOCK_SIZE (8 * 1024 * 1024)
+
#endif /* MEMUTILS_H */
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 9f876ae264..1fd7ec4256 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1941,6 +1941,9 @@ SimpleStringList
SimpleStringListCell
SingleBoundSortItem
Size
+SlabBlock
+SlabContext
+SlabChunk
SlabSlot
SlotNumber
SlruCtl
--
2.11.0.22.g8d7a455.dirty
>From 2e10d6e62ba4756042fef96e411efb33128e67e1 Mon Sep 17 00:00:00 2001
From: Andres Freund <and...@anarazel.de>
Date: Fri, 24 Feb 2017 14:02:59 -0800
Subject: [PATCH 3/3] Use the new Slab context for some allocations in
reorderbuffer.h.
Author: Tomas Vondra
Discussion: https://postgr.es/m/d15dff83-0b37-28ed-0809-95a5cc729...@2ndquadrant.com
---
src/backend/replication/logical/reorderbuffer.c | 74 ++++++-------------------
src/include/replication/reorderbuffer.h | 14 ++---
2 files changed, 22 insertions(+), 66 deletions(-)
diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c
index 7dc97fa796..8aac670bd4 100644
--- a/src/backend/replication/logical/reorderbuffer.c
+++ b/src/backend/replication/logical/reorderbuffer.c
@@ -156,10 +156,7 @@ static const Size max_changes_in_memory = 4096;
* major bottleneck, especially when spilling to disk while decoding batch
* workloads.
*/
-static const Size max_cached_changes = 4096 * 2;
static const Size max_cached_tuplebufs = 4096 * 2; /* ~8MB */
-static const Size max_cached_transactions = 512;
-
/* ---------------------------------------
* primary reorderbuffer support routines
@@ -241,6 +238,16 @@ ReorderBufferAllocate(void)
buffer->context = new_ctx;
+ buffer->change_context = SlabContextCreate(new_ctx,
+ "Change",
+ SLAB_DEFAULT_BLOCK_SIZE,
+ sizeof(ReorderBufferChange));
+
+ buffer->txn_context = SlabContextCreate(new_ctx,
+ "TXN",
+ SLAB_DEFAULT_BLOCK_SIZE,
+ sizeof(ReorderBufferTXN));
+
hash_ctl.keysize = sizeof(TransactionId);
hash_ctl.entrysize = sizeof(ReorderBufferTXNByIdEnt);
hash_ctl.hcxt = buffer->context;
@@ -251,8 +258,6 @@ ReorderBufferAllocate(void)
buffer->by_txn_last_xid = InvalidTransactionId;
buffer->by_txn_last_txn = NULL;
- buffer->nr_cached_transactions = 0;
- buffer->nr_cached_changes = 0;
buffer->nr_cached_tuplebufs = 0;
buffer->outbuf = NULL;
@@ -261,8 +266,6 @@ ReorderBufferAllocate(void)
buffer->current_restart_decoding_lsn = InvalidXLogRecPtr;
dlist_init(&buffer->toplevel_by_lsn);
- dlist_init(&buffer->cached_transactions);
- dlist_init(&buffer->cached_changes);
slist_init(&buffer->cached_tuplebufs);
return buffer;
@@ -291,19 +294,8 @@ ReorderBufferGetTXN(ReorderBuffer *rb)
{
ReorderBufferTXN *txn;
- /* check the slab cache */
- if (rb->nr_cached_transactions > 0)
- {
- rb->nr_cached_transactions--;
- txn = (ReorderBufferTXN *)
- dlist_container(ReorderBufferTXN, node,
- dlist_pop_head_node(&rb->cached_transactions));
- }
- else
- {
- txn = (ReorderBufferTXN *)
- MemoryContextAlloc(rb->context, sizeof(ReorderBufferTXN));
- }
+ txn = (ReorderBufferTXN *)
+ MemoryContextAlloc(rb->txn_context, sizeof(ReorderBufferTXN));
memset(txn, 0, sizeof(ReorderBufferTXN));
@@ -344,18 +336,7 @@ ReorderBufferReturnTXN(ReorderBuffer *rb, ReorderBufferTXN *txn)
txn->invalidations = NULL;
}
- /* check whether to put into the slab cache */
- if (rb->nr_cached_transactions < max_cached_transactions)
- {
- rb->nr_cached_transactions++;
- dlist_push_head(&rb->cached_transactions, &txn->node);
- VALGRIND_MAKE_MEM_UNDEFINED(txn, sizeof(ReorderBufferTXN));
- VALGRIND_MAKE_MEM_DEFINED(&txn->node, sizeof(txn->node));
- }
- else
- {
- pfree(txn);
- }
+ pfree(txn);
}
/*
@@ -366,19 +347,8 @@ ReorderBufferGetChange(ReorderBuffer *rb)
{
ReorderBufferChange *change;
- /* check the slab cache */
- if (rb->nr_cached_changes)
- {
- rb->nr_cached_changes--;
- change = (ReorderBufferChange *)
- dlist_container(ReorderBufferChange, node,
- dlist_pop_head_node(&rb->cached_changes));
- }
- else
- {
- change = (ReorderBufferChange *)
- MemoryContextAlloc(rb->context, sizeof(ReorderBufferChange));
- }
+ change = (ReorderBufferChange *)
+ MemoryContextAlloc(rb->change_context, sizeof(ReorderBufferChange));
memset(change, 0, sizeof(ReorderBufferChange));
return change;
@@ -434,21 +404,9 @@ ReorderBufferReturnChange(ReorderBuffer *rb, ReorderBufferChange *change)
break;
}
- /* check whether to put into the slab cache */
- if (rb->nr_cached_changes < max_cached_changes)
- {
- rb->nr_cached_changes++;
- dlist_push_head(&rb->cached_changes, &change->node);
- VALGRIND_MAKE_MEM_UNDEFINED(change, sizeof(ReorderBufferChange));
- VALGRIND_MAKE_MEM_DEFINED(&change->node, sizeof(change->node));
- }
- else
- {
- pfree(change);
- }
+ pfree(change);
}
-
/*
* Get an unused, possibly preallocated, ReorderBufferTupleBuf fitting at
* least a tuple of size tuple_len (excluding header overhead).
diff --git a/src/include/replication/reorderbuffer.h b/src/include/replication/reorderbuffer.h
index 25b0fc8c0a..17e47b385b 100644
--- a/src/include/replication/reorderbuffer.h
+++ b/src/include/replication/reorderbuffer.h
@@ -331,6 +331,12 @@ struct ReorderBuffer
MemoryContext context;
/*
+ * Memory contexts for specific types objects
+ */
+ MemoryContext change_context;
+ MemoryContext txn_context;
+
+ /*
* Data structure slab cache.
*
* We allocate/deallocate some structures very frequently, to avoid bigger
@@ -340,14 +346,6 @@ struct ReorderBuffer
* on top of reorderbuffer.c
*/
- /* cached ReorderBufferTXNs */
- dlist_head cached_transactions;
- Size nr_cached_transactions;
-
- /* cached ReorderBufferChanges */
- dlist_head cached_changes;
- Size nr_cached_changes;
-
/* cached ReorderBufferTupleBufs */
slist_head cached_tuplebufs;
Size nr_cached_tuplebufs;
--
2.11.0.22.g8d7a455.dirty
--
Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-hackers
