Resolve issue#5: store update_lsn of each block into two independent slots.

Previously we thought that 1 MB can track changes page-to-page in the 1 GB of
data files. However, recently it became evident that our ptrack map or basic
hash table behaves more like a Bloom filter with a number of hash functions k = 1.
See more here: https://en.wikipedia.org/wiki/Bloom_filter#Probability_of_false_positives.
Such filter has naturally more collisions.

By storing update_lsn of each block in the additional slot we perform as
a Bloom filter with k = 2, which significatly reduces collision rate.

Author: ololobus

engine.c

@@ -156,6 +156,8 @@ ptrackMapInit(void)
 	sprintf(ptrack_path, "%s/%s", DataDir, PTRACK_PATH);
 	sprintf(ptrack_mmap_path, "%s/%s", DataDir, PTRACK_MMAP_PATH);
 
+ptrack_map_reinit:
+
 	/* Remove old PTRACK_MMAP_PATH file, if exists */
 	if (ptrack_file_exists(ptrack_mmap_path))
 		durable_unlink(ptrack_mmap_path, LOG);
@@ -175,18 +177,15 @@ ptrackMapInit(void)
 	if (stat(ptrack_path, &stat_buf) == 0)
 	{
 		copy_file(ptrack_path, ptrack_mmap_path);
-		is_new_map = false;		/* flag to check checksum */
+		is_new_map = false;		/* flag to check map file format and checksum */
 		ptrack_fd = BasicOpenFile(ptrack_mmap_path, O_RDWR | PG_BINARY);
-		if (ptrack_fd < 0)
-			elog(ERROR, "ptrack init: failed to open map file \"%s\": %m", ptrack_mmap_path);
 	}
 	else
