EXPERIMENT: instrument current 3-patch bcs (ticks/victim + eviction counter)

Author: gburd

src/backend/storage/buffer/bufmgr.c

@@ -2326,6 +2326,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 	Assert(BUF_STATE_GET_REFCOUNT(victim_buf_state) == 1);
 	Assert(!(victim_buf_state & (BM_TAG_VALID | BM_VALID | BM_DIRTY | BM_IO_IN_PROGRESS)));
 
+	if (BufTagGetForkNum(&newTag) == MAIN_FORKNUM)
+		BcsGhostProbeRead(newHash);
 	victim_buf_hdr->tag = newTag;
 
 	/*
@@ -2663,6 +2665,13 @@ GetVictimBuffer(BufferAccessStrategy strategy, IOContext io_context)
 		 */
 		pgstat_count_io_op(IOOBJECT_RELATION, io_context,
 						   from_ring ? IOOP_REUSE : IOOP_EVICT, 1, 0);
+
+		/* EXPERIMENT: record real evictions of MAIN_FORKNUM by relfilenumber */
+		if (!from_ring && BufTagGetForkNum(&buf_hdr->tag) == MAIN_FORKNUM)
+		{
+			BcsRecordEviction(BufTagGetRelNumber(&buf_hdr->tag));
+			BcsGhostRecordEviction(BufTableHashCode(&buf_hdr->tag), (BUF_STATE_GET_COOLSTATE(buf_state) == BUF_COOLSTATE_COOL));
+		}
 	}
 
 	/*

src/backend/storage/buffer/freelist.c

@@ -15,6 +15,11 @@
  */
 #include "postgres.h"
 
+#include "funcapi.h"
+#include "utils/tuplestore.h"
+#include "access/relation.h"
+#include "common/pg_prng.h"
+#include "utils/rel.h"
 #include "pgstat.h"
 #include "port/atomics.h"
 #include "storage/buf_internals.h"
@@ -64,6 +69,25 @@ typedef struct
 	 * StrategyNotifyBgWriter.
 	 */
 	int			bgwprocno;
+
+	/*
+	 * EXPERIMENT INSTRUMENT (throwaway, never posted): clock-sweep work
+	 * counters + per-relation eviction counts.  sweepTicks/sweepVictims give
+	 * ticks-per-victim (the 0..5-grind metric); evictRel/evictCnt classify the
+	 * eviction stream by relation offline.  Exposed via bcs_sweepstats() and
+	 * bcs_evictions().
+	 */
+#define BCS_EVICT_SLOTS 8192
+	pg_atomic_uint64 sweepTicks;
+	pg_atomic_uint64 sweepVictims;
+	pg_atomic_uint64 evictRel[BCS_EVICT_SLOTS];
+	pg_atomic_uint64 evictCnt[BCS_EVICT_SLOTS];
+	/* ghost observer (measurement only) */
+#define BCS_GHOST_SLOTS (1<<20)
+	pg_atomic_uint64 ghostReads;
+	pg_atomic_uint64 ghostReloads;
+	pg_atomic_uint64 ghostReloadsCold;
+	pg_atomic_uint32 ghostTag[BCS_GHOST_SLOTS];	/* low 31 bits of taghash, bit31=cold */
 } BufferStrategyControl;
 
 /* Pointers to shared state */
@@ -204,6 +228,8 @@ ClockSweepTick(void)
 	victim = MyBatchPos % NBuffers;
 	MyBatchPos++;
 
+	pg_atomic_fetch_add_u64(&StrategyControl->sweepTicks, 1);	/* EXPERIMENT */
+
 	return victim;
 }
 
@@ -366,6 +392,8 @@ StrategyGetBuffer(BufferAccessStrategy strategy, uint64 *buf_state, bool *from_r
 						AddBufferToRing(strategy, buf);
 					*buf_state = local_buf_state;
 
+					pg_atomic_fetch_add_u64(&StrategyControl->sweepVictims, 1);	/* EXPERIMENT */
+
 					TrackNewBufferPin(BufferDescriptorGetBuffer(buf));
 
 					return buf;
@@ -477,6 +505,15 @@ StrategyCtlShmemInit(void *arg)
 	/* No pending notification */
 	StrategyControl->bgwprocno = -1;
 
+	/* EXPERIMENT: instrument counters */
+	pg_atomic_init_u64(&StrategyControl->sweepTicks, 0);
+	pg_atomic_init_u64(&StrategyControl->sweepVictims, 0);
+	for (int i = 0; i < BCS_EVICT_SLOTS; i++)
+	{
+		pg_atomic_init_u64(&StrategyControl->evictRel[i], 0);
+		pg_atomic_init_u64(&StrategyControl->evictCnt[i], 0);
+	}
+
 	/*
 	 * Decide whether to batch the clock sweep.
 	 *
@@ -499,6 +536,17 @@ StrategyCtlShmemInit(void *arg)
 										 (uint32) NBuffers);
 	else
 		StrategyControl->batchSize = 1;
+
+	/*
+	 * EXPERIMENT (throwaway): allow forcing the batch size via env, so a
+	 * single binary can be run at batch 1 / 16 / 64 to isolate the NUMA
+	 * batching effect.  Not part of the proposed patch.
+	 */
+	{
+		const char *ov = getenv("BCS_BATCH_OVERRIDE");
+		if (ov != NULL && atoi(ov) >= 1)
+			StrategyControl->batchSize = Min((uint32) atoi(ov), (uint32) NBuffers);
+	}
 }
 
 
@@ -862,3 +910,143 @@ StrategyRejectBuffer(BufferAccessStrategy strategy, BufferDesc *buf, bool from_r
 
 	return true;
 }
+
+/* EXPERIMENT INSTRUMENT (throwaway, never posted). */
+void
+BcsRecordEviction(RelFileNumber relNumber)
+{
+	uint32		h = ((uint32) relNumber) % BCS_EVICT_SLOTS;
+
+	for (int probe = 0; probe < 64; probe++)
+	{
+		uint32		i = (h + probe) % BCS_EVICT_SLOTS;
+		uint64		cur = pg_atomic_read_u64(&StrategyControl->evictRel[i]);
+
+		if (cur == (uint64) relNumber)
+		{ pg_atomic_fetch_add_u64(&StrategyControl->evictCnt[i], 1); return; }
+		if (cur == 0)
+		{
+			uint64 expected = 0;
+			if (pg_atomic_compare_exchange_u64(&StrategyControl->evictRel[i], &expected, (uint64) relNumber)
+				|| pg_atomic_read_u64(&StrategyControl->evictRel[i]) == (uint64) relNumber)
+			{ pg_atomic_fetch_add_u64(&StrategyControl->evictCnt[i], 1); return; }
+		}
+	}
+	pg_atomic_fetch_add_u64(&StrategyControl->evictCnt[0], 1);
+}
+
+PG_FUNCTION_INFO_V1(bcs_sweepstats);
+Datum
+bcs_sweepstats(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+	Datum		values[2];
+	bool		nulls[2] = {false, false};
+
+	InitMaterializedSRF(fcinfo, 0);
+	values[0] = Int64GetDatum((int64) pg_atomic_read_u64(&StrategyControl->sweepTicks));
+	values[1] = Int64GetDatum((int64) pg_atomic_read_u64(&StrategyControl->sweepVictims));
+	tuplestore_putvalues(rsi->setResult, rsi->setDesc, values, nulls);
+	return (Datum) 0;
+}
+
+PG_FUNCTION_INFO_V1(bcs_evictions);
+Datum
+bcs_evictions(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+
+	InitMaterializedSRF(fcinfo, 0);
+	for (int i = 0; i < BCS_EVICT_SLOTS; i++)
+	{
+		uint64	rel = pg_atomic_read_u64(&StrategyControl->evictRel[i]);
+		uint64	cnt = pg_atomic_read_u64(&StrategyControl->evictCnt[i]);
+		Datum	values[2];
+		bool	nulls[2] = {false, false};
+
+		if (cnt == 0) continue;
+		values[0] = Int64GetDatum((int64) rel);
+		values[1] = Int64GetDatum((int64) cnt);
+		tuplestore_putvalues(rsi->setResult, rsi->setDesc, values, nulls);
+	}
+	return (Datum) 0;
+}
+
+/*
+ * EXPERIMENT INSTRUMENT (throwaway, never posted).
+ * bcs_thrash(rel, n): pin+release n random MAIN_FORKNUM blocks of rel with the
+ * normal (global-sweep) strategy, forcing n buffer allocations with almost no
+ * other work -- so StrategyGetBuffer / nextVictimBuffer dominates the cost.
+ * Isolates the clock-sweep mechanism from executor/protocol overhead.
+ */
+PG_FUNCTION_INFO_V1(bcs_thrash);
+Datum
+bcs_thrash(PG_FUNCTION_ARGS)
+{
+	Oid			relid = PG_GETARG_OID(0);
+	int64		n = PG_GETARG_INT64(1);
+	Relation	rel = relation_open(relid, AccessShareLock);
+	BlockNumber nblocks = RelationGetNumberOfBlocks(rel);
+	uint64		sum = 0;
+	pg_prng_state prng;
+
+	pg_prng_seed(&prng, (uint64) MyProcPid ^ (uint64) n);
+	for (int64 i = 0; i < n && nblocks > 0; i++)
+	{
+		BlockNumber blk = (BlockNumber) (pg_prng_uint64(&prng) % nblocks);
+		Buffer		buf = ReadBufferExtended(rel, MAIN_FORKNUM, blk,
+											 RBM_NORMAL, NULL);
+
+		sum += blk;
+		ReleaseBuffer(buf);
+		CHECK_FOR_INTERRUPTS();
+	}
+	relation_close(rel, AccessShareLock);
+	PG_RETURN_INT64((int64) sum);
+}
+
+
+/* ---- ghost observer (measurement only, never posted) ---- */
+/* Record that a block (identified by its buffer tag hash) was evicted, and
+ * whether it was cold at eviction. Stores low 31 bits of hash + cold bit. */
+void
+BcsGhostRecordEviction(uint32 taghash, bool cold)
+{
+	uint32 slot = taghash & (BCS_GHOST_SLOTS - 1);
+	uint32 val = (taghash & 0x7fffffff) | (cold ? 0x80000000u : 0);
+	pg_atomic_write_u32(&StrategyControl->ghostTag[slot], val);
+}
+
+/* On a real read/alloc of a block, probe the ghost table: was this exact block
+ * recently evicted? If so it's a reload; note if it was cold when evicted. */
+void
+BcsGhostProbeRead(uint32 taghash)
+{
+	uint32 slot = taghash & (BCS_GHOST_SLOTS - 1);
+	uint32 val = pg_atomic_read_u32(&StrategyControl->ghostTag[slot]);
+	pg_atomic_fetch_add_u64(&StrategyControl->ghostReads, 1);
+	if ((val & 0x7fffffff) == (taghash & 0x7fffffff) && val != 0)
+	{
+		pg_atomic_fetch_add_u64(&StrategyControl->ghostReloads, 1);
+		if (val & 0x80000000u)
+			pg_atomic_fetch_add_u64(&StrategyControl->ghostReloadsCold, 1);
+		/* clear so we don't double-count the same resurrection */
+		pg_atomic_write_u32(&StrategyControl->ghostTag[slot], 0);
+	}
+}
+
+PG_FUNCTION_INFO_V1(bcs_ghost);
+Datum
+bcs_ghost(PG_FUNCTION_ARGS)
+{
+	ReturnSetInfo *rsi = (ReturnSetInfo *) fcinfo->resultinfo;
+	Datum v[3];
+	bool n[3] = {false, false, false};
+
+	InitMaterializedSRF(fcinfo, 0);
+	v[0] = Int64GetDatum((int64) pg_atomic_read_u64(&StrategyControl->ghostReads));
+	v[1] = Int64GetDatum((int64) pg_atomic_read_u64(&StrategyControl->ghostReloads));
+	v[2] = Int64GetDatum((int64) pg_atomic_read_u64(&StrategyControl->ghostReloadsCold));
+	tuplestore_putvalues(rsi->setResult, rsi->setDesc, v, n);
+	return (Datum) 0;
+}