-	{
 		/* Create new file for PTRACK_MMAP_PATH */
 		ptrack_fd = BasicOpenFile(ptrack_mmap_path, O_RDWR | O_CREAT | PG_BINARY);
-		if (ptrack_fd < 0)
-			elog(ERROR, "ptrack init: failed to open map file \"%s\": %m", ptrack_mmap_path);
-	}
+
+	if (ptrack_fd < 0)
+		elog(ERROR, "ptrack init: failed to open map file \"%s\": %m", ptrack_mmap_path);
 
 #ifdef WIN32
 	{
@@ -227,7 +226,19 @@ ptrackMapInit(void)
 			elog(ERROR, "ptrack init: wrong map format of file \"%s\"", ptrack_path);
 
 		/* Check ptrack version inside old ptrack map */
-		/* No-op for now, but may be used for future compatibility checks */
+		if (ptrack_map->version_num != PTRACK_VERSION_NUM)
+		{
+			ereport(WARNING,
+					(errcode(ERRCODE_DATA_CORRUPTED),
+					 errmsg("ptrack init: map format version %d in the file \"%s\" is incompatible with loaded version %d",
+							ptrack_map->version_num, ptrack_path, PTRACK_VERSION_NUM),
+					 errdetail("Deleting file \"%s\" and reinitializing ptrack map.", ptrack_path)));
+
+			/* Delete and try again */
+			durable_unlink(ptrack_path, LOG);
+			is_new_map = true;
+			goto ptrack_map_reinit;
+		}
 
 		/* Check CRC */
 		INIT_CRC32C(crc);
@@ -641,48 +652,56 @@ void
 ptrack_mark_block(RelFileNodeBackend smgr_rnode,
 				  ForkNumber forknum, BlockNumber blocknum)
 {
+	PtBlockId	bid;
 	size_t		hash;
+	size_t		slot1;
+	size_t		slot2;
 	XLogRecPtr	new_lsn;
-	PtBlockId	bid;
 	/*
 	 * We use pg_atomic_uint64 here only for alignment purposes, because
-	 * pg_atomic_uint64 is forcely aligned on 8 bytes during the MSVC build.
+	 * pg_atomic_uint64 is forcedly aligned on 8 bytes during the MSVC build.
 	 */
 	pg_atomic_uint64	old_lsn;
 	pg_atomic_uint64	old_init_lsn;
 
-	if (ptrack_map_size != 0 && (ptrack_map != NULL) &&
-		smgr_rnode.backend == InvalidBackendId) /* do not track temporary
-												 * relations */
-	{
-		bid.relnode = smgr_rnode.node;
-		bid.forknum = forknum;
-		bid.blocknum = blocknum;
-		hash = BID_HASH_FUNC(bid);
-
-		if (RecoveryInProgress())
-			new_lsn = GetXLogReplayRecPtr(NULL);
-		else
-			new_lsn = GetXLogInsertRecPtr();
+	if (ptrack_map_size == 0
+		|| ptrack_map == NULL
+		|| smgr_rnode.backend != InvalidBackendId) /* do not track temporary
+													* relations */
+		return;
 
-		old_lsn.value = pg_atomic_read_u64(&ptrack_map->entries[hash]);
+	bid.relnode = smgr_rnode.node;
+	bid.forknum = forknum;
+	bid.blocknum = blocknum;
 
-		/* Atomically assign new init LSN value */
-		old_init_lsn.value = pg_atomic_read_u64(&ptrack_map->init_lsn);
+	hash = BID_HASH_FUNC(bid);
+	slot1 = hash % PtrackContentNblocks;
+	slot2 = ((hash << 32) | (hash >> 32)) % PtrackContentNblocks;
 
-		if (old_init_lsn.value == InvalidXLogRecPtr)
-		{
-			elog(DEBUG1, "ptrack_mark_block: init_lsn " UINT64_FORMAT " <- " UINT64_FORMAT, old_init_lsn.value, new_lsn);
-
-			while (old_init_lsn.value < new_lsn &&
-				   !pg_atomic_compare_exchange_u64(&ptrack_map->init_lsn, (uint64 *) &old_init_lsn.value, new_lsn));
-		}
+	if (RecoveryInProgress())
+		new_lsn = GetXLogReplayRecPtr(NULL);
+	else
+		new_lsn = GetXLogInsertRecPtr();
 
-		elog(DEBUG3, "ptrack_mark_block: map[%zu]=" UINT64_FORMAT " <- " UINT64_FORMAT, hash, old_lsn.value, new_lsn);
+	/* Atomically assign new init LSN value */
+	old_init_lsn.value = pg_atomic_read_u64(&ptrack_map->init_lsn);
+	if (old_init_lsn.value == InvalidXLogRecPtr)
+	{
+		elog(DEBUG1, "ptrack_mark_block: init_lsn " UINT64_FORMAT " <- " UINT64_FORMAT, old_init_lsn.value, new_lsn);
 
-		/* Atomically assign new LSN value */
-		while (old_lsn.value < new_lsn &&
-			   !pg_atomic_compare_exchange_u64(&ptrack_map->entries[hash], (uint64 *) &old_lsn.value, new_lsn));
-		elog(DEBUG3, "ptrack_mark_block: map[%zu]=" UINT64_FORMAT, hash, pg_atomic_read_u64(&ptrack_map->entries[hash]));
+		while (old_init_lsn.value < new_lsn &&
+			   !pg_atomic_compare_exchange_u64(&ptrack_map->init_lsn, (uint64 *) &old_init_lsn.value, new_lsn));
 	}
+
+	/* Atomically assign new LSN value to the first slot */
+	old_lsn.value = pg_atomic_read_u64(&ptrack_map->entries[slot1]);
+	elog(DEBUG3, "ptrack_mark_block: map[%zu]=" UINT64_FORMAT " <- " UINT64_FORMAT, slot1, old_lsn.value, new_lsn);
+	while (old_lsn.value < new_lsn &&
+		   !pg_atomic_compare_exchange_u64(&ptrack_map->entries[slot1], (uint64 *) &old_lsn.value, new_lsn));
+	elog(DEBUG3, "ptrack_mark_block: map[%zu]=" UINT64_FORMAT, hash, pg_atomic_read_u64(&ptrack_map->entries[slot1]));
+
+	/* And to the second */
+	old_lsn.value = pg_atomic_read_u64(&ptrack_map->entries[slot2]);
+	while (old_lsn.value < new_lsn &&
+		   !pg_atomic_compare_exchange_u64(&ptrack_map->entries[slot2], (uint64 *) &old_lsn.value, new_lsn));
 }

engine.h

@@ -50,7 +50,7 @@ typedef struct PtrackMapHdr
 {
 	/*
 	 * Three magic bytes (+ \0) to be sure, that we are reading ptrack.map
-	 * with a right PtrackMapHdr strucutre.
+	 * with a right PtrackMapHdr structure.
 	 */
 	char		magic[PTRACK_MAGIC_SIZE];
 
@@ -72,7 +72,6 @@ typedef struct PtrackMapHdr
 
 typedef PtrackMapHdr * PtrackMap;
 
-/* TODO: check MAXALIGN usage below */
 /* Number of elements in ptrack map (LSN array)  */
 #define PtrackContentNblocks \
 		((ptrack_map_size - offsetof(PtrackMapHdr, entries) - sizeof(pg_crc32c)) / sizeof(pg_atomic_uint64))
@@ -84,9 +83,10 @@ typedef PtrackMapHdr * PtrackMap;
 /* CRC32 value offset in order to directly access it in the mmap'ed memory chunk */
 #define PtrackCrcOffset (PtrackActualSize - sizeof(pg_crc32c))
 
-/* Map block address 'bid' to map slot */
+/* Block address 'bid' to hash.  To get slot position in map should be divided
+ * with '% PtrackContentNblocks' */
 #define BID_HASH_FUNC(bid) \
-		(size_t)(DatumGetUInt64(hash_any_extended((unsigned char *)&bid, sizeof(bid), 0)) % PtrackContentNblocks)
+		(size_t)(DatumGetUInt64(hash_any_extended((unsigned char *)&bid, sizeof(bid), 0)))
 
 /*
  * Per process pointer to shared ptrack_map

ptrack.c

@@ -420,10 +420,9 @@ PG_FUNCTION_INFO_V1(ptrack_get_pagemapset);
 Datum
 ptrack_get_pagemapset(PG_FUNCTION_ARGS)
 {
+	PtScanCtx *ctx;
 	FuncCallContext *funcctx;
-	PtScanCtx  *ctx;
 	MemoryContext oldcontext;
-	XLogRecPtr	update_lsn;
 	datapagemap_t pagemap;
 	char		gather_path[MAXPGPATH];
 
@@ -486,6 +485,12 @@ ptrack_get_pagemapset(PG_FUNCTION_ARGS)
 
 	while (true)
 	{
+		size_t		hash;
+		size_t		slot1;
+		size_t		slot2;
+		XLogRecPtr	update_lsn1;
+		XLogRecPtr	update_lsn2;
+
 		/* Stop traversal if there are no more segments */
 		if (ctx->bid.blocknum > ctx->relsize)
 		{
@@ -525,15 +530,25 @@ ptrack_get_pagemapset(PG_FUNCTION_ARGS)
 			}
 		}
 
-		update_lsn = pg_atomic_read_u64(&ptrack_map->entries[BID_HASH_FUNC(ctx->bid)]);
+		hash = BID_HASH_FUNC(ctx->bid);
+		slot1 = hash % PtrackContentNblocks;
+		slot2 = ((hash << 32) | (hash >> 32)) % PtrackContentNblocks;
+
+		update_lsn1 = pg_atomic_read_u64(&ptrack_map->entries[slot1]);
+		update_lsn2 = pg_atomic_read_u64(&ptrack_map->entries[slot2]);
+
+		if (update_lsn1 != InvalidXLogRecPtr)
+			elog(DEBUG3, "ptrack: update_lsn1 %X/%X of blckno %u of file %s",
+				 (uint32) (update_lsn1 >> 32), (uint32) update_lsn1,
+				 ctx->bid.blocknum, ctx->relpath);
 
-		if (update_lsn != InvalidXLogRecPtr)
-			elog(DEBUG3, "ptrack: update_lsn %X/%X of blckno %u of file %s",
-				 (uint32) (update_lsn >> 32), (uint32) update_lsn,
+		if (update_lsn2 != InvalidXLogRecPtr)
+			elog(DEBUG3, "ptrack: update_lsn2 %X/%X of blckno %u of file %s",
+				 (uint32) (update_lsn1 >> 32), (uint32) update_lsn2,
 				 ctx->bid.blocknum, ctx->relpath);
 
-		/* Block has been changed since specified LSN. Mark it in the bitmap */
-		if (update_lsn >= ctx->lsn)
+		/* Block has been changed since specified LSN.  Mark it in the bitmap */
+		if (update_lsn1 >= ctx->lsn && update_lsn2 >= ctx->lsn)
 			datapagemap_add(&pagemap, ctx->bid.blocknum % ((BlockNumber) RELSEG_SIZE));
 
 		ctx->bid.blocknum += 1;

ptrack.h

@@ -24,7 +24,7 @@
 /* Ptrack version as a string */
 #define PTRACK_VERSION "2.1"
 /* Ptrack version as a number */
-#define PTRACK_VERSION_NUM 210
+#define PTRACK_VERSION_NUM 220
 
 /*
  * Structure identifying block on the disk.