src/include/catalog/pg_proc.dat

@@ -12715,4 +12715,25 @@
   proname => 'hashoid8extended', prorettype => 'int8',
   proargtypes => 'oid8 int8', prosrc => 'hashoid8extended' },
 
+# EXPERIMENT INSTRUMENT (throwaway, never posted)
+{ oid => '8902', descr => 'bcs experiment: clock-sweep ticks and victims',
+  proname => 'bcs_sweepstats', prorows => '1', proretset => 't',
+  provolatile => 'v', proparallel => 'r', prorettype => 'record',
+  proargtypes => '', proallargtypes => '{int8,int8}', proargmodes => '{o,o}',
+  proargnames => '{ticks,victims}', prosrc => 'bcs_sweepstats' },
+{ oid => '8901', descr => 'bcs experiment: per-relation eviction counts',
+  proname => 'bcs_evictions', prorows => '1000', proretset => 't',
+  provolatile => 'v', proparallel => 'r', prorettype => 'record',
+  proargtypes => '', proallargtypes => '{int8,int8}', proargmodes => '{o,o}',
+  proargnames => '{relfilenode,evictions}', prosrc => 'bcs_evictions' },
+
+{ oid => '8903', descr => 'bcs experiment: thrash n random blocks (sweep isolation)',
+  proname => 'bcs_thrash', provolatile => 'v', proparallel => 'u',
+  prorettype => 'int8', proargtypes => 'regclass int8', prosrc => 'bcs_thrash' },
+
+{ oid => '8905', descr => 'bcs exp: ghost observer',
+  proname => 'bcs_ghost', prorows => '1', proretset => 't', provolatile => 'v',
+  proparallel => 'r', prorettype => 'record', proargtypes => '',
+  proallargtypes => '{int8,int8,int8}', proargmodes => '{o,o,o}',
+  proargnames => '{reads,reloads,reloads_cold}', prosrc => 'bcs_ghost' },
 ]

src/include/storage/buf_internals.h

@@ -638,6 +638,9 @@ extern BufferDesc *StrategyGetBuffer(BufferAccessStrategy strategy,
 extern bool StrategyRejectBuffer(BufferAccessStrategy strategy,
 								 BufferDesc *buf, bool from_ring);
 
+extern void BcsRecordEviction(RelFileNumber relNumber);
+extern void BcsGhostRecordEviction(uint32 taghash, bool cold);
+extern void BcsGhostProbeRead(uint32 taghash);
 extern int	StrategySyncStart(uint32 *complete_passes, uint32 *num_buf_alloc);
 extern void StrategyNotifyBgWriter(int bgwprocno);