[Patch] Optimize dropping of relation buffers using dlist

From 8e1c614a645e2b688cf0166d119e903050bd5fe2 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 25 Sep 2019 02:24:13 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

---
 src/backend/storage/buffer/Makefile     |   2 +-
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     |  84 +++++----
 src/backend/storage/buffer/cached_buf.c | 324 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     | 163 ++++++++++++++++
 5 files changed, 539 insertions(+), 40 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index 2c10fba..fa23c0c 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -12,6 +12,6 @@ subdir = src/backend/storage/buffer
 top_builddir = ../../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = buf_table.o buf_init.o bufmgr.o freelist.o localbuf.o
+OBJS = buf_table.o buf_init.o bufmgr.o freelist.o localbuf.o cached_buf.o
 
 include $(top_srcdir)/src/backend/common.mk
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index ccd2c31..3e4eb40 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -146,6 +146,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -189,5 +192,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 483f705..0ec6a78 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1268,6 +1268,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 			return buf;
 		}
+		/* Insert an entry into the cached block list */
+		CachedBufTableInsert(&newTag.rnode, buf->buf_id);
 
 		/*
 		 * Need to lock the buffer header too in order to change its tag.
@@ -1285,6 +1287,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 			break;
 
 		UnlockBufHdr(buf, buf_state);
+		CachedBufTableDelete(&newTag.rnode, buf->buf_id);
 		BufTableDelete(&newTag, newHash);
 		if (oldPartitionLock != NULL &&
 			oldPartitionLock != newPartitionLock)
@@ -1319,6 +1322,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
@@ -1432,7 +1436,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2916,19 +2923,15 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
 DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			i, j, nbufs;
+	int			buf_id_array[BUF_ID_ARRAY_SIZE];
+	int			forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2942,45 +2945,48 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32	buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..3a3b1fb
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,324 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+static HTAB		*CachedBufHash = NULL;
+
+BufDlistEnt	*BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static uint32 CachedBufTableHashCode(RelFileNode *rnode);
+static LWLock *GetCachedBufPartitionLock(RelFileNode *rnode,
+										 uint32 *hashcodePtr);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers,
+											sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/*
+ * InitCachedBLockTable
+ *      Initialize the cached block hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList, foundLock;
+	int			i;
+
+	info.keysize = sizeof(RelFileNode);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Block Lookup Table",
+								  size, size,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			LWLockInitialize(&CachedBufLockArray->cacheLock[i],
+							 CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_block_tranche_id");
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with target relation
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * relation. We do it like this because the callers need to know the hash
+  * code in order to determine which partition to lock, and we don't want
+  * to do the hash computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(RelFileNode *rnode)
+{
+	return get_hash_value(CachedBufHash, (void *) rnode);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static LWLock *
+GetCachedBufPartitionLock(RelFileNode *rnode, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(rnode);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given relation and buffer ID
+ *
+ * If a hash entry for the target relation already exists, only buffer ID
+ * is inserted. Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold exclusive lock for relation's partition.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, int buf_id)
+{
+	uint32			hashcode;
+	LWLock			*map_lock;
+	CachedBufEnt	*hash_entry;
+	bool			found;
+
+	map_lock = GetCachedBufPartitionLock(rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) rnode,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	Assert(buf_id >= 0);
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	LWLockRelease(map_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers of target relation in the cached buffer hash
+ *      table, insert the buffer IDs to the given array of buffer ID, and
+ *      return the number of buffers inserted in the array.
+ *
+ * This function must hold shared LWLock for relation's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size)
+{
+	uint32		hashcode;
+	LWLock		*map_lock;
+	CachedBufEnt	*hash_entry;
+	CachedBufEnt	temp_head_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		i;
+	int		curr_buf_id;
+	int		new_curr_buf_id;
+	int		count = 0;
+	bool		target_buf = false;
+
+	map_lock = GetCachedBufPartitionLock(&rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_SHARED);
+
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &rnode,
+									hashcode,
+									HASH_FIND,
+									NULL);
+
+	if (!hash_entry)
+	{
+		LWLockRelease(map_lock);
+		return 0;	/* No existing hash entry */
+	}
+
+	/* Initial temporary dlist */
+	temp_head_entry.head = CACHED_BUF_END_OF_LIST;
+
+	/* When traversing the main dlist, start from head */
+	curr_buf_id = hash_entry->head;
+
+	while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+	{
+		BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+		curr_entry = cb_dlist_entry(curr_buf_id);
+		new_curr_buf_id = curr_entry->next;
+
+		/* Check if it's our target buffer */
+		for (i = 0; i < nforks; i++)
+		{
+			if (bufHdr->tag.forkNum != forkNum[i])
+				continue;
+			else
+			{
+				if (bufHdr->tag.blockNum >= firstDelBlock[i])
+					target_buf = true;
+				break;
+			}
+		}
+
+		if (target_buf)
+		{
+			forknum_indexes[count] = i;
+			buf_id_array[count] = curr_buf_id;
+			++count;
+		}
+		else
+		{
+			/*
+			 * It's not the target buffer. Remove the current buffer ID
+			 * from the current list of target buffer IDs and store it
+			 * to a temporary list.
+			 */
+			cb_dlist_delete(hash_entry, curr_buf_id);
+			cb_dlist_push_head(&temp_head_entry, curr_buf_id);
+		}
+		/* Move current pointer to next */
+		curr_buf_id = new_curr_buf_id;
+	}
+
+	/* Check if main dlist is now empty */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry->head = temp_head_entry.head;
+		temp_head_entry.head = CACHED_BUF_END_OF_LIST;
+	}
+
+	/* If we have a temporary dlist, append it to the main dlist */
+	if (!cb_dlist_is_empty(hash_entry) &&
+		!cb_dlist_is_empty(&temp_head_entry))
+		cb_dlist_combine(hash_entry, &temp_head_entry);
+
+	LWLockRelease(map_lock);
+
+	return count;
+}
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the relation hash entry if its list is empty.
+ *
+ * This function must hold exclusive lock for relation's partition.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, int buf_id)
+{
+	LWLock		*map_lock;
+	uint32		hashcode;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	Assert(buf_id >= 0);
+
+	map_lock = GetCachedBufPartitionLock(rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) rnode,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* rnode not found, nothing to do */
+	{
+		LWLockRelease(map_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the target relation,
+	 * remove the relation hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) rnode,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	LWLockRelease(map_lock);
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index 6ffe184..1efb41a 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -297,6 +297,7 @@ typedef struct CkptSortItem
 
 extern CkptSortItem *CkptBufferIds;
 
+
 /*
  * Internal buffer management routines
  */
@@ -338,4 +339,166 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	RelFileNode		rnode;
+	int			head;	/* head index of list */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+#define NUM_MAP_PARTITIONS	128
+#define BUF_ID_ARRAY_SIZE	100
+
+/* end of list entry for cached buffer list */
+#define CACHED_BUF_END_OF_LIST	(-1)
+
+extern BufDlistEnt	*BufDlistEntArray;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	LWLock	cacheLock[NUM_MAP_PARTITIONS];
+	int		cacheTrancheId;
+} CachedBufTableLock;
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode, int buf_id);
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the cached buffer id of the target entry */
+static inline int
+cb_dlist_buf_id(BufDlistEnt *entry)
+{
+	return entry - BufDlistEntArray;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt *new_entry = cb_dlist_entry(buf_id);
+
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		new_entry->prev = buf_id; /* TAIL */
+		new_entry->next = hash_entry->head;
+	}
+	else
+	{
+		BufDlistEnt *head_entry = cb_dlist_entry(hash_entry->head);
+		int tail = head_entry->prev;
+		new_entry->prev = tail;
+		new_entry->next = hash_entry->head;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	int tail = head_entry->prev;
+	BufDlistEnt	*tail_entry = cb_dlist_entry(tail);
+
+	/* If entry to be deleted is the only entry */
+	if (head_entry == tail_entry)
+	{
+		head_entry->prev = CACHED_BUF_END_OF_LIST;
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = tail;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt  *temp_head_entry = cb_dlist_entry(temp->head);
+	int main_tail = main_head_entry->prev;
+	int temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp_head_entry->prev = CACHED_BUF_END_OF_LIST;
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From f6c46678dd0191f803bc9f897a72f9fa5c1f9e27 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Tue, 12 Nov 2019 08:55:00 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     |  84 +++---
 src/backend/storage/buffer/cached_buf.c | 450 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  12 +
 5 files changed, 514 insertions(+), 39 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index ccd2c31..3e4eb40 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -146,6 +146,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -189,5 +192,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 7ad1073..6a5e3b6 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1268,6 +1268,8 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 			return buf;
 		}
+		/* Insert an entry into the cached buffer list */
+		CachedBufTableInsert(&newTag.rnode, buf->buf_id);
 
 		/*
 		 * Need to lock the buffer header too in order to change its tag.
@@ -1285,6 +1287,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 			break;
 
 		UnlockBufHdr(buf, buf_state);
+		CachedBufTableDelete(&newTag.rnode, buf->buf_id);
 		BufTableDelete(&newTag, newHash);
 		if (oldPartitionLock != NULL &&
 			oldPartitionLock != newPartitionLock)
@@ -1319,6 +1322,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
@@ -1432,7 +1436,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2916,19 +2923,15 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
 DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			i, j, nbufs;
+	int			buf_id_array[BUF_ID_ARRAY_SIZE];
+	int			forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2942,45 +2945,48 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..8d9f658
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,450 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS	128	/* number of partition of hash table */
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	RelFileNode		rnode;
+	int			head;	/* head index of list */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	LWLock	cacheLock[NUM_MAP_PARTITIONS];
+	int	cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static uint32 CachedBufTableHashCode(RelFileNode *rnode);
+static LWLock *GetCachedBufPartitionLock(RelFileNode *rnode,
+										 uint32 *hashcodePtr);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/*
+ * InitCachedBLockTable
+ *      Initialize the cached block hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList, foundLock;
+	int		i;
+
+	info.keysize = sizeof(RelFileNode);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Block Lookup Table",
+								  size, size, &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			LWLockInitialize(&CachedBufLockArray->cacheLock[i],
+							 CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_block_tranche_id");
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with target relation
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * relation. We do it like this because the callers need to know the hash
+  * code in order to determine which partition to lock, and we don't want
+  * to do the hash computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(RelFileNode *rnode)
+{
+	return get_hash_value(CachedBufHash, (void *) rnode);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static LWLock *
+GetCachedBufPartitionLock(RelFileNode *rnode, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(rnode);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given relation and buffer ID
+ *
+ * If a hash entry for the target relation already exists, only buffer ID
+ * is inserted. Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold exclusive lock for relation's partition.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, int buf_id)
+{
+	uint32		hashcode;
+	LWLock		*map_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	map_lock = GetCachedBufPartitionLock(rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) rnode,
+									hashcode, HASH_ENTER, &found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	LWLockRelease(map_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers of target relation in the cached buffer hash
+ *      table, insert the buffer IDs to the given array of buffer ID, and
+ *      return the number of buffers inserted in the array.
+ *
+ * This function must hold exclusive LWLock for relation's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size)
+{
+	uint32		hashcode;
+	LWLock		*map_lock;
+	CachedBufEnt	*hash_entry;
+	CachedBufEnt	temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		i;
+	int		curr_buf_id;
+	int		new_curr_buf_id;
+	int		count = 0;
+	bool		target_buf = false;
+
+	map_lock = GetCachedBufPartitionLock(&rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &rnode,
+									hashcode, HASH_FIND, NULL);
+
+	if (!hash_entry)
+	{
+		LWLockRelease(map_lock);
+		return 0;	/* No existing hash entry */
+	}
+
+	/* Initial temporary dlist */
+	temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+	/* When traversing the main dlist, start from head */
+	curr_buf_id = hash_entry->head;
+
+	while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+	{
+		BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+		curr_entry = BufDlistEntArray + curr_buf_id;
+		new_curr_buf_id = curr_entry->next;
+
+		/* Check if it's our target buffer */
+		for (i = 0; i < nforks; i++)
+		{
+			if (bufHdr->tag.forkNum != forkNum[i])
+				continue;
+			else
+			{
+				if (bufHdr->tag.blockNum >= firstDelBlock[i])
+					target_buf = true;
+				break;
+			}
+		}
+
+		if (target_buf)
+		{
+			forknum_indexes[count] = i;
+			buf_id_array[count] = curr_buf_id;
+			++count;
+		}
+		else
+		{
+			/*
+			 * It's not the target buffer. Remove the current buffer ID
+			 * from the current list of target buffer IDs and store it
+			 * to a temporary list.
+			 */
+			cb_dlist_delete(hash_entry, curr_buf_id);
+			cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+		}
+		/* Move current pointer to next */
+		curr_buf_id = new_curr_buf_id;
+	}
+
+	/* Check if main dlist is now empty */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry->head = temp_hash_entry.head;
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+	}
+
+	/* If we have a temporary dlist, append it to the main dlist */
+	if (!cb_dlist_is_empty(hash_entry) &&
+		!cb_dlist_is_empty(&temp_hash_entry))
+		cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+	LWLockRelease(map_lock);
+
+	return count;
+}
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the relation hash entry if its list is empty.
+ *
+ * This function must hold exclusive lock for relation's partition.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, int buf_id)
+{
+	LWLock		*map_lock;
+	uint32		hashcode;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	map_lock = GetCachedBufPartitionLock(rnode, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) rnode,
+									hashcode, HASH_FIND, &found);
+
+	if (!found)		/* rnode not found, nothing to do */
+	{
+		LWLockRelease(map_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the target relation,
+	 * remove the relation hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) rnode,
+										hashcode, HASH_REMOVE, NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	LWLockRelease(map_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If entry to be deleted is the only entry */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index 6ffe184..bb69106 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -338,4 +338,16 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode, int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From ed11082ef20329a766080524ff4f5c6b95222c13 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Tue, 12 Nov 2019 08:55:00 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     |  83 +++---
 src/backend/storage/buffer/cached_buf.c | 486 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  14 +
 5 files changed, 551 insertions(+), 39 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index 1eb08cd..b04e9b2 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -145,6 +145,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -188,5 +191,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 7ad1073..634273c 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1268,6 +1268,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 			return buf;
 		}
+		CachedBufTableInsert(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 
 		/*
 		 * Need to lock the buffer header too in order to change its tag.
@@ -1285,6 +1286,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 			break;
 
 		UnlockBufHdr(buf, buf_state);
+		CachedBufTableDelete(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 		BufTableDelete(&newTag, newHash);
 		if (oldPartitionLock != NULL &&
 			oldPartitionLock != newPartitionLock)
@@ -1319,6 +1321,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
@@ -1432,7 +1435,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2916,19 +2922,15 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
 DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			i, j, nbufs;
+	int			buf_id_array[BUF_ID_ARRAY_SIZE];
+	int			forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2942,45 +2944,48 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..9ed0f56
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,486 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS_FOR_REL	128	/* relation-level */
+#define NUM_MAP_PARTITIONS_IN_REL	4	/* block-level */
+#define NUM_MAP_PARTITIONS \
+	(NUM_MAP_PARTITIONS_FOR_REL * NUM_MAP_PARTITIONS_IN_REL)
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* hash table key */
+typedef struct CachedBufTag
+{
+	RelFileNode		rnode;		/* relation */
+	int			modOfBlockNum;	/* modulo of BlockNumber*/
+} CachedBufTag;
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	CachedBufTag	key;	/* hash table key */
+	int		head;	/* index of dlist */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	LWLock	cacheLock[NUM_MAP_PARTITIONS];
+	int	cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static uint32 CachedBufTableHashCode(CachedBufTag *tag);
+static LWLock *GetCachedBufPartitionLock(CachedBufTag *tag,
+										 uint32 *hashcode);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers + NUM_MAP_PARTITIONS,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/*
+ * InitCachedBufTable
+ *      Initialize the cached buffer hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList, foundLock;
+	int		i;
+
+	info.keysize = sizeof(CachedBufTag);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Buffer Lookup Table",
+								  size + NUM_MAP_PARTITIONS,
+								  size + NUM_MAP_PARTITIONS,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("buffer dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("cached buffer hash partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			LWLockInitialize(&CachedBufLockArray->cacheLock[i],
+							 CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_buf_tranche_id");
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with tag
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * tag. We do it like this because the callers need to know the hash code
+  * to determine which partition to lock, and we don't want to do the  hash
+  * computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(CachedBufTag *tag)
+{
+	return get_hash_value(CachedBufHash, (void *) tag);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static LWLock *
+GetCachedBufPartitionLock(CachedBufTag *tag, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(tag);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given tag and buffer ID
+ *
+ * If a hash entry for the tag already exists, only buffer ID is inserted.
+ * Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold exclusive lock for tag's partition
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	LWLock		*map_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	map_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	LWLockRelease(map_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers for the given tag in the cached buffer hash
+ *		table. Insert the buffer ID to the array of buffer IDs, and
+ *		return the total number of buffers in the array.
+ *
+ * This function must hold exclusive LWLock for tag's partition
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				int *forknum_indexes, BlockNumber *firstDelBlock,
+				int *buf_id_array, int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	LWLock		*map_lock;
+	CachedBufEnt	*hash_entry;
+	CachedBufEnt	temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		mod;
+	int		i;
+	int		curr_buf_id;
+	int		new_curr_buf_id;
+	int		count = 0;
+	bool		target_buf = false;
+
+	for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+	{
+		cb_tag.rnode = rnode;
+		cb_tag.modOfBlockNum = mod;
+
+		map_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+		LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_FIND,
+										NULL);
+
+		if (!hash_entry)
+		{
+			LWLockRelease(map_lock);
+			continue;
+		}
+
+		/* Initial temporary dlist */
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+		/* When traversing the main dlist, start from head */
+		curr_buf_id = hash_entry->head;
+
+		while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+			curr_entry = BufDlistEntArray + curr_buf_id;
+			new_curr_buf_id = curr_entry->next;
+
+			/* Check if it's our target buffer */
+			for (i = 0; i < nforks; i++)
+			{
+				if (bufHdr->tag.forkNum != forkNum[i])
+					continue;
+				else
+				{
+					if (bufHdr->tag.blockNum >= firstDelBlock[i])
+						target_buf = true;
+					break;
+				}
+			}
+
+			if (target_buf)
+			{
+				forknum_indexes[count] = i;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+			}
+			else
+			{
+				/*
+				* It's not the target buffer. Remove the current buffer ID
+				* from the current list of target buffer IDs and store it
+				* to a temporary list.
+				*/
+				cb_dlist_delete(hash_entry, curr_buf_id);
+				cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+			}
+			/* Move current pointer to next */
+			curr_buf_id = new_curr_buf_id;
+		}
+
+		/* Check if main dlist is now empty */
+		if (cb_dlist_is_empty(hash_entry))
+		{
+			hash_entry->head = temp_hash_entry.head;
+			temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+		}
+
+		/* If we have a temporary dlist, append it to the main dlist */
+		if (!cb_dlist_is_empty(hash_entry) &&
+			!cb_dlist_is_empty(&temp_hash_entry))
+			cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+		LWLockRelease(map_lock);
+	}
+
+	return count;
+}
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the hash entry for the given tag if its list is empty.
+ *
+ * This function must hold exclusive lock for tag's partition
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	LWLock		*map_lock;
+	uint32		hashcode;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	map_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	LWLockAcquire(map_lock, LW_EXCLUSIVE);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* tag not found, nothing to do */
+	{
+		LWLockRelease(map_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the given tag,
+	 * remove the hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	LWLockRelease(map_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If only one entry is in the list */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index d540c0a..1068815 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -337,4 +337,18 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum,
+								 int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode,  BlockNumber *blockNum,
+								 int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From d3ef35f28494255d6a7f1d7a80d088f491f29ffd Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Tue, 12 Nov 2019 08:55:00 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     |  88 ++---
 src/backend/storage/buffer/cached_buf.c | 571 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  14 +
 5 files changed, 639 insertions(+), 41 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index 1eb08cd..b04e9b2 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -145,6 +145,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -188,5 +191,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 7ad1073..4e6e52f 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1268,6 +1268,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 			return buf;
 		}
+		CachedBufTableInsert(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 
 		/*
 		 * Need to lock the buffer header too in order to change its tag.
@@ -1285,6 +1286,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 			break;
 
 		UnlockBufHdr(buf, buf_state);
+		CachedBufTableDelete(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 		BufTableDelete(&newTag, newHash);
 		if (oldPartitionLock != NULL &&
 			oldPartitionLock != newPartitionLock)
@@ -1319,6 +1321,7 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
@@ -1432,7 +1435,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2916,11 +2922,6 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
@@ -2928,59 +2929,64 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
-	int			j;
+	int			nbufs;
+	int			buf_id_array[BUF_ID_ARRAY_SIZE];
+	int			forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (i = 0; i < nforks; i++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[i],
+											firstDelBlock[i]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..066b143
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,571 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS_FOR_REL	128	/* relation-level */
+#define NUM_MAP_PARTITIONS_IN_REL	4	/* block-level */
+#define NUM_MAP_PARTITIONS \
+	(NUM_MAP_PARTITIONS_FOR_REL * NUM_MAP_PARTITIONS_IN_REL)
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* hash table key */
+typedef struct CachedBufTag
+{
+	RelFileNode		rnode;		/* relation */
+	int			modOfBlockNum;	/* modulo of BlockNumber*/
+} CachedBufTag;
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	CachedBufTag	key;	/* hash table key */
+	int		head;	/* index of dlist */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* Locks to be used for the hash table operations */
+typedef struct CombinedLock
+{
+	volatile bool	flag;	/* flag for lookup operation */
+	slock_t		spinLock;	/* spinlock to protect the flag */
+	LWLock		lwLock;	/* LWLock used in lookup */
+} CombinedLock;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	CombinedLock	cacheLock[NUM_MAP_PARTITIONS];
+	int		cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static void CombinedLockInitialize(CombinedLock *lock, int trancheId);
+static uint32 CachedBufTableHashCode(CachedBufTag *tag);
+static CombinedLock *GetCachedBufPartitionLock(CachedBufTag *tag,
+											   uint32 *hashcode);
+static void CombinedLockAcquireSpinLock(CombinedLock *lock);
+static void CombinedLockAcquireLWLock(CombinedLock *lock);
+static void CombinedLockReleaseSpinLock(CombinedLock *lock);
+static void CombinedLockReleaseLWLock(CombinedLock *lock);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers +
+											 NUM_MAP_PARTITIONS,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/* Initialize spinlock and LWLock for cached buffer hash table */
+void
+CombinedLockInitialize(CombinedLock *lock, int trancheId)
+{
+	lock->flag = false;
+	SpinLockInit(&lock->spinLock);
+	LWLockInitialize(&lock->lwLock, trancheId);
+}
+
+/*
+ * InitCachedBufTable
+ *      Initialize the cached buffer hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList;
+	bool		foundLock;
+	int		i;
+
+	info.keysize = sizeof(CachedBufTag);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Buffer Lookup Table",
+								  size + NUM_MAP_PARTITIONS,
+								  size + NUM_MAP_PARTITIONS,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("buffer dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("cached buffer hash partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			CombinedLockInitialize(&CachedBufLockArray->cacheLock[i],
+								   CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_buf_tranche_id");
+
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with tag
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * tag. We do it like this because the callers need to know the hash code
+  * to determine which partition to lock, and we don't want to do the  hash
+  * computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(CachedBufTag *tag)
+{
+	return get_hash_value(CachedBufHash, (void *) tag);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static CombinedLock *
+GetCachedBufPartitionLock(CachedBufTag *tag, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(tag);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CombinedLockAcquireSpinLock
+ *		Acquire spinlock to proceed to inserting/deleting hash
+ *		table entries
+ *
+ * This function waits for a lookup process (if flag is true) to finish,
+ * before reacquring a spinlock.
+ */
+void
+CombinedLockAcquireSpinLock(CombinedLock *lock)
+{
+	SpinLockAcquire(&lock->spinLock);
+
+	while (lock->flag)
+	{
+		SpinLockRelease(&lock->spinLock);
+		LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+		LWLockRelease(&lock->lwLock);
+		SpinLockAcquire(&lock->spinLock);
+	}
+}
+
+/*
+ * CombinedLockAcquireLWLock
+ *		Get LWLock instance for partition of cached buffer lookup table
+ *
+ * To prevent other backend processes from modifying the lookup table,
+ * this function sets the CombinedLock's flag to true.
+ */
+void
+CombinedLockAcquireLWLock(CombinedLock *lock)
+{
+	LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+	SpinLockAcquire(&lock->spinLock);
+	lock->flag = true;
+	SpinLockRelease(&lock->spinLock);
+}
+
+/* 
+ * CombinedLockReleaseSpinLock
+ *		Release the spinlock used in insert/delete functions 
+ */
+void
+CombinedLockReleaseSpinLock(CombinedLock *lock)
+{
+	SpinLockRelease(&lock->spinLock);
+}
+
+/* 
+ * CombinedLockReleaseSpinLock
+ *		Release the LWLock used in lookup function after changing the
+ *		CombinedLock's flag to false.
+ */
+void
+CombinedLockReleaseLWLock(CombinedLock *lock)
+{
+	lock->flag = false;
+	LWLockRelease(&lock->lwLock);
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given tag and buffer ID
+ *
+ * If a hash entry for the tag already exists, only buffer ID is inserted.
+ * Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers for the given tag in the cached buffer
+ *		hash table. Insert the buffer ID to the array of buffer
+ *		IDs, and return the total number of buffers in the array.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				int *forknum_indexes, BlockNumber *firstDelBlock,
+				int *buf_id_array, int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	CachedBufEnt	temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		mod;
+	int		i;
+	int		curr_buf_id;
+	int		new_curr_buf_id;
+	int		count = 0;
+	bool		target_buf = false;
+
+	for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+	{
+		cb_tag.rnode = rnode;
+		cb_tag.modOfBlockNum = mod;
+
+		combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+		CombinedLockAcquireLWLock(combined_lock);
+
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_FIND,
+										NULL);
+
+		if (!hash_entry)
+		{
+			CombinedLockReleaseLWLock(combined_lock);
+			continue;
+		}
+
+		/* Initial temporary dlist */
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+		/* When traversing the main dlist, start from head */
+		curr_buf_id = hash_entry->head;
+
+		while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+			curr_entry = BufDlistEntArray + curr_buf_id;
+			new_curr_buf_id = curr_entry->next;
+
+			/* Check if it's our target buffer */
+			for (i = 0; i < nforks; i++)
+			{
+				if (bufHdr->tag.forkNum != forkNum[i])
+					continue;
+				else
+				{
+					if (bufHdr->tag.blockNum >= firstDelBlock[i])
+						target_buf = true;
+					break;
+				}
+			}
+
+			if (target_buf)
+			{
+				forknum_indexes[count] = i;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+			}
+			else
+			{
+				/*
+				* It's not the target buffer. Remove the current buffer ID
+				* from the current list of target buffer IDs and store it
+				* to a temporary list.
+				*/
+				cb_dlist_delete(hash_entry, curr_buf_id);
+				cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+			}
+			/* Move current pointer to next */
+			curr_buf_id = new_curr_buf_id;
+		}
+
+		/* Check if main dlist is now empty */
+		if (cb_dlist_is_empty(hash_entry))
+		{
+			hash_entry->head = temp_hash_entry.head;
+			temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+		}
+
+		/* If we have a temporary dlist, append it to the main dlist */
+		if (!cb_dlist_is_empty(hash_entry) &&
+			!cb_dlist_is_empty(&temp_hash_entry))
+			cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+		CombinedLockReleaseLWLock(combined_lock);
+	}
+
+	return count;
+}
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the hash entry for the given tag if its list is empty.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* tag not found, nothing to do */
+	{
+		CombinedLockReleaseSpinLock(combined_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the given tag,
+	 * remove the hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If only one entry is in the list */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index d540c0a..1068815 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -337,4 +337,18 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum,
+								 int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode,  BlockNumber *blockNum,
+								 int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From 3ae203671208a60b04122ac22f3ad54c797dfb86 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Tue, 12 Nov 2019 08:55:00 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

Whenever buffer manager is called by INSERT, SELECT,
UPDATE, DELETE, TRUNCATE, VACUUM commands, the list
of buffers is also updated in an auxiliary hash table.
Cached buffer hash table is a new auxiliary hash table
structure added to the shared memory. Each hash table
entry contains key (relation file node and modulo of
block number) and buffer ID which points to the head
entry of a doubly-linked list.  The cached buffer list
links the cached pages of a target relation to a
doubly-linked list and provides the ability to improve
performance of invalidationg relation buffers by
simply scanning the list, rather than scanning the
entire shared_buffers.
---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     |  87 ++---
 src/backend/storage/buffer/cached_buf.c | 571 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  14 +
 5 files changed, 638 insertions(+), 41 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index af62d48..0d17cfd 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -145,6 +145,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -188,5 +191,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index aba3960..c8d1a00 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1319,10 +1319,12 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
 	}
+	CachedBufTableInsert(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 
 	LWLockRelease(newPartitionLock);
 
@@ -1432,7 +1434,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2926,11 +2931,6 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
@@ -2938,59 +2938,64 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
-	int			j;
+	int			nbufs;
+	int			buf_id_array[BUF_ID_ARRAY_SIZE];
+	int			forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (i = 0; i < nforks; i++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[i],
+											firstDelBlock[i]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..8af05f2
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,571 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS_FOR_REL	128	/* relation-level */
+#define NUM_MAP_PARTITIONS_IN_REL	4	/* block-level */
+#define NUM_MAP_PARTITIONS \
+	(NUM_MAP_PARTITIONS_FOR_REL * NUM_MAP_PARTITIONS_IN_REL)
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* hash table key */
+typedef struct CachedBufTag
+{
+	RelFileNode		rnode;		/* relation */
+	int			modOfBlockNum;	/* modulo of BlockNumber*/
+} CachedBufTag;
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	CachedBufTag	key;	/* hash table key */
+	int		head;	/* index of dlist */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* Locks to be used for the hash table operations */
+typedef struct CombinedLock
+{
+	volatile bool	flag;	/* flag for lookup operation */
+	slock_t		spinLock;	/* spinlock to protect the flag */
+	LWLock		lwLock;	/* LWLock used in lookup */
+} CombinedLock;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	CombinedLock	cacheLock[NUM_MAP_PARTITIONS];
+	int		cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static void CombinedLockInitialize(CombinedLock *lock, int trancheId);
+static uint32 CachedBufTableHashCode(CachedBufTag *tag);
+static CombinedLock *GetCachedBufPartitionLock(CachedBufTag *tag,
+											   uint32 *hashcode);
+static void CombinedLockAcquireSpinLock(CombinedLock *lock);
+static void CombinedLockAcquireLWLock(CombinedLock *lock);
+static void CombinedLockReleaseSpinLock(CombinedLock *lock);
+static void CombinedLockReleaseLWLock(CombinedLock *lock);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers +
+											 NUM_MAP_PARTITIONS,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/* Initialize spinlock and LWLock for cached buffer hash table */
+void
+CombinedLockInitialize(CombinedLock *lock, int trancheId)
+{
+	lock->flag = false;
+	SpinLockInit(&lock->spinLock);
+	LWLockInitialize(&lock->lwLock, trancheId);
+}
+
+/*
+ * InitCachedBufTable
+ *      Initialize the cached buffer hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList;
+	bool		foundLock;
+	int		i;
+
+	info.keysize = sizeof(CachedBufTag);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Buffer Lookup Table",
+								  size + NUM_MAP_PARTITIONS,
+								  size + NUM_MAP_PARTITIONS,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("buffer dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("cached buffer hash partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			CombinedLockInitialize(&CachedBufLockArray->cacheLock[i],
+								   CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_buf_tranche_id");
+
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with tag
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * tag. We do it like this because the callers need to know the hash code
+  * to determine which partition to lock, and we don't want to do the  hash
+  * computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(CachedBufTag *tag)
+{
+	return get_hash_value(CachedBufHash, (void *) tag);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static CombinedLock *
+GetCachedBufPartitionLock(CachedBufTag *tag, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(tag);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CombinedLockAcquireSpinLock
+ *		Acquire spinlock to proceed to inserting/deleting hash
+ *		table entries
+ *
+ * This function waits for a lookup process (if flag is true) to finish,
+ * before reacquring a spinlock.
+ */
+void
+CombinedLockAcquireSpinLock(CombinedLock *lock)
+{
+	SpinLockAcquire(&lock->spinLock);
+
+	while (lock->flag)
+	{
+		SpinLockRelease(&lock->spinLock);
+		LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+		LWLockRelease(&lock->lwLock);
+		SpinLockAcquire(&lock->spinLock);
+	}
+}
+
+/*
+ * CombinedLockAcquireLWLock
+ *		Get LWLock instance for partition of cached buffer lookup table
+ *
+ * To prevent other backend processes from modifying the lookup table,
+ * this function sets the CombinedLock's flag to true.
+ */
+void
+CombinedLockAcquireLWLock(CombinedLock *lock)
+{
+	LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+	SpinLockAcquire(&lock->spinLock);
+	lock->flag = true;
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the spinlock used in insert/delete functions
+ */
+void
+CombinedLockReleaseSpinLock(CombinedLock *lock)
+{
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the LWLock used in lookup function after changing the
+ *		CombinedLock's flag to false.
+ */
+void
+CombinedLockReleaseLWLock(CombinedLock *lock)
+{
+	lock->flag = false;
+	LWLockRelease(&lock->lwLock);
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given tag and buffer ID
+ *
+ * If a hash entry for the tag already exists, only buffer ID is inserted.
+ * Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers for the given tag in the cached buffer
+ *		hash table. Insert the buffer ID to the array of buffer
+ *		IDs, and return the total number of buffers in the array.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				int *forknum_indexes, BlockNumber *firstDelBlock,
+				int *buf_id_array, int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	CachedBufEnt	temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		mod;
+	int		i;
+	int		curr_buf_id;
+	int		new_curr_buf_id;
+	int		count = 0;
+	bool		target_buf = false;
+
+	for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+	{
+		cb_tag.rnode = rnode;
+		cb_tag.modOfBlockNum = mod;
+
+		combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+		CombinedLockAcquireLWLock(combined_lock);
+
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_FIND,
+										NULL);
+
+		if (!hash_entry)
+		{
+			CombinedLockReleaseLWLock(combined_lock);
+			continue;
+		}
+
+		/* Initial temporary dlist */
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+		/* When traversing the main dlist, start from head */
+		curr_buf_id = hash_entry->head;
+
+		while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+			curr_entry = BufDlistEntArray + curr_buf_id;
+			new_curr_buf_id = curr_entry->next;
+
+			/* Check if it's our target buffer */
+			for (i = 0; i < nforks; i++)
+			{
+				if (bufHdr->tag.forkNum != forkNum[i])
+					continue;
+				else
+				{
+					if (bufHdr->tag.blockNum >= firstDelBlock[i])
+						target_buf = true;
+					break;
+				}
+			}
+
+			if (target_buf)
+			{
+				forknum_indexes[count] = i;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+			}
+			else
+			{
+				/*
+				* It's not the target buffer. Remove the current buffer ID
+				* from the current list of target buffer IDs and store it
+				* to a temporary list.
+				*/
+				cb_dlist_delete(hash_entry, curr_buf_id);
+				cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+			}
+			/* Move current pointer to next */
+			curr_buf_id = new_curr_buf_id;
+		}
+
+		/* Check if main dlist is now empty */
+		if (cb_dlist_is_empty(hash_entry))
+		{
+			hash_entry->head = temp_hash_entry.head;
+			temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+		}
+
+		/* If we have a temporary dlist, append it to the main dlist */
+		if (!cb_dlist_is_empty(hash_entry) &&
+			!cb_dlist_is_empty(&temp_hash_entry))
+			cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+		CombinedLockReleaseLWLock(combined_lock);
+	}
+
+	return count;
+}
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the hash entry for the given tag if its list is empty.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* tag not found, nothing to do */
+	{
+		CombinedLockReleaseSpinLock(combined_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the given tag,
+	 * remove the hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If only one entry is in the list */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index bf3b8ad..a7c0b18 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -337,4 +337,18 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum,
+								 int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode,  BlockNumber *blockNum,
+								 int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From 8698283b06f488bdcc655374b172f01dece6cdc2 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 13 Mar 2020 00:47:24 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

The invalidation of relation buffers does not depend
on the size of the shared_buffers anymore. This
improves the buffer invalidation process of VACUUM and
TRUNCATE.

Cached buffer hash table is a new auxiliary hash table
structure added to the shared memory. Each hash table
entry contains key (relation file node and modulo of
block number) and buffer ID which points to the head
entry of a doubly-linked list. The cached buffer list
links the to-be-invalidated buffers of a relation to a
doubly-linked list. This significantly improves the
performance of invalidating relation buffers in
DropRelFileNodeBuffers and DropRelFileNodeBuffersAll,
by simply scanning the list rather than scanning the
entire shared_buffers.
---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     | 161 ++++----
 src/backend/storage/buffer/cached_buf.c | 638 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  16 +
 5 files changed, 748 insertions(+), 74 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index af62d48..0d17cfd 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -145,6 +145,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -188,5 +191,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e05e2b3..0b46384 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1266,10 +1266,12 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
 	}
+	CachedBufTableInsert(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 
 	LWLockRelease(newPartitionLock);
 
@@ -1379,7 +1381,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2873,71 +2878,71 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
 DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			i,
+				nbufs,
+				buf_id_array[BUF_ID_ARRAY_SIZE],
+				forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (i = 0; i < nforks; i++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[i],
+											firstDelBlock[i]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
 				InvalidateBuffer(bufHdr); /* releases spinlock */
-				break;
-			}
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
@@ -2953,7 +2958,9 @@ void
 DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
 {
 	int			i,
-				n = 0;
+				n = 0,
+				nbufs,
+				buf_id_array[BUF_ID_ARRAY_SIZE];
 	RelFileNode *nodes;
 	bool		use_bsearch;
 
@@ -2996,47 +3003,53 @@ DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
 	if (use_bsearch)
 		pg_qsort(nodes, n, sizeof(RelFileNode), rnode_comparator);
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		RelFileNode *rnode = NULL;
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
-
-		/*
-		 * As in DropRelFileNodeBuffers, an unlocked precheck should be safe
-		 * and saves some cycles.
-		 */
+		nbufs = CachedBufLookupAll(nodes, nnodes, buf_id_array,
+								   lengthof(buf_id_array));
 
-		if (!use_bsearch)
+		for (i = 0; i < nbufs; i++)
 		{
-			int			j;
+			RelFileNode *rnode = NULL;
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
 
-			for (j = 0; j < n; j++)
+			/*
+			* As in DropRelFileNodeBuffers, an unlocked precheck should be safe
+			* and saves some cycles.
+			*/
+
+			if (!use_bsearch)
 			{
-				if (RelFileNodeEquals(bufHdr->tag.rnode, nodes[j]))
+				int			j;
+
+				for (j = 0; j < n; j++)
 				{
-					rnode = &nodes[j];
-					break;
+					if (RelFileNodeEquals(bufHdr->tag.rnode, nodes[j]))
+					{
+						rnode = &nodes[j];
+						break;
+					}
 				}
 			}
-		}
-		else
-		{
-			rnode = bsearch((const void *) &(bufHdr->tag.rnode),
-							nodes, n, sizeof(RelFileNode),
-							rnode_comparator);
-		}
+			else
+			{
+				rnode = bsearch((const void *) &(bufHdr->tag.rnode),
+								nodes, n, sizeof(RelFileNode),
+								rnode_comparator);
+			}
 
-		/* buffer doesn't belong to any of the given relfilenodes; skip it */
-		if (rnode == NULL)
-			continue;
+			/* buffer doesn't belong to any of the given relfilenodes; skip it */
+			if (rnode == NULL)
+				continue;
 
-		buf_state = LockBufHdr(bufHdr);
-		if (RelFileNodeEquals(bufHdr->tag.rnode, (*rnode)))
-			InvalidateBuffer(bufHdr);	/* releases spinlock */
-		else
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+			buf_state = LockBufHdr(bufHdr);
+			if (RelFileNodeEquals(bufHdr->tag.rnode, (*rnode)))
+				InvalidateBuffer(bufHdr);	/* releases spinlock */
+			else
+				UnlockBufHdr(bufHdr, buf_state);
+		}
+	} while (nbufs == lengthof(buf_id_array));
 
 	pfree(nodes);
 }
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..1e38087
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,638 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS_FOR_REL	128	/* relation-level */
+#define NUM_MAP_PARTITIONS_IN_REL	4	/* block-level */
+#define NUM_MAP_PARTITIONS \
+	(NUM_MAP_PARTITIONS_FOR_REL * NUM_MAP_PARTITIONS_IN_REL)
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* hash table key */
+typedef struct CachedBufTag
+{
+	RelFileNode		rnode;		/* relation */
+	int			modOfBlockNum;	/* modulo of BlockNumber*/
+} CachedBufTag;
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	CachedBufTag	key;	/* hash table key */
+	int		head;	/* index of dlist */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* Locks to be used for the hash table operations */
+typedef struct CombinedLock
+{
+	volatile bool	flag;	/* flag for lookup operation */
+	slock_t		spinLock;	/* spinlock to protect the flag */
+	LWLock		lwLock;	/* LWLock used in lookup */
+} CombinedLock;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	CombinedLock	cacheLock[NUM_MAP_PARTITIONS];
+	int		cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static void CombinedLockInitialize(CombinedLock *lock, int trancheId);
+static uint32 CachedBufTableHashCode(CachedBufTag *tag);
+static CombinedLock *GetCachedBufPartitionLock(CachedBufTag *tag,
+											   uint32 *hashcode);
+static void CombinedLockAcquireSpinLock(CombinedLock *lock);
+static void CombinedLockAcquireLWLock(CombinedLock *lock);
+static void CombinedLockReleaseSpinLock(CombinedLock *lock);
+static void CombinedLockReleaseLWLock(CombinedLock *lock);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers +
+											 NUM_MAP_PARTITIONS,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/* Initialize spinlock and LWLock for cached buffer hash table */
+void
+CombinedLockInitialize(CombinedLock *lock, int trancheId)
+{
+	lock->flag = false;
+	SpinLockInit(&lock->spinLock);
+	LWLockInitialize(&lock->lwLock, trancheId);
+}
+
+/*
+ * InitCachedBufTable
+ *      Initialize the cached buffer hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList,
+				foundLock;
+	int		i;
+
+	info.keysize = sizeof(CachedBufTag);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Buffer Lookup Table",
+								  size + NUM_MAP_PARTITIONS,
+								  size + NUM_MAP_PARTITIONS,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("buffer dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("cached buffer hash partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			CombinedLockInitialize(&CachedBufLockArray->cacheLock[i],
+								   CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_buf_tranche_id");
+
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with tag
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * tag. We do it like this because the callers need to know the hash code
+  * to determine which partition to lock, and we don't want to do the  hash
+  * computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(CachedBufTag *tag)
+{
+	return get_hash_value(CachedBufHash, (void *) tag);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static CombinedLock *
+GetCachedBufPartitionLock(CachedBufTag *tag, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(tag);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CombinedLockAcquireSpinLock
+ *		Acquire spinlock to proceed to inserting/deleting hash
+ *		table entries
+ *
+ * This function waits for a lookup process (if flag is true) to finish,
+ * before reacquring a spinlock.
+ */
+void
+CombinedLockAcquireSpinLock(CombinedLock *lock)
+{
+	SpinLockAcquire(&lock->spinLock);
+
+	while (lock->flag)
+	{
+		SpinLockRelease(&lock->spinLock);
+		LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+		LWLockRelease(&lock->lwLock);
+		SpinLockAcquire(&lock->spinLock);
+	}
+}
+
+/*
+ * CombinedLockAcquireLWLock
+ *		Get LWLock instance for partition of cached buffer lookup table
+ *
+ * To prevent other backend processes from modifying the lookup table,
+ * this function sets the CombinedLock's flag to true.
+ */
+void
+CombinedLockAcquireLWLock(CombinedLock *lock)
+{
+	LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+	SpinLockAcquire(&lock->spinLock);
+	lock->flag = true;
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the spinlock used in insert/delete functions
+ */
+void
+CombinedLockReleaseSpinLock(CombinedLock *lock)
+{
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the LWLock used in lookup function after changing the
+ *		CombinedLock's flag to false.
+ */
+void
+CombinedLockReleaseLWLock(CombinedLock *lock)
+{
+	lock->flag = false;
+	LWLockRelease(&lock->lwLock);
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given tag and buffer ID
+ *
+ * If a hash entry for the tag already exists, only buffer ID is inserted.
+ * Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers for the given tag in the cached buffer
+ *		hash table. Insert the buffer ID to the array of buffer
+ *		IDs, and return the total number of buffers to be invalidated.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				int *forknum_indexes, BlockNumber *firstDelBlock,
+				int *buf_id_array, int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry,
+					temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		mod,
+			i,
+			curr_buf_id,
+			new_curr_buf_id,
+			count = 0;
+	bool		target_buf = false;
+
+	for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+	{
+		cb_tag.rnode = rnode;
+		cb_tag.modOfBlockNum = mod;
+
+		combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+		CombinedLockAcquireLWLock(combined_lock);
+
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_FIND,
+										NULL);
+
+		if (!hash_entry)
+		{
+			CombinedLockReleaseLWLock(combined_lock);
+			continue;
+		}
+
+		/* Initial temporary dlist */
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+		/* When traversing the main dlist, start from head */
+		curr_buf_id = hash_entry->head;
+
+		while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+			curr_entry = BufDlistEntArray + curr_buf_id;
+			new_curr_buf_id = curr_entry->next;
+
+			/* Check if it's our target buffer */
+			for (i = 0; i < nforks; i++)
+			{
+				if (bufHdr->tag.forkNum != forkNum[i])
+					continue;
+				else
+				{
+					if (bufHdr->tag.blockNum >= firstDelBlock[i])
+						target_buf = true;
+					break;
+				}
+			}
+
+			if (target_buf)
+			{
+				forknum_indexes[count] = i;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+			}
+			else
+			{
+				/*
+				* It's not the target buffer. Remove the current buffer ID
+				* from the current list of target buffer IDs and store it
+				* to a temporary list.
+				*/
+				cb_dlist_delete(hash_entry, curr_buf_id);
+				cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+			}
+			/* Move current pointer to next */
+			curr_buf_id = new_curr_buf_id;
+		}
+
+		/* Check if main dlist is now empty */
+		if (cb_dlist_is_empty(hash_entry))
+		{
+			hash_entry->head = temp_hash_entry.head;
+			temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+		}
+
+		/* If we have a temporary dlist, append it to the main dlist */
+		if (!cb_dlist_is_empty(hash_entry) &&
+			!cb_dlist_is_empty(&temp_hash_entry))
+			cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+		CombinedLockReleaseLWLock(combined_lock);
+	}
+
+	return count;
+}
+
+/*
+ * CachedBufLookupAll
+ *		Lookup all the buffers of specified relations in the cached buffer
+ *		hash table. Store all the buffer IDs to the array, and return
+ *		the total number of buffers to be invalidated.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookupAll(RelFileNode *rnode, int nnodes, int *buf_id_array,
+				   int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		i,
+			mod,
+			curr_buf_id,
+			new_curr_buf_id,
+			count = 0;
+
+	for (i = 0; i < nnodes; i++)
+	{
+		cb_tag.rnode = rnode[i];
+
+		for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+		{
+			cb_tag.modOfBlockNum = mod;
+
+			combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+			CombinedLockAcquireLWLock(combined_lock);
+
+			hash_entry = (CachedBufEnt *)
+				hash_search_with_hash_value(CachedBufHash,
+											(void *) &cb_tag,
+											hashcode,
+											HASH_FIND,
+											NULL);
+
+			if (!hash_entry)
+			{
+				CombinedLockReleaseLWLock(combined_lock);
+				continue;
+			}
+
+			/* When traversing the dlist, start from head */
+			curr_buf_id = hash_entry->head;
+
+			while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+			{
+				curr_entry = BufDlistEntArray + curr_buf_id;
+				new_curr_buf_id = curr_entry->next;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+				curr_buf_id = new_curr_buf_id; /* Move pointer */
+			}
+
+			CombinedLockReleaseLWLock(combined_lock);
+		}
+	}
+
+	return count;
+}
+
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the hash entry for the given tag if its list is empty.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* tag not found, nothing to do */
+	{
+		CombinedLockReleaseSpinLock(combined_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the given tag,
+	 * remove the hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If only one entry is in the list */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index bf3b8ad..2bbbcd9 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -337,4 +337,20 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum,
+								 int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern int CachedBufLookupAll(RelFileNode *rnode, int nnodes,
+							  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode,  BlockNumber *blockNum,
+								 int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From cff179afa2705ea8e4d2f8296f5166d7267dbfa3 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 5 Jun 2020 01:02:40 +0000
Subject: [PATCH] Optimize dropping of relation buffers using dlist

The invalidation of relation buffers does not depend
on the size of the shared_buffers anymore. This
improves the buffer invalidation process of VACUUM and
TRUNCATE.

Cached buffer hash table is a new auxiliary hash table
structure added to the shared memory. Each hash table
entry contains key (relation file node and modulo of
block number) and buffer ID which points to the head
entry of a doubly-linked list. The cached buffer list
links the to-be-invalidated buffers of a relation to a
doubly-linked list. This significantly improves the
performance of invalidating relation buffers in
DropRelFileNodeBuffers and DropRelFileNodeBuffersAll,
by simply scanning the list rather than scanning the
entire shared_buffers.
---
 src/backend/storage/buffer/Makefile     |   1 +
 src/backend/storage/buffer/buf_init.c   |   6 +
 src/backend/storage/buffer/bufmgr.c     | 163 ++++----
 src/backend/storage/buffer/cached_buf.c | 638 ++++++++++++++++++++++++++++++++
 src/include/storage/buf_internals.h     |  16 +
 5 files changed, 749 insertions(+), 75 deletions(-)
 create mode 100644 src/backend/storage/buffer/cached_buf.c

diff --git a/src/backend/storage/buffer/Makefile b/src/backend/storage/buffer/Makefile
index fd7c40d..3662349 100644
--- a/src/backend/storage/buffer/Makefile
+++ b/src/backend/storage/buffer/Makefile
@@ -16,6 +16,7 @@ OBJS = \
 	buf_init.o \
 	buf_table.o \
 	bufmgr.o \
+	cached_buf.o \
 	freelist.o \
 	localbuf.o
 
diff --git a/src/backend/storage/buffer/buf_init.c b/src/backend/storage/buffer/buf_init.c
index a8ce660..f248fbc 100644
--- a/src/backend/storage/buffer/buf_init.c
+++ b/src/backend/storage/buffer/buf_init.c
@@ -142,6 +142,9 @@ InitBufferPool(void)
 	/* Init other shared buffer-management stuff */
 	StrategyInitialize(!foundDescs);
 
+	/* Init cached buffer hash table and related shmem data structures */
+	InitCachedBufTable(NBuffers);
+
 	/* Initialize per-backend file flush context */
 	WritebackContextInit(&BackendWritebackContext,
 						 &backend_flush_after);
@@ -185,5 +188,8 @@ BufferShmemSize(void)
 	/* size of checkpoint sort array in bufmgr.c */
 	size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
 
+	/* size of cached buffer shmem data structures */
+	size = add_size(size, CachedBufShmemSize());
+
 	return size;
 }
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 29c9208..67f38d0 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -1329,10 +1329,12 @@ BufferAlloc(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	if (oldPartitionLock != NULL)
 	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
 		if (oldPartitionLock != newPartitionLock)
 			LWLockRelease(oldPartitionLock);
 	}
+	CachedBufTableInsert(&newTag.rnode, &newTag.blockNum, buf->buf_id);
 
 	LWLockRelease(newPartitionLock);
 
@@ -1442,7 +1444,10 @@ retry:
 	 * Remove the buffer from the lookup hashtable, if it was in there.
 	 */
 	if (oldFlags & BM_TAG_VALID)
+	{
+		CachedBufTableDelete(&oldTag.rnode, &oldTag.blockNum, buf->buf_id);
 		BufTableDelete(&oldTag, oldHash);
+	}
 
 	/*
 	 * Done with mapping lock.
@@ -2936,71 +2941,71 @@ BufferGetLSNAtomic(Buffer buffer)
  *		later.  It is also the responsibility of higher-level code to ensure
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
- *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
  * --------------------------------------------------------------------
  */
 void
 DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			i,
+				nbufs,
+				buf_id_array[BUF_ID_ARRAY_SIZE],
+				forknum_indexes[BUF_ID_ARRAY_SIZE];
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (i = 0; i < nforks; i++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[i],
+											firstDelBlock[i]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookup(rnode.node, forkNum, nforks,
+								forknum_indexes, firstDelBlock,
+								buf_id_array, lengthof(buf_id_array));
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		for (i = 0; i < nbufs; i++)
+		{
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
+			int		index = forknum_indexes[i];
 
-		buf_state = LockBufHdr(bufHdr);
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag
+			 * before we attempt to lock the buffer; this saves a lot of
+			 * lock acquisitions in typical cases.  It should be safe
+			 * because the caller must have AccessExclusiveLock on the
+			 * relation, or some other reason to be certain that no one is
+			 * loading new pages of the rel into the buffer pool.
+			 * (Otherwise we might well miss such pages entirely.)
+			 * Therefore, while the tag might be changing while we look at
+			 * it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible,
+			 * and false positives are safe because we'll recheck after
+			 * getting the buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but
+			 * the incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
-		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
-			{
-				InvalidateBuffer(bufHdr);	/* releases spinlock */
-				break;
-			}
+				bufHdr->tag.forkNum == forkNum[index] &&
+				bufHdr->tag.blockNum >= firstDelBlock[index])
+				InvalidateBuffer(bufHdr); /* releases spinlock */
+			else
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+	} while (nbufs == lengthof(buf_id_array));
 }
 
 /* ---------------------------------------------------------------------
@@ -3016,7 +3021,9 @@ void
 DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
 {
 	int			i,
-				n = 0;
+				n = 0,
+				nbufs,
+				buf_id_array[BUF_ID_ARRAY_SIZE];
 	RelFileNode *nodes;
 	bool		use_bsearch;
 
@@ -3059,47 +3066,53 @@ DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes)
 	if (use_bsearch)
 		pg_qsort(nodes, n, sizeof(RelFileNode), rnode_comparator);
 
-	for (i = 0; i < NBuffers; i++)
+	do
 	{
-		RelFileNode *rnode = NULL;
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		nbufs = CachedBufLookupAll(nodes, nnodes, buf_id_array,
+								   lengthof(buf_id_array));
 
-		/*
-		 * As in DropRelFileNodeBuffers, an unlocked precheck should be safe
-		 * and saves some cycles.
-		 */
-
-		if (!use_bsearch)
+		for (i = 0; i < nbufs; i++)
 		{
-			int			j;
+			RelFileNode *rnode = NULL;
+			BufferDesc	*bufHdr = GetBufferDescriptor(buf_id_array[i]);
+			uint32		buf_state;
 
-			for (j = 0; j < n; j++)
+			/*
+			* As in DropRelFileNodeBuffers, an unlocked precheck should be safe
+			* and saves some cycles.
+			*/
+
+			if (!use_bsearch)
 			{
-				if (RelFileNodeEquals(bufHdr->tag.rnode, nodes[j]))
+				int			j;
+
+				for (j = 0; j < n; j++)
 				{
-					rnode = &nodes[j];
-					break;
+					if (RelFileNodeEquals(bufHdr->tag.rnode, nodes[j]))
+					{
+						rnode = &nodes[j];
+						break;
+					}
 				}
 			}
-		}
-		else
-		{
-			rnode = bsearch((const void *) &(bufHdr->tag.rnode),
-							nodes, n, sizeof(RelFileNode),
-							rnode_comparator);
-		}
+			else
+			{
+				rnode = bsearch((const void *) &(bufHdr->tag.rnode),
+								nodes, n, sizeof(RelFileNode),
+								rnode_comparator);
+			}
 
-		/* buffer doesn't belong to any of the given relfilenodes; skip it */
-		if (rnode == NULL)
-			continue;
+			/* buffer doesn't belong to any of the given relfilenodes; skip it */
+			if (rnode == NULL)
+				continue;
 
-		buf_state = LockBufHdr(bufHdr);
-		if (RelFileNodeEquals(bufHdr->tag.rnode, (*rnode)))
-			InvalidateBuffer(bufHdr);	/* releases spinlock */
-		else
-			UnlockBufHdr(bufHdr, buf_state);
-	}
+			buf_state = LockBufHdr(bufHdr);
+			if (RelFileNodeEquals(bufHdr->tag.rnode, (*rnode)))
+				InvalidateBuffer(bufHdr);	/* releases spinlock */
+			else
+				UnlockBufHdr(bufHdr, buf_state);
+		}
+	} while (nbufs == lengthof(buf_id_array));
 
 	pfree(nodes);
 }
diff --git a/src/backend/storage/buffer/cached_buf.c b/src/backend/storage/buffer/cached_buf.c
new file mode 100644
index 0000000..1e38087
--- /dev/null
+++ b/src/backend/storage/buffer/cached_buf.c
@@ -0,0 +1,638 @@
+/*-------------------------------------------------------------------------
+ *
+ * cached_buf.c
+ *	  routines for mapping relations to the indexes of auxillary cached
+ *	  buffers.
+ *
+ * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/storage/buffer/cached_buf.c
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "storage/bufmgr.h"
+#include "storage/buf_internals.h"
+
+
+/*
+ * Each relation and its buffer information are cached in a hash table
+ * located in shared memory. These cached buffers are chained together
+ * in a doubly-linked list.
+ */
+#define NUM_MAP_PARTITIONS_FOR_REL	128	/* relation-level */
+#define NUM_MAP_PARTITIONS_IN_REL	4	/* block-level */
+#define NUM_MAP_PARTITIONS \
+	(NUM_MAP_PARTITIONS_FOR_REL * NUM_MAP_PARTITIONS_IN_REL)
+#define CACHED_BUF_END_OF_LIST	(-1) /* end of doubly linked list */
+
+/* hash table key */
+typedef struct CachedBufTag
+{
+	RelFileNode		rnode;		/* relation */
+	int			modOfBlockNum;	/* modulo of BlockNumber*/
+} CachedBufTag;
+
+/* entry to the cached buffer hash table */
+typedef struct CachedBufEnt
+{
+	CachedBufTag	key;	/* hash table key */
+	int		head;	/* index of dlist */
+} CachedBufEnt;
+
+/* entry to the doubly-linked list */
+typedef struct BufDlistEnt
+{
+	int		prev;
+	int		next;
+} BufDlistEnt;
+
+/* Locks to be used for the hash table operations */
+typedef struct CombinedLock
+{
+	volatile bool	flag;	/* flag for lookup operation */
+	slock_t		spinLock;	/* spinlock to protect the flag */
+	LWLock		lwLock;	/* LWLock used in lookup */
+} CombinedLock;
+
+/* lock for cached buffer hash table */
+typedef struct CachedBufTableLock
+{
+	CombinedLock	cacheLock[NUM_MAP_PARTITIONS];
+	int		cacheTrancheId;
+} CachedBufTableLock;
+
+static HTAB *CachedBufHash = NULL;
+static BufDlistEnt *BufDlistEntArray = NULL;
+static CachedBufTableLock *CachedBufLockArray = NULL;
+static void CombinedLockInitialize(CombinedLock *lock, int trancheId);
+static uint32 CachedBufTableHashCode(CachedBufTag *tag);
+static CombinedLock *GetCachedBufPartitionLock(CachedBufTag *tag,
+											   uint32 *hashcode);
+static void CombinedLockAcquireSpinLock(CombinedLock *lock);
+static void CombinedLockAcquireLWLock(CombinedLock *lock);
+static void CombinedLockReleaseSpinLock(CombinedLock *lock);
+static void CombinedLockReleaseLWLock(CombinedLock *lock);
+static inline BufDlistEnt *cb_dlist_entry(int buf_id);
+static inline BufDlistEnt *cb_dlist_next(BufDlistEnt *entry);
+static inline BufDlistEnt *cb_dlist_prev(BufDlistEnt *entry);
+static inline bool cb_dlist_is_empty(CachedBufEnt *hash_entry);
+static inline void cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id);
+static inline void cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp);
+
+/*
+ * CachedBufShmemSize
+ * 		Estimate space needed for mapping cached buffer hash table
+ *
+ * 		size of lookup table is the desired hash table size
+ *		(possibly more than NBuffers)
+ */
+Size
+CachedBufShmemSize(void)
+{
+	Size		size = 0;
+
+	/* size of cached buffer lookup table */
+	size = add_size(size, hash_estimate_size(NBuffers +
+											 NUM_MAP_PARTITIONS,
+											 sizeof(CachedBufEnt)));
+
+	/* size of cached buffer dlist entry array */
+	size = add_size(size, mul_size(NBuffers, sizeof(BufDlistEnt)));
+
+	/* size of locks */
+	size = add_size(size, mul_size(NBuffers,
+								   sizeof(CachedBufTableLock)));
+
+	return size;
+}
+
+/* Initialize spinlock and LWLock for cached buffer hash table */
+void
+CombinedLockInitialize(CombinedLock *lock, int trancheId)
+{
+	lock->flag = false;
+	SpinLockInit(&lock->spinLock);
+	LWLockInitialize(&lock->lwLock, trancheId);
+}
+
+/*
+ * InitCachedBufTable
+ *      Initialize the cached buffer hash table and related data
+ *      structures at shared memory initialization.
+ */
+void
+InitCachedBufTable(int size)
+{
+	HASHCTL		info;
+	bool		foundList,
+				foundLock;
+	int		i;
+
+	info.keysize = sizeof(CachedBufTag);
+	info.entrysize = sizeof(CachedBufEnt);
+	info.num_partitions = NUM_MAP_PARTITIONS;
+
+	CachedBufHash = ShmemInitHash("Cached Buffer Lookup Table",
+								  size + NUM_MAP_PARTITIONS,
+								  size + NUM_MAP_PARTITIONS,
+								  &info,
+								  HASH_ELEM | HASH_BLOBS |
+								  HASH_PARTITION);
+
+	BufDlistEntArray = ShmemInitStruct("buffer dlist entry array",
+									   size * sizeof(BufDlistEnt),
+									   &foundList);
+
+	CachedBufLockArray = (CachedBufTableLock *)
+			ShmemInitStruct("cached buffer hash partition lock",
+							size * sizeof(CachedBufTableLock),
+							&foundLock);
+
+	if (!foundList && !foundLock)
+	{
+		CachedBufLockArray->cacheTrancheId = LWLockNewTrancheId();
+
+		for (i = 0; i < NUM_MAP_PARTITIONS; i++)
+			CombinedLockInitialize(&CachedBufLockArray->cacheLock[i],
+								   CachedBufLockArray->cacheTrancheId);
+	}
+	LWLockRegisterTranche(CachedBufLockArray->cacheTrancheId,
+						  "cached_buf_tranche_id");
+
+}
+
+ /*
+  * CachedBufTableHashCode
+  *      Compute the hash code associated with tag
+  *
+  * This must be passed to the insert/lookup/delete routines along with the
+  * tag. We do it like this because the callers need to know the hash code
+  * to determine which partition to lock, and we don't want to do the  hash
+  * computation twice (hash_any is a bit slow).
+  */
+static uint32
+CachedBufTableHashCode(CachedBufTag *tag)
+{
+	return get_hash_value(CachedBufHash, (void *) tag);
+}
+
+/*
+ * GetCachedBufPartitionLock
+ * 		Get lock instance for partition of cached buffer lookup table
+ */
+static CombinedLock *
+GetCachedBufPartitionLock(CachedBufTag *tag, uint32 *hashcode)
+{
+	*hashcode = CachedBufTableHashCode(tag);
+
+	return &CachedBufLockArray->cacheLock[*hashcode % NUM_MAP_PARTITIONS];
+}
+
+/*
+ * CombinedLockAcquireSpinLock
+ *		Acquire spinlock to proceed to inserting/deleting hash
+ *		table entries
+ *
+ * This function waits for a lookup process (if flag is true) to finish,
+ * before reacquring a spinlock.
+ */
+void
+CombinedLockAcquireSpinLock(CombinedLock *lock)
+{
+	SpinLockAcquire(&lock->spinLock);
+
+	while (lock->flag)
+	{
+		SpinLockRelease(&lock->spinLock);
+		LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+		LWLockRelease(&lock->lwLock);
+		SpinLockAcquire(&lock->spinLock);
+	}
+}
+
+/*
+ * CombinedLockAcquireLWLock
+ *		Get LWLock instance for partition of cached buffer lookup table
+ *
+ * To prevent other backend processes from modifying the lookup table,
+ * this function sets the CombinedLock's flag to true.
+ */
+void
+CombinedLockAcquireLWLock(CombinedLock *lock)
+{
+	LWLockAcquire(&lock->lwLock, LW_EXCLUSIVE);
+	SpinLockAcquire(&lock->spinLock);
+	lock->flag = true;
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the spinlock used in insert/delete functions
+ */
+void
+CombinedLockReleaseSpinLock(CombinedLock *lock)
+{
+	SpinLockRelease(&lock->spinLock);
+}
+
+/*
+ * CombinedLockReleaseSpinLock
+ *		Release the LWLock used in lookup function after changing the
+ *		CombinedLock's flag to false.
+ */
+void
+CombinedLockReleaseLWLock(CombinedLock *lock)
+{
+	lock->flag = false;
+	LWLockRelease(&lock->lwLock);
+}
+
+/*
+ * CachedBufTableInsert
+ *		Insert a hash table entry for given tag and buffer ID
+ *
+ * If a hash entry for the tag already exists, only buffer ID is inserted.
+ * Chain the buffer ID to the doubly-linked list.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up or create a hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_ENTER,
+									&found);
+
+	/* If not found, initialize linked list */
+	if (!found)
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+
+	cb_dlist_push_head(hash_entry, buf_id);
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * CachedBufLookup
+ *		Lookup the buffers for the given tag in the cached buffer
+ *		hash table. Insert the buffer ID to the array of buffer
+ *		IDs, and return the total number of buffers to be invalidated.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				int *forknum_indexes, BlockNumber *firstDelBlock,
+				int *buf_id_array, int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry,
+					temp_hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		mod,
+			i,
+			curr_buf_id,
+			new_curr_buf_id,
+			count = 0;
+	bool		target_buf = false;
+
+	for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+	{
+		cb_tag.rnode = rnode;
+		cb_tag.modOfBlockNum = mod;
+
+		combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+		CombinedLockAcquireLWLock(combined_lock);
+
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_FIND,
+										NULL);
+
+		if (!hash_entry)
+		{
+			CombinedLockReleaseLWLock(combined_lock);
+			continue;
+		}
+
+		/* Initial temporary dlist */
+		temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+
+		/* When traversing the main dlist, start from head */
+		curr_buf_id = hash_entry->head;
+
+		while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(curr_buf_id);
+			curr_entry = BufDlistEntArray + curr_buf_id;
+			new_curr_buf_id = curr_entry->next;
+
+			/* Check if it's our target buffer */
+			for (i = 0; i < nforks; i++)
+			{
+				if (bufHdr->tag.forkNum != forkNum[i])
+					continue;
+				else
+				{
+					if (bufHdr->tag.blockNum >= firstDelBlock[i])
+						target_buf = true;
+					break;
+				}
+			}
+
+			if (target_buf)
+			{
+				forknum_indexes[count] = i;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+			}
+			else
+			{
+				/*
+				* It's not the target buffer. Remove the current buffer ID
+				* from the current list of target buffer IDs and store it
+				* to a temporary list.
+				*/
+				cb_dlist_delete(hash_entry, curr_buf_id);
+				cb_dlist_push_head(&temp_hash_entry, curr_buf_id);
+			}
+			/* Move current pointer to next */
+			curr_buf_id = new_curr_buf_id;
+		}
+
+		/* Check if main dlist is now empty */
+		if (cb_dlist_is_empty(hash_entry))
+		{
+			hash_entry->head = temp_hash_entry.head;
+			temp_hash_entry.head = CACHED_BUF_END_OF_LIST;
+		}
+
+		/* If we have a temporary dlist, append it to the main dlist */
+		if (!cb_dlist_is_empty(hash_entry) &&
+			!cb_dlist_is_empty(&temp_hash_entry))
+			cb_dlist_combine(hash_entry, &temp_hash_entry);
+
+		CombinedLockReleaseLWLock(combined_lock);
+	}
+
+	return count;
+}
+
+/*
+ * CachedBufLookupAll
+ *		Lookup all the buffers of specified relations in the cached buffer
+ *		hash table. Store all the buffer IDs to the array, and return
+ *		the total number of buffers to be invalidated.
+ *
+ * This function must hold exclusive LWLock for tag's partition.
+ */
+int
+CachedBufLookupAll(RelFileNode *rnode, int nnodes, int *buf_id_array,
+				   int size)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	BufDlistEnt	*curr_entry = NULL;
+	int		i,
+			mod,
+			curr_buf_id,
+			new_curr_buf_id,
+			count = 0;
+
+	for (i = 0; i < nnodes; i++)
+	{
+		cb_tag.rnode = rnode[i];
+
+		for (mod = 0; mod < NUM_MAP_PARTITIONS_IN_REL; mod++)
+		{
+			cb_tag.modOfBlockNum = mod;
+
+			combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+			CombinedLockAcquireLWLock(combined_lock);
+
+			hash_entry = (CachedBufEnt *)
+				hash_search_with_hash_value(CachedBufHash,
+											(void *) &cb_tag,
+											hashcode,
+											HASH_FIND,
+											NULL);
+
+			if (!hash_entry)
+			{
+				CombinedLockReleaseLWLock(combined_lock);
+				continue;
+			}
+
+			/* When traversing the dlist, start from head */
+			curr_buf_id = hash_entry->head;
+
+			while(curr_buf_id != CACHED_BUF_END_OF_LIST && count < size)
+			{
+				curr_entry = BufDlistEntArray + curr_buf_id;
+				new_curr_buf_id = curr_entry->next;
+				buf_id_array[count] = curr_buf_id;
+				++count;
+				curr_buf_id = new_curr_buf_id; /* Move pointer */
+			}
+
+			CombinedLockReleaseLWLock(combined_lock);
+		}
+	}
+
+	return count;
+}
+
+
+/*
+ * CachedBufTableDelete
+ *		Unlink the buffer ID from the doubly-linked list, then remove
+ *		the hash entry for the given tag if its list is empty.
+ *
+ * This function must hold spin lock.
+ */
+void
+CachedBufTableDelete(RelFileNode *rnode, BlockNumber *blockNum, int buf_id)
+{
+	CachedBufTag	cb_tag;
+	uint32		hashcode;
+	CombinedLock	*combined_lock;
+	CachedBufEnt	*hash_entry;
+	bool		found;
+
+	cb_tag.rnode = *rnode;
+	cb_tag.modOfBlockNum = *blockNum % NUM_MAP_PARTITIONS_IN_REL;
+
+	combined_lock = GetCachedBufPartitionLock(&cb_tag, &hashcode);
+	CombinedLockAcquireSpinLock(combined_lock);
+
+	/* look up hash table entry */
+	hash_entry = (CachedBufEnt *)
+		hash_search_with_hash_value(CachedBufHash,
+									(void *) &cb_tag,
+									hashcode,
+									HASH_FIND,
+									&found);
+
+	if (!found)		/* tag not found, nothing to do */
+	{
+		CombinedLockReleaseSpinLock(combined_lock);
+		return;
+	}
+
+	cb_dlist_delete(hash_entry, buf_id);
+
+	/*
+	 * If there's no more cached elements for the given tag,
+	 * remove the hash entry.
+	 */
+	if (cb_dlist_is_empty(hash_entry))
+	{
+		hash_entry = (CachedBufEnt *)
+			hash_search_with_hash_value(CachedBufHash,
+										(void *) &cb_tag,
+										hashcode,
+										HASH_REMOVE,
+										NULL);
+
+		if (!hash_entry)
+			elog(ERROR, "cached buffer hash table corrupted");
+	}
+
+	CombinedLockReleaseSpinLock(combined_lock);
+}
+
+/*
+ * inline functions for the doubly-linked list of cached buffers
+ */
+/* Return the dlist entry */
+static inline BufDlistEnt *
+cb_dlist_entry(int buf_id)
+{
+	return BufDlistEntArray + buf_id;
+}
+
+/* Return the next entry */
+static inline BufDlistEnt *
+cb_dlist_next(BufDlistEnt *entry)
+{
+	return entry->next == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->next);
+}
+
+/* Return the prev entry */
+static inline BufDlistEnt *
+cb_dlist_prev(BufDlistEnt *entry)
+{
+	return entry->prev == CACHED_BUF_END_OF_LIST ?
+							NULL : cb_dlist_entry(entry->prev);
+}
+
+/* Return if dlist is empty */
+static inline bool
+cb_dlist_is_empty(CachedBufEnt *hash_entry)
+{
+	return hash_entry->head == CACHED_BUF_END_OF_LIST;
+}
+
+/* Push to head of dlist */
+static inline void
+cb_dlist_push_head(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*new_entry = cb_dlist_entry(buf_id);
+	new_entry->next = hash_entry->head;
+
+	if (cb_dlist_is_empty(hash_entry))
+		new_entry->prev = buf_id;
+	else
+	{
+		BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+		new_entry->prev = head_entry->prev;
+		cb_dlist_next(new_entry)->prev = buf_id;
+	}
+	hash_entry->head = buf_id;
+}
+
+/* Remove the buffer ID from dlist */
+static inline void
+cb_dlist_delete(CachedBufEnt *hash_entry, int buf_id)
+{
+	BufDlistEnt	*curr_entry = cb_dlist_entry(buf_id);
+	BufDlistEnt	*head_entry = cb_dlist_entry(hash_entry->head);
+	BufDlistEnt	*tail_entry = cb_dlist_entry(head_entry->prev);
+	BufDlistEnt	*next_entry = cb_dlist_next(curr_entry);
+	BufDlistEnt	*prev_entry = cb_dlist_prev(curr_entry);
+
+	/* If only one entry is in the list */
+	if (head_entry == tail_entry)
+	{
+		hash_entry->head = CACHED_BUF_END_OF_LIST;
+		return;
+	}
+
+	/*
+	 * If there is a next entry, update its prev field.
+	 * Otherwise, current entry is at tail (but not at head),
+	 * so update the new tail.
+	 */
+	if (next_entry != NULL)
+		next_entry->prev = curr_entry->prev;
+	else
+		head_entry->prev = curr_entry->prev;
+
+	/*
+	 * If the previous entry is not the tail entry, update its
+	 * next field. Otherwise, current entry is at head (but not
+	 * at tail). Update the new head entry and its tail pointer.
+	 */
+	if (prev_entry != tail_entry)
+		prev_entry->next = curr_entry->next;
+	else
+		hash_entry->head = curr_entry->next;
+}
+
+/* Append head of temporary dlist to main dlist */
+static inline void
+cb_dlist_combine(CachedBufEnt *main, CachedBufEnt *temp)
+{
+	BufDlistEnt	*main_head_entry = cb_dlist_entry(main->head);
+	BufDlistEnt	*temp_head_entry = cb_dlist_entry(temp->head);
+	int	main_tail = main_head_entry->prev;
+	int	temp_tail = temp_head_entry->prev;
+	BufDlistEnt	*main_tail_entry = cb_dlist_entry(main_tail);
+
+	/* Append the temporary dlist to main dlist */
+	main_tail_entry->next = temp->head;
+	temp_head_entry->prev = main_tail;
+	main_head_entry->prev = temp_tail;
+
+	/* Clear the head of temporary dlist */
+	temp->head = CACHED_BUF_END_OF_LIST;
+}
diff --git a/src/include/storage/buf_internals.h b/src/include/storage/buf_internals.h
index e57f84e..1d9bf54 100644
--- a/src/include/storage/buf_internals.h
+++ b/src/include/storage/buf_internals.h
@@ -338,4 +338,20 @@ extern void DropRelFileNodeLocalBuffers(RelFileNode rnode, ForkNumber forkNum,
 extern void DropRelFileNodeAllLocalBuffers(RelFileNode rnode);
 extern void AtEOXact_LocalBuffers(bool isCommit);
 
+/* in cached_buf.c */
+/* size of array of linked buffer ID's of target relation */
+#define BUF_ID_ARRAY_SIZE	100
+
+extern Size CachedBufShmemSize(void);
+extern void InitCachedBufTable(int size);
+extern void CachedBufTableInsert(RelFileNode *rnode, BlockNumber *blockNum,
+								 int buf_id);
+extern int CachedBufLookup(RelFileNode rnode, ForkNumber *forkNum, int nforks,
+				  int *forknum_indexes, BlockNumber *firstDelBlock,
+				  int *buf_id_array, int size);
+extern int CachedBufLookupAll(RelFileNode *rnode, int nnodes,
+							  int *buf_id_array, int size);
+extern void CachedBufTableDelete(RelFileNode *rnode,  BlockNumber *blockNum,
+								 int buf_id);
+
 #endif							/* BUFMGR_INTERNALS_H */
-- 
1.8.3.1

From 20b620d4548acc344d9ad065db42e68cc0ce5f14 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k,jamison@fujitsu.com>
Date: Thu, 27 Aug 2020 08:09:39 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 125 +++++++++++++++++++++++++++---------
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   5 +-
 3 files changed, 98 insertions(+), 34 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..95b3c7d 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_THRESHOLD		500	/* NBuffers divided by 2 */
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2979,11 +2981,14 @@ BufferGetLSNAtomic(Buffer buffer)
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,44 +3002,102 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/*
+	 * Proceed to the normal buffer invalidation process. We only speedup
+	 * this path during recovery, because that's the only timing when we
+	 * can get a valid cached value of blocks for relation. See comment
+	 * in smgrnblocks() in smgr.c.
+	 */
+	if (!InRecovery)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		for (i = 0; i < NBuffers; i++)
+		{
+			BufferDesc *bufHdr = GetBufferDescriptor(i);
+			uint32		buf_state;
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag before
+			 * we attempt to lock the buffer; this saves a lot of lock
+			 * acquisitions in typical cases.  It should be safe because the
+			 * caller must have AccessExclusiveLock on the relation, or some other
+			 * reason to be certain that no one is loading new pages of the rel
+			 * into the buffer pool.  (Otherwise we might well miss such pages
+			 * entirely.)  Therefore, while the tag might be changing while we
+			 * look at it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible, and
+			 * false positives are safe because we'll recheck after getting the
+			 * buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but the
+			 * incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
 
-		buf_state = LockBufHdr(bufHdr);
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
+			for (j = 0; j < nforks; j++)
+			{
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+				{
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+					break;
+				}
+			}
+			if (j >= nforks)
+				UnlockBufHdr(bufHdr, buf_state);
+		}
+	}
+	else
+	{
+		BufferTag	newTag;			/* identity of requested block */
+		uint32		newHash;		/* hash value for newTag */
+		LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+		BlockNumber 	reln_nblocks;
+
+		for (i = 0; i < nforks; i++)
 		{
-			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+			/* Get the number of blocks for the supplied relation fork */
+			reln_nblocks = smgrnblocks(smgr_reln, forkNum[i]);
+
+			/* create a tag so we can lookup the buffer */
+			INIT_BUFFERTAG(newTag, rnode.node, forkNum[i], reln_nblocks);
+
+			/* determine its hash code and partition lock ID */
+			newHash = BufTableHashCode(&newTag);
+			newPartitionLock = BufMappingPartitionLock(newHash);
+
+			if (((int)reln_nblocks) < BUF_DROP_THRESHOLD)
 			{
-				InvalidateBuffer(bufHdr);	/* releases spinlock */
-				break;
+				for (j = 0; j < reln_nblocks; j++)
+				{
+					BufferDesc	*bufHdr;
+					uint32		buf_state;
+					int		buf_id;
+
+					/* Check that it is in the buffer pool */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum >= firstDelBlock[j])
+						InvalidateBuffer(bufHdr); /* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
 			}
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
 	}
 }
 
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..da3104c 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -201,9 +201,10 @@ extern BlockNumber RelationGetNumberOfBlocksInFork(Relation relation,
 												   ForkNumber forkNum);
 extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
-extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
+extern void FlushRelationsAllBuffers(struct SMgrRelationData
+ **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 25cac32ee1561c27a0a5eee5ff929d9c44bb1ffc Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 2 Sep 2020 02:57:26 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 148 ++++++++++++++++++++++++++++--------
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 119 insertions(+), 33 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..2b3f08c 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(NBuffers / 2) 	/* NBuffers divided by 2 */
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2979,11 +2981,17 @@ BufferGetLSNAtomic(Buffer buffer)
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	int			k;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,44 +3005,122 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/*
+	 * Proceed to the normal buffer invalidation process. We only speedup
+	 * this path during recovery, because that's the only timing when we
+	 * can get a valid cached value of blocks for relation. See comment
+	 * in smgrnblocks() in smgr.c.
+	 */
+	if (!InRecovery)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		for (i = 0; i < NBuffers; i++)
+		{
+			bufHdr = GetBufferDescriptor(i);
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag before
+			 * we attempt to lock the buffer; this saves a lot of lock
+			 * acquisitions in typical cases.  It should be safe because the
+			 * caller must have AccessExclusiveLock on the relation, or some other
+			 * reason to be certain that no one is loading new pages of the rel
+			 * into the buffer pool.  (Otherwise we might well miss such pages
+			 * entirely.)  Therefore, while the tag might be changing while we
+			 * look at it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible, and
+			 * false positives are safe because we'll recheck after getting the
+			 * buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but the
+			 * incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
 
-		buf_state = LockBufHdr(bufHdr);
+			buf_state = LockBufHdr(bufHdr);
+
+			for (j = 0; j < nforks; j++)
+			{
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+				{
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+					break;
+				}
+			}
+			if (j >= nforks)
+				UnlockBufHdr(bufHdr, buf_state);
+		}
+	}
+	else
+	{
+		BufferTag	newTag;			/* identity of requested block */
+		uint32		newHash;		/* hash value for newTag */
+		LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+		BlockNumber 	reln_nblocks;
 
-		for (j = 0; j < nforks; j++)
+		for (i = 0; i < nforks; i++)
 		{
-			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+			/* Get the number of blocks for the supplied relation fork */
+			reln_nblocks = smgrnblocks(smgr_reln, forkNum[i]);
+
+			/* create a tag so we can lookup the buffer */
+			INIT_BUFFERTAG(newTag, rnode.node, forkNum[i], reln_nblocks);
+
+			/* determine its hash code and partition lock ID */
+			newHash = BufTableHashCode(&newTag);
+			newPartitionLock = BufMappingPartitionLock(newHash);
+
+			if (((int)reln_nblocks) < BUF_DROP_FULLSCAN_THRESHOLD)
 			{
-				InvalidateBuffer(bufHdr);	/* releases spinlock */
-				break;
+				for (j = 0; j < reln_nblocks; j++)
+				{
+					int		buf_id;
+
+					/* Check that it is in the buffer pool */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum >= firstDelBlock[j])
+						InvalidateBuffer(bufHdr); /* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
 			}
+			else
+			{
+				for (j = BUF_DROP_FULLSCAN_THRESHOLD; j < NBuffers; j++)
+				{
+					bufHdr = GetBufferDescriptor(j);
+
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum >= firstDelBlock[j])
+					{
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+						break;
+					}
+				}
+			}
+
+			if (i >= nforks)
+				UnlockBufHdr(bufHdr, buf_state);
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
 	}
 }
 
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 7556544fbbf4e06e94f24f7120437dd7f0b966d4 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 2 Sep 2020 02:57:26 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 144 ++++++++++++++++++++++++++++--------
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 115 insertions(+), 33 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..3dadb83 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(NBuffers / 2)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2979,11 +2981,16 @@ BufferGetLSNAtomic(Buffer buffer)
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,44 +3004,119 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/*
+	 * Proceed to the normal buffer invalidation process. We only speedup
+	 * this path during recovery, because that's the only timing when we
+	 * can get a valid cached value of blocks for relation. See comment
+	 * in smgrnblocks() in smgr.c.
+	 */
+	if (!InRecovery)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		for (i = 0; i < NBuffers; i++)
+		{
+			bufHdr = GetBufferDescriptor(i);
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag before
+			 * we attempt to lock the buffer; this saves a lot of lock
+			 * acquisitions in typical cases.  It should be safe because the
+			 * caller must have AccessExclusiveLock on the relation, or some other
+			 * reason to be certain that no one is loading new pages of the rel
+			 * into the buffer pool.  (Otherwise we might well miss such pages
+			 * entirely.)  Therefore, while the tag might be changing while we
+			 * look at it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible, and
+			 * false positives are safe because we'll recheck after getting the
+			 * buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but the
+			 * incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
 
-		buf_state = LockBufHdr(bufHdr);
+			buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
+			for (j = 0; j < nforks; j++)
+			{
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+				{
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+					break;
+				}
+			}
+			if (j >= nforks)
+				UnlockBufHdr(bufHdr, buf_state);
+		}
+	}
+	else
+	{
+		for (i = 0; i < nforks; i++)
 		{
-			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+			BlockNumber 	nblocks;
+
+			/* Get the number of blocks for the supplied relation fork */
+			nblocks = smgrnblocks(smgr_reln, forkNum[i]);
+
+			Assert(BlockNumberIsValid(nblocks));
+
+			if (((int)nblocks) < BUF_DROP_FULLSCAN_THRESHOLD)
 			{
-				InvalidateBuffer(bufHdr);	/* releases spinlock */
-				break;
+				for (j = 0; j < (int)nblocks; j++)
+				{
+					int		buf_id;
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], firstDelBlock[j]);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum >= firstDelBlock[j])
+						InvalidateBuffer(bufHdr); /* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+			}
+			else
+			{
+				for (j = BUF_DROP_FULLSCAN_THRESHOLD; j < NBuffers; j++)
+				{
+					bufHdr = GetBufferDescriptor(j);
+
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum >= firstDelBlock[j])
+						InvalidateBuffer(bufHdr); /* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
 			}
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
 	}
 }
 
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 83d01f27df5f6128f5abadac501d76a282c4cd36 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 173 ++++++++++++++++++++++++++++++------
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 146 insertions(+), 31 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..01ea4d5 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2979,65 +2983,176 @@ BufferGetLSNAtomic(Buffer buffer)
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			buf_num;
+	int			fork_num;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (fork_num = 0; fork_num < nforks; fork_num++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[fork_num],
+											firstDelBlock[fork_num]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/*
+	 * We only speedup this path during recovery, because that's the only
+	 * timing when we can get a valid cached value of blocks for relation.
+	 * See comment in smgrnblocks() in smgr.c. Otherwise, proceed to usual
+	 * buffer invalidation process (scanning of whole shared buffers).
+	 */
+	if (InRecovery)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		for (fork_num = 0; fork_num < nforks; fork_num++)
+		{
+			BlockNumber 	nblocks;
+
+			/* Get the number of blocks for the supplied relation's fork */
+			nblocks = smgrnblocks(smgr_reln, forkNum[fork_num]);
+			Assert(BlockNumberIsValid(nblocks));
+
+			if (nblocks < BUF_DROP_FULLSCAN_THRESHOLD)
+			{
+				BlockNumber		block_num;
+				for (block_num = 0; block_num < nblocks; block_num++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[fork_num],
+								   firstDelBlock[fork_num]);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+
+					if (buf_id < 0)
+					{
+						LWLockRelease(newPartitionLock);
+						continue;
+					}
+					LWLockRelease(newPartitionLock);
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					/*
+					 * We can make this a tad faster by prechecking the buffer tag before
+					 * we attempt to lock the buffer; this saves a lot of lock
+					 * acquisitions in typical cases.  It should be safe because the
+					 * caller must have AccessExclusiveLock on the relation, or some other
+					 * reason to be certain that no one is loading new pages of the rel
+					 * into the buffer pool.  (Otherwise we might well miss such pages
+					 * entirely.)  Therefore, while the tag might be changing while we
+					 * look at it, it can't be changing *to* a value we care about, only
+					 * *away* from such a value.  So false negatives are impossible, and
+					 * false positives are safe because we'll recheck after getting the
+					 * buffer lock.
+					 *
+					 * We could check forkNum and blockNum as well as the rnode, but the
+					 * incremental win from doing so seems small.
+					 */
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[fork_num] &&
+						bufHdr->tag.blockNum >= firstDelBlock[fork_num])
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+				if (block_num >= nblocks)
+				{
+					DropRelFileNodeBuffersOfFork(rnode.node, forkNum[fork_num],
+												firstDelBlock[fork_num]);
+				}
+			}
+			else
+			{
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[fork_num],
+											 firstDelBlock[fork_num]);
+			}
+		}
+		return;
+	}
+	for (buf_num = 0; buf_num < NBuffers; buf_num++)
+	{
+		bufHdr = GetBufferDescriptor(buf_num);
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
 		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
 			continue;
 
 		buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
+		for (fork_num = 0; fork_num < nforks; fork_num++)
 		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+				bufHdr->tag.forkNum == forkNum[fork_num] &&
+				bufHdr->tag.blockNum >= firstDelBlock[fork_num])
 			{
 				InvalidateBuffer(bufHdr);	/* releases spinlock */
 				break;
 			}
 		}
-		if (j >= nforks)
+		if (fork_num >= nforks)
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		each fork of the specified relation.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			buf_num;
+
+	for (buf_num = 0; buf_num < NBuffers; buf_num++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(buf_num);
+		uint32		buf_state;
+
+		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode))
+			continue;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
 			UnlockBufHdr(bufHdr, buf_state);
 	}
 }
 
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From f670d8135cb220e96eac8037912a92c4a8eb3eb1 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

Added ereport/elog for debugging
---
 src/backend/storage/buffer/bufmgr.c | 182 ++++++++++++++++++++++++++++++------
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 155 insertions(+), 31 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..bd1d89b 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2979,65 +2983,185 @@ BufferGetLSNAtomic(Buffer buffer)
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
-	int			i;
-	int			j;
+	int			buf_num;
+	int			fork_num;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
 	{
 		if (rnode.backend == MyBackendId)
 		{
-			for (j = 0; j < nforks; j++)
-				DropRelFileNodeLocalBuffers(rnode.node, forkNum[j],
-											firstDelBlock[j]);
+			for (fork_num = 0; fork_num < nforks; fork_num++)
+				DropRelFileNodeLocalBuffers(rnode.node, forkNum[fork_num],
+											firstDelBlock[fork_num]);
 		}
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/*
+	 * We only speedup this path during recovery, because that's the only
+	 * timing when we can get a valid cached value of blocks for relation.
+	 * See comment in smgrnblocks() in smgr.c. Otherwise, proceed to usual
+	 * buffer invalidation process (scanning of whole shared buffers).
+	 */
+	if (InRecovery)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		for (fork_num = 0; fork_num < nforks; fork_num++)
+		{
+			BlockNumber 	nblocks;
+
+			/* Get the number of blocks for the supplied relation's fork */
+			nblocks = smgrnblocks(smgr_reln, forkNum[fork_num]);
+			Assert(BlockNumberIsValid(nblocks));
+
+			if (nblocks < BUF_DROP_FULLSCAN_THRESHOLD)
+			{
+				BlockNumber		block_num;
+
+				for (block_num = 0; block_num <= nblocks; block_num++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag with respect to the block so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[fork_num],
+								   firstDelBlock[block_num]);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+
+					if (buf_id < 0)
+					{
+						LWLockRelease(newPartitionLock);
+						continue;
+					}
+					LWLockRelease(newPartitionLock);
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					/*
+					 * We can make this a tad faster by prechecking the buffer tag before
+					 * we attempt to lock the buffer; this saves a lot of lock
+					 * acquisitions in typical cases.  It should be safe because the
+					 * caller must have AccessExclusiveLock on the relation, or some other
+					 * reason to be certain that no one is loading new pages of the rel
+					 * into the buffer pool.  (Otherwise we might well miss such pages
+					 * entirely.)  Therefore, while the tag might be changing while we
+					 * look at it, it can't be changing *to* a value we care about, only
+					 * *away* from such a value.  So false negatives are impossible, and
+					 * false positives are safe because we'll recheck after getting the
+					 * buffer lock.
+					 *
+					 * We could check forkNum and blockNum as well as the rnode, but the
+					 * incremental win from doing so seems small.
+					 */
+					if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+						continue;
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[fork_num] &&
+						bufHdr->tag.blockNum >= firstDelBlock[block_num])
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+				/*
+				 * We've invalidated the nblocks already. Scan the shared buffers
+				 * for each fork.
+				 */
+				if (block_num > nblocks)
+				{
+					DropRelFileNodeBuffersOfFork(rnode.node, forkNum[fork_num],
+												 firstDelBlock[fork_num]);
+				}
+			}
+			else
+			{
+				/*
+				 * Relation fork is bigger than the threshold. Scan the shared buffers
+				 * for each fork.
+				 */
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[fork_num],
+											 firstDelBlock[fork_num]);
+			}
+		}
+		return;
+	}
+	for (buf_num = 0; buf_num < NBuffers; buf_num++)
+	{
+		bufHdr = GetBufferDescriptor(buf_num);
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
 		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
 			continue;
 
 		buf_state = LockBufHdr(bufHdr);
 
-		for (j = 0; j < nforks; j++)
+		for (fork_num = 0; fork_num < nforks; fork_num++)
 		{
 			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+				bufHdr->tag.forkNum == forkNum[fork_num] &&
+				bufHdr->tag.blockNum >= firstDelBlock[fork_num])
 			{
 				InvalidateBuffer(bufHdr);	/* releases spinlock */
 				break;
 			}
 		}
-		if (j >= nforks)
+		if (fork_num >= nforks)
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		each fork of the specified relation.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			buf_num;
+
+	for (buf_num = 0; buf_num < NBuffers; buf_num++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(buf_num);
+		uint32		buf_state;
+
+		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode))
+			continue;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
 			UnlockBufHdr(bufHdr, buf_state);
 	}
 }
 
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From e59bb976b1804ce6f2a2436b176deb3309bf49ce Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Speedup dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 126 ++++++++++++++++++++++++++++++++++--
 src/backend/storage/smgr/smgr.c     |   9 ++-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 128 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..6494f9f 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2972,18 +2976,27 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  See comment in
+ *		smgrnblocks() in smgr.c.  In addition, it is safe to do this since
+ *		there are no other processes but the startup process that changes
+ *		the relation size during recovery. Otherwise, or if not in recovery,
+ *		proceed to usual invalidation process, where it sequentially
+ *		searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,10 +3010,78 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	if (InRecovery)
+	{
+		BlockNumber		nblocks = 0;
+
+		/* Get the total number of blocks for the supplied relation's fork */
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		block = smgrnblocks(smgr_reln, forkNum[j]);
+			nblocks += block;
+		}
+
+		for (j = 0; j < nforks; j++)
+		{
+			/*
+			 * Do explicit hashtable probe iff the ratio of total number of buffers to be
+			 * truncated against NBuffers is less than the threshold for full-scanning of
+			 * buffer pool. IOW, relation is small enough for its buffers to be removed.
+			 */
+			if ((nblocks / (uint32)NBuffers) < BUF_DROP_FULLSCAN_THRESHOLD &&
+				BlockNumberIsValid(nblocks))
+			{
+				BlockNumber		cur_blk;
+
+				for (cur_blk = firstDelBlock[j]; cur_blk < nblocks; cur_blk++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], cur_blk);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					if (buf_id < 0)
+						continue;
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum == cur_blk)
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+			}
+			else
+			{
+				/*
+				 * Relation is larger than the threshold. Execute full scan of
+				 * buffer pool for each fork.
+				 */
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[j],
+											 firstDelBlock[j]);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3038,6 +3119,37 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 	}
 }
 
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		the specified relation's fork.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(i);
+		uint32		buf_state;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..450819f 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension while recovering.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
@@ -583,7 +590,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 62fab3f5ad7adfa64a0a0732b7983f9ab334a1f0 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize dropping of relation buffers during recovery

---
 src/backend/storage/buffer/bufmgr.c | 120 +++++++++++++++++++++++++++++++++---
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 115 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..11f450b 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2972,18 +2976,27 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  See comment in
+ *		smgrnblocks() in smgr.c.  In addition, it is safe to do this since
+ *		there are no other processes but the startup process that changes
+ *		the relation size during recovery.  Otherwise, or if not in
+ *		recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,10 +3010,72 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	if (InRecovery)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			/* Get the total number of blocks for the supplied relation's fork */
+			BlockNumber		nblocks;
+			nblocks = smgrnblocks(smgr_reln, forkNum[j]) - firstDelBlock[j];
+
+			/*
+			 * Do explicit hashtable probe iff the ratio of total number of buffers to be
+			 * truncated against NBuffers is less than the threshold for full-scanning of
+			 * buffer pool. IOW, relation is small enough for its buffers to be removed.
+			 */
+			if (nblocks < BUF_DROP_FULLSCAN_THRESHOLD)
+			{
+				BlockNumber		cur_blk;
+
+				for (cur_blk = firstDelBlock[j]; cur_blk < nblocks; cur_blk++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], cur_blk);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					if (buf_id < 0)
+						continue;
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum == cur_blk)
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+			}
+			else
+			{
+				/*
+				 * Relation is larger than the threshold. Execute full scan of
+				 * buffer pool for each fork.
+				 */
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[j],
+											 firstDelBlock[j]);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3038,6 +3113,37 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 	}
 }
 
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		the specified relation's fork.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(i);
+		uint32		buf_state;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 7b3fc6096effb862677e868699f33759bf0ff087 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating of cached blocks in smgrextend during
 recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 4b051a1aae7ad344269ca81322b956e24158a881 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork by calling smgrnblocks(), and it's safe
because there are no other processes but the startup process that
changes the relation size during recovery.  Otherwise, or if not in
recovery, proceed to sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 125 ++++++++++++++++++++++++++++++++++--
 src/backend/storage/smgr/smgr.c     |   2 +-
 src/include/storage/bufmgr.h        |   2 +-
 3 files changed, 120 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index a2a963b..7c2c196 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2972,18 +2976,27 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  See comment in
+ *		smgrnblocks() in smgr.c.  In addition, it is safe to do this since
+ *		there are no other processes but the startup process that changes
+ *		the relation size during recovery.  Otherwise, or if not in
+ *		recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2997,10 +3010,77 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	if (InRecovery)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber	nTotalBlocks; /* total nblocks */
+			BlockNumber nBlocksToInvalidate; /* total nblocks to be invalidated */
+
+			/* Get the total number of blocks for the supplied relation's fork */
+			nTotalBlocks = smgrnblocks(smgr_reln, forkNum[j]);
+
+			/* Get the total number of blocks to be invalidated for the specified fork */
+			nBlocksToInvalidate = nTotalBlocks - firstDelBlock[j];
+
+			/*
+			 * Do explicit hashtable probe iff the ratio of total number of buffers to be
+			 * truncated against NBuffers is less than the threshold for full-scanning of
+			 * buffer pool. IOW, relation is small enough for its buffers to be removed.
+			 */
+			if (nBlocksToInvalidate < BUF_DROP_FULLSCAN_THRESHOLD)
+			{
+				BlockNumber		curBlock;
+
+				for (curBlock = firstDelBlock[j]; curBlock < nTotalBlocks; curBlock++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], curBlock);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					if (buf_id < 0)
+						continue;
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum == curBlock)
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+			}
+			else
+			{
+				/*
+				 * Relation is larger than the threshold. Execute full scan of
+				 * buffer pool for each fork.
+				 */
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[j],
+											 firstDelBlock[j]);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3038,6 +3118,37 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 	}
 }
 
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		the specified relation's fork.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(i);
+		uint32		buf_state;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..5238c6c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -583,7 +583,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From 7b3fc6096effb862677e868699f33759bf0ff087 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating of cached blocks in smgrextend during
 recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 005814c3521df425204fa26286c3a4bb0804fe77 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork by calling smgrnblocks(), and it's safe
because there are no other processes but the startup process that
changes the relation size during recovery.  Otherwise, or if not in
recovery, proceed to sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 127 ++++++++++++++++++++++++++++++++++--
 src/backend/storage/smgr/smgr.c     |  36 +++++++++-
 src/include/storage/bufmgr.h        |   2 +-
 src/include/storage/smgr.h          |   1 +
 4 files changed, 157 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..8cb2209 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -473,6 +475,8 @@ static BufferDesc *BufferAlloc(SMgrRelation smgr,
 							   BufferAccessStrategy strategy,
 							   bool *foundPtr);
 static void FlushBuffer(BufferDesc *buf, SMgrRelation reln);
+static void DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+										 BlockNumber firstDelBlock);
 static void AtProcExit_Buffers(int code, Datum arg);
 static void CheckForBufferLeaks(void);
 static int	rnode_comparator(const void *p1, const void *p2);
@@ -2965,18 +2969,27 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  See comment in
+ *		smgrnblocks() in smgr.c.  In addition, it is safe to do this since
+ *		there are no other processes but the startup process that changes
+ *		the relation size during recovery.  Otherwise, or if not in
+ *		recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2990,10 +3003,79 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	if (InRecovery)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber	nTotalBlocks; /* total nblocks */
+			BlockNumber nBlocksToInvalidate; /* total nblocks to be invalidated */
+
+			/* Get the total number of blocks for the supplied relation's fork */
+			nTotalBlocks = smgrcachednblocks(smgr_reln, forkNum[j]);
+
+			/* Get the total number of blocks to be invalidated for the specified fork */
+			nBlocksToInvalidate = nTotalBlocks - firstDelBlock[j];
+
+			/*
+			 * Do explicit hashtable probe if the blocks to be invalidated have not been
+			 * invalidated yet as well as if the ratio of total number of buffers to be
+			 * truncated against NBuffers is less than the threshold for full-scanning of
+			 * buffer pool. IOW, relation is small enough for its buffers to be removed.
+			 */
+			if (BlockNumberIsValid(nTotalBlocks) &&
+				nBlocksToInvalidate < BUF_DROP_FULLSCAN_THRESHOLD)
+			{
+				BlockNumber		curBlock;
+
+				for (curBlock = firstDelBlock[j]; curBlock < nTotalBlocks; curBlock++)
+				{
+					uint32		newHash;		/* hash value for newTag */
+					BufferTag	newTag;			/* identity of requested block */
+					LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+					int		buf_id;
+
+					/* create a tag so we can lookup the buffer */
+					INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], curBlock);
+
+					/* determine its hash code and partition lock ID */
+					newHash = BufTableHashCode(&newTag);
+					newPartitionLock = BufMappingPartitionLock(newHash);
+
+					/* Check that it is in the buffer pool. If not, do nothing */
+					LWLockAcquire(newPartitionLock, LW_SHARED);
+					buf_id = BufTableLookup(&newTag, newHash);
+					LWLockRelease(newPartitionLock);
+
+					if (buf_id < 0)
+						continue;
+
+					bufHdr = GetBufferDescriptor(buf_id);
+
+					buf_state = LockBufHdr(bufHdr);
+
+					if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+						bufHdr->tag.forkNum == forkNum[j] &&
+						bufHdr->tag.blockNum == curBlock)
+						InvalidateBuffer(bufHdr);	/* releases spinlock */
+					else
+						UnlockBufHdr(bufHdr, buf_state);
+				}
+			}
+			else
+			{
+				/*
+				 * Relation is larger than the threshold. Execute full scan of
+				 * buffer pool for each fork.
+				 */
+				DropRelFileNodeBuffersOfFork(rnode.node, forkNum[j],
+											 firstDelBlock[j]);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3031,6 +3113,37 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 	}
 }
 
+
+/* -----------------------------------------------------------------
+ *		DropRelFileNodeBuffersOfFork
+ *
+ *		This function removes from the buffer pool the pages for
+ *		the specified relation's fork.
+ * -----------------------------------------------------------------
+ */
+static void
+DropRelFileNodeBuffersOfFork(RelFileNode rnode, ForkNumber forkNum,
+							 BlockNumber firstDelBlock)
+{
+	int			i;
+
+	for (i = 0; i < NBuffers; i++)
+	{
+		BufferDesc	*bufHdr = GetBufferDescriptor(i);
+		uint32		buf_state;
+
+		buf_state = LockBufHdr(bufHdr);
+
+		if (RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
+			bufHdr->tag.forkNum == forkNum &&
+			bufHdr->tag.blockNum >= firstDelBlock)
+			InvalidateBuffer(bufHdr);	/* releases spinlock */
+		else
+			UnlockBufHdr(bufHdr, buf_state);
+	}
+}
+
+
 /* ---------------------------------------------------------------------
  *		DropRelFileNodesAllBuffers
  *
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..023f809 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -565,6 +565,40 @@ smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 }
 
 /*
+ *	smgrcachednblocks() -- Calculate the number of blocks that are cached in
+ *					 the supplied relation.
+ *
+ * It is equivalent to calling smgrnblocks, but only used in recovery for now
+ * when DropRelFileNodeBuffers() is called, to ensure that only cached value
+ * is used, which is always valid.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not available
+ */
+BlockNumber
+smgrcachednblocks(SMgrRelation reln, ForkNumber forknum)
+{
+	BlockNumber result;
+
+	/*
+	 * For now, we only use cached values in recovery due to lack of a shared
+	 * invalidation mechanism for changes in file size.
+	 */
+	if (InRecovery)
+	{
+		if (reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+			return reln->smgr_cached_nblocks[forknum];
+		else
+			return InvalidBlockNumber;
+	}
+
+	result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
+
+	reln->smgr_cached_nblocks[forknum] = result;
+
+	return result;
+}
+
+/*
  *	smgrtruncate() -- Truncate the given forks of supplied relation to
  *					  each specified numbers of blocks
  *
@@ -583,7 +617,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..fbb7a4a 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -99,6 +99,7 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrcachednblocks(SMgrRelation reln, ForkNumber forknum);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 5f3cef6674749b187054c5a9f2e7aae06001b536 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating blocks in smgrextend() during recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From c520ab04cbbe705c9a2d55c0575b2a6b84b7ced5 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork by calling smgrcachednblocks(), and it's
safe because there are no other processes but the startup process
that changes the relation size during recovery.  Otherwise, or if
not in recovery, proceed to sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 145 +++++++++++++++++++++++++++---------
 src/backend/storage/smgr/smgr.c     |  25 ++++++-
 src/include/storage/bufmgr.h        |   2 +-
 src/include/storage/smgr.h          |   1 +
 4 files changed, 137 insertions(+), 36 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..d44686e 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 500)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2965,18 +2967,28 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  See comment in
+ *		smgrnblocks() in smgr.c.  In addition, it is safe to do this since
+ *		there are no other processes but the startup process that changes
+ *		the relation size during recovery.  Otherwise, or if not in
+ *		recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BlockNumber	nTotalBlocks;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2990,44 +3002,109 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
-	for (i = 0; i < NBuffers; i++)
+	/* get the total number of blocks for the supplied relation */
+	for (j = 0; j < nforks; j++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		BlockNumber	nForkBlocks; /* nblocks for a relation's fork */
 
-		/*
-		 * We can make this a tad faster by prechecking the buffer tag before
-		 * we attempt to lock the buffer; this saves a lot of lock
-		 * acquisitions in typical cases.  It should be safe because the
-		 * caller must have AccessExclusiveLock on the relation, or some other
-		 * reason to be certain that no one is loading new pages of the rel
-		 * into the buffer pool.  (Otherwise we might well miss such pages
-		 * entirely.)  Therefore, while the tag might be changing while we
-		 * look at it, it can't be changing *to* a value we care about, only
-		 * *away* from such a value.  So false negatives are impossible, and
-		 * false positives are safe because we'll recheck after getting the
-		 * buffer lock.
-		 *
-		 * We could check forkNum and blockNum as well as the rnode, but the
-		 * incremental win from doing so seems small.
-		 */
-		if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
-			continue;
+		 /* this returns an InvalidBlockNumber when not in recovery */
+		nForkBlocks = smgrcachednblocks(smgr_reln, forkNum[j]);
 
-		buf_state = LockBufHdr(bufHdr);
+		if (nForkBlocks == InvalidBlockNumber)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks;
+	}
 
+	/*
+	 * Do explicit hashtable probe if the blocks to be dropped have not been
+	 * invalidated yet and the value is less than the full-scan threshold of
+	 * buffer pool.  IOW, relation is small enough for its buffers to be removed.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nTotalBlocks < BUF_DROP_FULLSCAN_THRESHOLD)
+	{
 		for (j = 0; j < nforks; j++)
 		{
-			if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
-				bufHdr->tag.forkNum == forkNum[j] &&
-				bufHdr->tag.blockNum >= firstDelBlock[j])
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nTotalBlocks; curBlock++)
 			{
-				InvalidateBuffer(bufHdr);	/* releases spinlock */
-				break;
+				uint32		newHash;		/* hash value for newTag */
+				BufferTag	newTag;			/* identity of requested block */
+				LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				newHash = BufTableHashCode(&newTag);
+				newPartitionLock = BufMappingPartitionLock(newHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(newPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&newTag, newHash);
+				LWLockRelease(newPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum == curBlock)
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
 			}
 		}
-		if (j >= nforks)
-			UnlockBufHdr(bufHdr, buf_state);
+	}
+	else
+	{
+		for (i= 0; i < NBuffers; i++)
+		{
+			bufHdr = GetBufferDescriptor(i);
+
+			/*
+			 * We can make this a tad faster by prechecking the buffer tag before
+			 * we attempt to lock the buffer; this saves a lot of lock
+			 * acquisitions in typical cases.  It should be safe because the
+			 * caller must have AccessExclusiveLock on the relation, or some other
+			 * reason to be certain that no one is loading new pages of the rel
+			 * into the buffer pool.  (Otherwise we might well miss such pages
+			 * entirely.)  Therefore, while the tag might be changing while we
+			 * look at it, it can't be changing *to* a value we care about, only
+			 * *away* from such a value.  So false negatives are impossible, and
+			 * false positives are safe because we'll recheck after getting the
+			 * buffer lock.
+			 *
+			 * We could check forkNum and blockNum as well as the rnode, but the
+			 * incremental win from doing so seems small.
+			 */
+			if (!RelFileNodeEquals(bufHdr->tag.rnode, rnode.node))
+				continue;
+
+			buf_state = LockBufHdr(bufHdr);
+
+			for (j = 0; j < nforks; j++)
+			{
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+				{
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+					break;
+				}
+			}
+			if (j >= nforks)
+				UnlockBufHdr(bufHdr, buf_state);
+		}
 	}
 }
 
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..4e45c47 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -565,6 +565,29 @@ smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 }
 
 /*
+ *	smgrcachednblocks() -- Calculate the number of blocks that are cached in
+ *					 the supplied relation.
+ *
+ * It is equivalent to calling smgrnblocks, but only used in recovery for now
+ * when DropRelFileNodeBuffers() is called.  This ensures that only cached value
+ * is used which is always valid in recovery, since there is no shared
+ * invalidation mechanism that is implemented yet for changes in file size.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not available
+ * and when the path is not in recovery.
+ */
+BlockNumber
+smgrcachednblocks(SMgrRelation reln, ForkNumber forknum)
+{
+	if (InRecovery)
+	{
+		if (reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+			return reln->smgr_cached_nblocks[forknum];
+	}
+	return InvalidBlockNumber;
+}
+
+/*
  *	smgrtruncate() -- Truncate the given forks of supplied relation to
  *					  each specified numbers of blocks
  *
@@ -583,7 +606,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..fbb7a4a 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -99,6 +99,7 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrcachednblocks(SMgrRelation reln, ForkNumber forknum);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 9266f25c02818feab55d2a5b524fba5f0f305b28 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating blocks in smgrextend() during recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From b8b4b1e865a74a846c5375f257c0c1818db726fe Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 86 ++++++++++++++++++++++++++++++++++---
 src/backend/storage/smgr/smgr.c     | 23 +++++++++-
 src/include/storage/bufmgr.h        |  2 +-
 src/include/storage/smgr.h          |  1 +
 4 files changed, 103 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..22f51c4 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2965,18 +2967,26 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  In addition, it is safe to
+ *		do this since there are no other processes but the startup process
+ *		that changes the relation size during recovery.  Otherwise, or if
+ *		not in recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2990,10 +3000,72 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/* Enter optimization loop if blocks are valid, wherein the path is in recovery */
+	for (j = 0; j < nforks; j++)
+	{
+		BlockNumber	nTotalBlocks; /* total nblocks */
+		BlockNumber nBlocksToInvalidate; /* total nblocks to be invalidated */
+
+		/* Get the total number of blocks for the supplied relation's fork */
+		nTotalBlocks = smgrcachednblocks(smgr_reln, forkNum[j]);
+
+		/* If blocks are invalid, exit the optimization and execute full scan */
+		if (nTotalBlocks == InvalidBlockNumber)
+			break;
+
+		/* Get the total number of blocks to be invalidated for the specified fork */
+		nBlocksToInvalidate = nTotalBlocks - firstDelBlock[j];
+
+		/*
+		 * Do explicit hashtable probe if the blocks to be invalidated have not been
+		 * invalidated yet as well as if the ratio of total number of buffers to be
+		 * truncated against NBuffers is less than the threshold for full-scanning of
+		 * buffer pool. IOW, relation is small enough for its buffers to be removed.
+		 */
+		if (nBlocksToInvalidate < BUF_DROP_FULLSCAN_THRESHOLD)
+		{
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nTotalBlocks; curBlock++)
+			{
+				uint32		newHash;		/* hash value for newTag */
+				BufferTag	newTag;			/* identity of requested block */
+				LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				newHash = BufTableHashCode(&newTag);
+				newPartitionLock = BufMappingPartitionLock(newHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing */
+				LWLockAcquire(newPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&newTag, newHash);
+				LWLockRelease(newPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum == curBlock)
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		else
+			break;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..e7a9ded 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -565,6 +565,27 @@ smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 }
 
 /*
+ *	smgrcachednblocks() -- Calculate the number of blocks that are cached in
+ *					 the supplied relation.
+ *
+ * It is equivalent to calling smgrnblocks, but only used in recovery for now
+ * when DropRelFileNodeBuffers() is called.  This ensures that only cached value
+ * is used which is always valid in recovery, since there is no shared
+ * invalidation mechanism that is implemented yet for changes in file size.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not available
+ * and when not in recovery.
+ */
+BlockNumber
+smgrcachednblocks(SMgrRelation reln, ForkNumber forknum)
+{
+	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+			return reln->smgr_cached_nblocks[forknum];
+
+	return InvalidBlockNumber;
+}
+
+/*
  *	smgrtruncate() -- Truncate the given forks of supplied relation to
  *					  each specified numbers of blocks
  *
@@ -583,7 +604,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..fbb7a4a 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -99,6 +99,7 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrcachednblocks(SMgrRelation reln, ForkNumber forknum);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 9266f25c02818feab55d2a5b524fba5f0f305b28 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating blocks in smgrextend() during recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 1f4a85a0c57fcd00af530f0932991775b9f532f7 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 92 ++++++++++++++++++++++++++++++++++---
 src/backend/storage/smgr/smgr.c     | 23 +++++++++-
 src/include/storage/bufmgr.h        |  2 +-
 src/include/storage/smgr.h          |  1 +
 4 files changed, 109 insertions(+), 9 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..1b72510 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULLSCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2965,18 +2967,28 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		XXX The relation might have extended before this, so this path is
+ *		only optimized during recovery when we can get a reliable cached
+ *		value of blocks for specified relation.  In addition, it is safe to
+ *		do this since there are no other processes but the startup process
+ *		that changes the relation size during recovery.  Otherwise, or if
+ *		not in recovery, proceed to usual invalidation process, where it
+ *		sequentially searches the buffer pool.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BlockNumber	nBlocksToInvalidate = 0;
+	BlockNumber	nTotalBlocks = 0;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2990,10 +3002,76 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/*
+	 * Get the total number of cached blocks and to-be-invalidated blocks
+	 * of the relation.  If a fork's nblocks is not valid, break the loop.
+	 */
+	for (j = 0; j < nforks; j++)
+	{
+		BlockNumber	nForkBlocks; /* total nblocks for a relation's fork */
+
+		nForkBlocks = smgrcachednblocks(smgr_reln, forkNum[j]);
+
+		if (nForkBlocks == InvalidBlockNumber)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks;
+		nBlocksToInvalidate = nTotalBlocks - firstDelBlock[j];
+	}
+
+	/*
+	 * Do explicit hashtable probe if the total of nblocks of relation's forks
+	 * is not invalid and the nblocks to be invalidated is less than the full-scan
+	 * threshold of buffer pool.  Otherwise, full scan is executed.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nBlocksToInvalidate < BUF_DROP_FULLSCAN_THRESHOLD)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nTotalBlocks; curBlock++)
+			{
+				uint32		newHash;		/* hash value for newTag */
+				BufferTag	newTag;			/* identity of requested block */
+				LWLock	   	*newPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(newTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				newHash = BufTableHashCode(&newTag);
+				newPartitionLock = BufMappingPartitionLock(newHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(newPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&newTag, newHash);
+				LWLockRelease(newPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum == curBlock)
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..69f431c 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -565,6 +565,27 @@ smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 }
 
 /*
+ *	smgrcachednblocks() -- Calculate the number of blocks that are cached in
+ *					 the supplied relation.
+ *
+ * It is equivalent to calling smgrnblocks, but only used in recovery for now
+ * when DropRelFileNodeBuffers() is called.  This ensures that only cached value
+ * is used which is always valid in recovery, since there is no shared
+ * invalidation mechanism that is implemented yet for changes in file size.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not available
+ * and when not in recovery.
+ */
+BlockNumber
+smgrcachednblocks(SMgrRelation reln, ForkNumber forknum)
+{
+	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+		return reln->smgr_cached_nblocks[forknum];
+
+	return InvalidBlockNumber;
+}
+
+/*
  *	smgrtruncate() -- Truncate the given forks of supplied relation to
  *					  each specified numbers of blocks
  *
@@ -583,7 +604,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..fbb7a4a 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -99,6 +99,7 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrcachednblocks(SMgrRelation reln, ForkNumber forknum);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 6b0219580f34a3c0b63445521d6ba1fef3352f53 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating blocks in smgrextend() during recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 50788405a308a910cee08ac4bef414e002ba4a23 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Fri, 11 Sep 2020 13:00:33 +0000
Subject: [PATCH] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 99 +++++++++++++++++++++++++++++++++----
 src/backend/storage/smgr/smgr.c     | 25 +++++++++-
 src/include/storage/bufmgr.h        |  2 +-
 src/include/storage/smgr.h          |  1 +
 4 files changed, 116 insertions(+), 11 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..e2d6219 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULL_SCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2965,18 +2967,28 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		If the expected maximum number of buffers to be dropped is small
+ *		enough, individual buffer is located by BufTableLookup().  Otherwise,
+ *		the buffer pool is sequentially scanned. Since buffers must not be
+ *		left behind, the latter way is executed unless the sizes of all the
+ *		involved forks are known to be accurate. See smgrcachednblocks() for
+ *		more details.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	BlockNumber	nBlocksToInvalidate = 0;
+	BlockNumber	nForkBlocks = 0;
+	BlockNumber	nTotalBlocks = 0;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2990,10 +3002,80 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/*
+	 * Get the total number of cached blocks and to-be-invalidated blocks
+	 * of the relation.  The cached value returned by smgrcachednblocks
+	 * could be smaller than the actual number of existing buffers of the
+	 * file.  This is caused by buggy Linux kernels that might not have
+	 * accounted the recent write.  If a fork's nblocks is invalid, exit loop.
+	 */
+	for (i = 0; i < nforks; i++)
+	{
+		/* Get the total nblocks for a relation's fork */
+		nForkBlocks = smgrcachednblocks(smgr_reln, forkNum[i]);
+
+		if (nForkBlocks == InvalidBlockNumber)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks;
+		nBlocksToInvalidate = nTotalBlocks - firstDelBlock[i];
+	}
+
+	/*
+	 * Do explicit hashtable probe if the total of nblocks of relation's forks
+	 * is not invalid and the nblocks to be invalidated is less than the
+	 * full-scan threshold of buffer pool.  Otherwise, full scan is executed.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		curBlock;
+
+			nForkBlocks = smgrcachednblocks(smgr_reln, forkNum[j]);
+
+			for (curBlock = firstDelBlock[j]; curBlock < nForkBlocks; curBlock++)
+			{
+				uint32		bufHash;		/* hash value for tag */
+				BufferTag	bufTag;			/* identity of requested block */
+				LWLock	   	*bufPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(bufTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				bufHash = BufTableHashCode(&bufTag);
+				bufPartitionLock = BufMappingPartitionLock(bufHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(bufPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&bufTag, bufHash);
+				LWLockRelease(bufPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3244,8 +3326,7 @@ PrintPinnedBufs(void)
  *		XXX currently it sequentially searches the buffer pool, should be
  *		changed to more clever ways of searching.  This routine is not
  *		used in any performance-critical code paths, so it's not worth
- *		adding additional overhead to normal paths to make it go faster;
- *		but see also DropRelFileNodeBuffers.
+ *		adding additional overhead to normal paths to make it go faster.
  * --------------------------------------------------------------------
  */
 void
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..c089e62 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -565,6 +565,29 @@ smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 }
 
 /*
+ *	smgrcachednblocks() -- Calculate the number of blocks that are cached in
+ *					 	   the supplied relation.
+ *
+ * It is equivalent to calling smgrnblocks, but only used in recovery for now.
+ * The returned value of file size could be inaccurate because the lseek of buggy
+ * Linux kernels might not have accounted the recent file extension or write.
+ * However, this function ensures that cached values are only used in recovery,
+ * since there is no shared invalidation mechanism that is implemented yet for
+ * changes in file size.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not available
+ * and when not in recovery.
+ */
+BlockNumber
+smgrcachednblocks(SMgrRelation reln, ForkNumber forknum)
+{
+	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+		return reln->smgr_cached_nblocks[forknum];
+
+	return InvalidBlockNumber;
+}
+
+/*
  *	smgrtruncate() -- Truncate the given forks of supplied relation to
  *					  each specified numbers of blocks
  *
@@ -583,7 +606,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..fbb7a4a 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -99,6 +99,7 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
 extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrcachednblocks(SMgrRelation reln, ForkNumber forknum);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 6b0219580f34a3c0b63445521d6ba1fef3352f53 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH] Prevent invalidating blocks in smgrextend() during recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 859c547487109481f13ee36db8ca884e4475da2c Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH 1/3] Prevent invalidating blocks in smgrextend() during
 recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From cec0f764901cf33ba66dca40eb2efa5f475076fb Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 7 Oct 2020 09:57:53 +0000
Subject: [PATCH 2/3] Add bool param in arg of smgrextend for cached blocks

---
 src/backend/access/gist/gistbuild.c       |  4 +++-
 src/backend/access/heap/visibilitymap.c   |  9 ++++++---
 src/backend/access/table/tableam.c        |  5 +++--
 src/backend/access/transam/xlogutils.c    |  3 ++-
 src/backend/catalog/storage.c             |  6 ++++--
 src/backend/storage/buffer/bufmgr.c       | 12 ++++++++----
 src/backend/storage/freespace/freespace.c |  9 ++++++---
 src/backend/storage/smgr/smgr.c           | 19 ++++++++++++++++++-
 src/include/storage/smgr.h                |  3 ++-
 9 files changed, 52 insertions(+), 18 deletions(-)

diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c
index 28bc585..d599655 100644
--- a/src/backend/access/gist/gistbuild.c
+++ b/src/backend/access/gist/gistbuild.c
@@ -808,6 +808,7 @@ gistBuildCallback(Relation index,
 	GISTBuildState *buildstate = (GISTBuildState *) state;
 	IndexTuple	itup;
 	MemoryContext oldCtx;
+	bool		isCached;
 
 	oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
 
@@ -856,7 +857,8 @@ gistBuildCallback(Relation index,
 	 */
 	if ((buildstate->buildMode == GIST_BUFFERING_AUTO &&
 		 buildstate->indtuples % BUFFERING_MODE_SWITCH_CHECK_STEP == 0 &&
-		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM)) ||
+		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM,
+											&isCached)) ||
 		(buildstate->buildMode == GIST_BUFFERING_STATS &&
 		 buildstate->indtuples >= BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET))
 	{
diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c
index b107218..6d2be35 100644
--- a/src/backend/access/heap/visibilitymap.c
+++ b/src/backend/access/heap/visibilitymap.c
@@ -445,6 +445,7 @@ BlockNumber
 visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 {
 	BlockNumber newnblocks;
+	bool	cached;
 
 	/* last remaining block, byte, and bit */
 	BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
@@ -528,7 +529,7 @@ visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 	else
 		newnblocks = truncBlock;
 
-	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM) <= newnblocks)
+	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached) <= newnblocks)
 	{
 		/* nothing to do, the file was already smaller than requested size */
 		return InvalidBlockNumber;
@@ -547,6 +548,7 @@ static Buffer
 vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 {
 	Buffer		buf;
+	bool		cached;
 
 	/*
 	 * We might not have opened the relation at the smgr level yet, or we
@@ -564,7 +566,7 @@ vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 	if (rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == InvalidBlockNumber)
 	{
 		if (smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
-			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = 0;
 	}
@@ -618,6 +620,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 {
 	BlockNumber vm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -647,7 +650,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = InvalidBlockNumber;
-	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 
 	/* Now extend the file */
 	while (vm_nblocks_now < vm_nblocks)
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 6438c45..e64451f 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -628,6 +628,7 @@ uint64
 table_block_relation_size(Relation rel, ForkNumber forkNumber)
 {
 	uint64		nblocks = 0;
+	bool		cached;
 
 	/* Open it at the smgr level if not already done */
 	RelationOpenSmgr(rel);
@@ -636,10 +637,10 @@ table_block_relation_size(Relation rel, ForkNumber forkNumber)
 	if (forkNumber == InvalidForkNumber)
 	{
 		for (int i = 0; i < MAX_FORKNUM; i++)
-			nblocks += smgrnblocks(rel->rd_smgr, i);
+			nblocks += smgrnblocks(rel->rd_smgr, i, &cached);
 	}
 	else
-		nblocks = smgrnblocks(rel->rd_smgr, forkNumber);
+		nblocks = smgrnblocks(rel->rd_smgr, forkNumber, &cached);
 
 	return nblocks * BLCKSZ;
 }
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index 7e915bc..20eda81 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -444,6 +444,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	BlockNumber lastblock;
 	Buffer		buffer;
 	SMgrRelation smgr;
+	bool		cached;
 
 	Assert(blkno != P_NEW);
 
@@ -460,7 +461,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	 */
 	smgrcreate(smgr, forknum, true);
 
-	lastblock = smgrnblocks(smgr, forknum);
+	lastblock = smgrnblocks(smgr, forknum, &cached);
 
 	if (blkno < lastblock)
 	{
diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
index dbbd3aa..057e53b 100644
--- a/src/backend/catalog/storage.c
+++ b/src/backend/catalog/storage.c
@@ -410,6 +410,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 {
 	PGAlignedBlock buf;
 	Page		page;
+	bool		cached;
 	bool		use_wal;
 	bool		copying_initfork;
 	BlockNumber nblocks;
@@ -434,7 +435,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 	use_wal = XLogIsNeeded() &&
 		(relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork);
 
-	nblocks = smgrnblocks(src, forkNum);
+	nblocks = smgrnblocks(src, forkNum, &cached);
 
 	for (blkno = 0; blkno < nblocks; blkno++)
 	{
@@ -703,6 +704,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 		BlockNumber nblocks[MAX_FORKNUM + 1];
 		BlockNumber total_blocks = 0;
 		SMgrRelation srel;
+		bool		cached;
 
 		srel = smgropen(pendingsync->rnode, InvalidBackendId);
 
@@ -720,7 +722,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 			{
 				if (smgrexists(srel, fork))
 				{
-					BlockNumber n = smgrnblocks(srel, fork);
+					BlockNumber n = smgrnblocks(srel, fork, &cached);
 
 					/* we shouldn't come here for unlogged relations */
 					Assert(fork != INIT_FORKNUM);
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..45897a3 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -720,6 +720,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 	BufferDesc *bufHdr;
 	Block		bufBlock;
 	bool		found;
+	bool		isCached;
 	bool		isExtend;
 	bool		isLocalBuf = SmgrIsTemp(smgr);
 
@@ -739,7 +740,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	/* Substitute proper block number if caller asked for P_NEW */
 	if (isExtend)
-		blockNum = smgrnblocks(smgr, forkNum);
+		blockNum = smgrnblocks(smgr, forkNum, &isCached);
 
 	if (isLocalBuf)
 	{
@@ -2852,11 +2853,14 @@ RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
 		case RELKIND_SEQUENCE:
 		case RELKIND_INDEX:
 		case RELKIND_PARTITIONED_INDEX:
-			/* Open it at the smgr level if not already done */
-			RelationOpenSmgr(relation);
+			{
+				bool		isCached;
 
-			return smgrnblocks(relation->rd_smgr, forkNum);
+				/* Open it at the smgr level if not already done */
+				RelationOpenSmgr(relation);
 
+				return smgrnblocks(relation->rd_smgr, forkNum, &isCached);
+			}
 		case RELKIND_RELATION:
 		case RELKIND_TOASTVALUE:
 		case RELKIND_MATVIEW:
diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 6a96126..f631878 100644
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -264,6 +264,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	FSMAddress	first_removed_address;
 	uint16		first_removed_slot;
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -317,7 +318,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	else
 	{
 		new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
-		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM) <= new_nfsmblocks)
+		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached) <= new_nfsmblocks)
 			return InvalidBlockNumber;	/* nothing to do; the FSM was already
 										 * smaller */
 	}
@@ -532,6 +533,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 {
 	BlockNumber blkno = fsm_logical_to_physical(addr);
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -547,7 +549,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 		/* Invalidate the cache so smgrnblocks asks the kernel. */
 		rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
 		if (smgrexists(rel->rd_smgr, FSM_FORKNUM))
-			smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+			smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = 0;
 	}
@@ -603,6 +605,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 {
 	BlockNumber fsm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -633,7 +636,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
-	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 
 	while (fsm_nblocks_now < fsm_nblocks)
 	{
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index f476b8e..6e2b680 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -551,23 +551,40 @@ smgrwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 /*
  *	smgrnblocks() -- Calculate the number of blocks in the
  *					 supplied relation.
+ *
+ * This returns an InvalidBlockNumber when smgr_cached_nblocks is not
+ * available and when not in recovery path.
  */
 BlockNumber
-smgrnblocks(SMgrRelation reln, ForkNumber forknum)
+smgrnblocks(SMgrRelation reln, ForkNumber forknum, bool *isCached)
 {
 	BlockNumber result;
 
+	*isCached = false;
+
 	/*
 	 * For now, we only use cached values in recovery due to lack of a shared
 	 * invalidation mechanism for changes in file size.
 	 */
 	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+	{
+		*isCached = true;
+
 		return reln->smgr_cached_nblocks[forknum];
+	}
 
 	result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
 
 	reln->smgr_cached_nblocks[forknum] = result;
 
+	/*
+	 * We cannot believe the result from smgr_nblocks is always accurate
+	 * because lseek of buggy Linux kernels doesn't account for a recent
+	 * write.
+	 */
+	if (!InRecovery && result == InvalidBlockNumber)
+		return InvalidBlockNumber;
+
 	return result;
 }
 
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..e247cce 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -98,7 +98,8 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 					  BlockNumber blocknum, char *buffer, bool skipFsync);
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
-extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum,
+							   bool *isCached);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From c69409f04e486449971b1f8eb3235429eb2cf969 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 7 Oct 2020 10:23:51 +0000
Subject: [PATCH 3/3] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 98 +++++++++++++++++++++++++++++++++----
 src/backend/storage/smgr/smgr.c     |  2 +-
 src/include/storage/bufmgr.h        |  2 +-
 3 files changed, 91 insertions(+), 11 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 45897a3..fae9980 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULL_SCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2969,18 +2971,29 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		If the expected maximum number of buffers to be dropped is small
+ *		enough, individual buffer is located by BufTableLookup().  Otherwise,
+ *		the buffer pool is sequentially scanned. Since buffers must not be
+ *		left behind, the latter way is executed unless the sizes of all the
+ *		involved forks are known to be accurate. See smgrnblocks() for
+ *		more details.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	bool		isCached;
+	BlockNumber	nForkBlocks[MAX_FORKNUM];
+	BlockNumber	nBlocksToInvalidate = 0;
+	BlockNumber	nTotalBlocks = 0;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2994,10 +3007,78 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/*
+	 * Get the total number of cached blocks and to-be-invalidated blocks
+	 * of the relation.  The cached value returned by smgrnblocks could be
+	 * smaller than the actual number of existing buffers of the file.
+	 * This is caused by buggy Linux kernels that might not have accounted
+	 * the recent write.  If a fork's nblocks is invalid, exit loop.
+	 */
+	for (i = 0; i < nforks; i++)
+	{
+		/* Get the total nblocks for a relation's fork */
+		nForkBlocks[i] = smgrnblocks(smgr_reln, forkNum[i], &isCached);
+
+		if (nForkBlocks[i] == InvalidBlockNumber)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks[i];
+		nBlocksToInvalidate = nTotalBlocks - firstDelBlock[i];
+	}
+
+	/*
+	 * Do explicit hashtable lookup if the total of nblocks of relation's forks
+	 * is not invalid and the nblocks to be invalidated is less than the
+	 * full-scan threshold of buffer pool.  Otherwise, full scan is executed.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nForkBlocks[j]; curBlock++)
+			{
+				uint32		bufHash;		/* hash value for tag */
+				BufferTag	bufTag;			/* identity of requested block */
+				LWLock	   	*bufPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(bufTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				bufHash = BufTableHashCode(&bufTag);
+				bufPartitionLock = BufMappingPartitionLock(bufHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(bufPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&bufTag, bufHash);
+				LWLockRelease(bufPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= firstDelBlock[j])
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3248,8 +3329,7 @@ PrintPinnedBufs(void)
  *		XXX currently it sequentially searches the buffer pool, should be
  *		changed to more clever ways of searching.  This routine is not
  *		used in any performance-critical code paths, so it's not worth
- *		adding additional overhead to normal paths to make it go faster;
- *		but see also DropRelFileNodeBuffers.
+ *		adding additional overhead to normal paths to make it go faster.
  * --------------------------------------------------------------------
  */
 void
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index 6e2b680..8e189db 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -607,7 +607,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From f357f48100c3856a173f8644db6e5c7fb90b5f9f Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH 1/3] Prevent invalidating blocks in smgrextend() during
 recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 5b5bccc7cb6cd7b55a5c244d9ab1e73c746a8cca Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 7 Oct 2020 09:57:53 +0000
Subject: [PATCH 2/3] Add bool param in smgrnblocks() for cached blocks.

---
 src/backend/access/gist/gistbuild.c       |  4 +++-
 src/backend/access/heap/visibilitymap.c   |  9 ++++++---
 src/backend/access/table/tableam.c        |  5 +++--
 src/backend/access/transam/xlogutils.c    |  3 ++-
 src/backend/catalog/storage.c             |  6 ++++--
 src/backend/storage/buffer/bufmgr.c       | 12 ++++++++----
 src/backend/storage/freespace/freespace.c |  9 ++++++---
 src/backend/storage/smgr/smgr.c           | 13 +++++++++++--
 src/include/storage/smgr.h                |  3 ++-
 9 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c
index 28bc585..d599655 100644
--- a/src/backend/access/gist/gistbuild.c
+++ b/src/backend/access/gist/gistbuild.c
@@ -808,6 +808,7 @@ gistBuildCallback(Relation index,
 	GISTBuildState *buildstate = (GISTBuildState *) state;
 	IndexTuple	itup;
 	MemoryContext oldCtx;
+	bool		isCached;
 
 	oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
 
@@ -856,7 +857,8 @@ gistBuildCallback(Relation index,
 	 */
 	if ((buildstate->buildMode == GIST_BUFFERING_AUTO &&
 		 buildstate->indtuples % BUFFERING_MODE_SWITCH_CHECK_STEP == 0 &&
-		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM)) ||
+		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM,
+											&isCached)) ||
 		(buildstate->buildMode == GIST_BUFFERING_STATS &&
 		 buildstate->indtuples >= BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET))
 	{
diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c
index b107218..6d2be35 100644
--- a/src/backend/access/heap/visibilitymap.c
+++ b/src/backend/access/heap/visibilitymap.c
@@ -445,6 +445,7 @@ BlockNumber
 visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 {
 	BlockNumber newnblocks;
+	bool	cached;
 
 	/* last remaining block, byte, and bit */
 	BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
@@ -528,7 +529,7 @@ visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 	else
 		newnblocks = truncBlock;
 
-	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM) <= newnblocks)
+	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached) <= newnblocks)
 	{
 		/* nothing to do, the file was already smaller than requested size */
 		return InvalidBlockNumber;
@@ -547,6 +548,7 @@ static Buffer
 vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 {
 	Buffer		buf;
+	bool		cached;
 
 	/*
 	 * We might not have opened the relation at the smgr level yet, or we
@@ -564,7 +566,7 @@ vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 	if (rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == InvalidBlockNumber)
 	{
 		if (smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
-			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = 0;
 	}
@@ -618,6 +620,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 {
 	BlockNumber vm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -647,7 +650,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = InvalidBlockNumber;
-	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 
 	/* Now extend the file */
 	while (vm_nblocks_now < vm_nblocks)
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 6438c45..e64451f 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -628,6 +628,7 @@ uint64
 table_block_relation_size(Relation rel, ForkNumber forkNumber)
 {
 	uint64		nblocks = 0;
+	bool		cached;
 
 	/* Open it at the smgr level if not already done */
 	RelationOpenSmgr(rel);
@@ -636,10 +637,10 @@ table_block_relation_size(Relation rel, ForkNumber forkNumber)
 	if (forkNumber == InvalidForkNumber)
 	{
 		for (int i = 0; i < MAX_FORKNUM; i++)
-			nblocks += smgrnblocks(rel->rd_smgr, i);
+			nblocks += smgrnblocks(rel->rd_smgr, i, &cached);
 	}
 	else
-		nblocks = smgrnblocks(rel->rd_smgr, forkNumber);
+		nblocks = smgrnblocks(rel->rd_smgr, forkNumber, &cached);
 
 	return nblocks * BLCKSZ;
 }
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index 7e915bc..20eda81 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -444,6 +444,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	BlockNumber lastblock;
 	Buffer		buffer;
 	SMgrRelation smgr;
+	bool		cached;
 
 	Assert(blkno != P_NEW);
 
@@ -460,7 +461,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	 */
 	smgrcreate(smgr, forknum, true);
 
-	lastblock = smgrnblocks(smgr, forknum);
+	lastblock = smgrnblocks(smgr, forknum, &cached);
 
 	if (blkno < lastblock)
 	{
diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
index dbbd3aa..057e53b 100644
--- a/src/backend/catalog/storage.c
+++ b/src/backend/catalog/storage.c
@@ -410,6 +410,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 {
 	PGAlignedBlock buf;
 	Page		page;
+	bool		cached;
 	bool		use_wal;
 	bool		copying_initfork;
 	BlockNumber nblocks;
@@ -434,7 +435,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 	use_wal = XLogIsNeeded() &&
 		(relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork);
 
-	nblocks = smgrnblocks(src, forkNum);
+	nblocks = smgrnblocks(src, forkNum, &cached);
 
 	for (blkno = 0; blkno < nblocks; blkno++)
 	{
@@ -703,6 +704,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 		BlockNumber nblocks[MAX_FORKNUM + 1];
 		BlockNumber total_blocks = 0;
 		SMgrRelation srel;
+		bool		cached;
 
 		srel = smgropen(pendingsync->rnode, InvalidBackendId);
 
@@ -720,7 +722,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 			{
 				if (smgrexists(srel, fork))
 				{
-					BlockNumber n = smgrnblocks(srel, fork);
+					BlockNumber n = smgrnblocks(srel, fork, &cached);
 
 					/* we shouldn't come here for unlogged relations */
 					Assert(fork != INIT_FORKNUM);
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..45897a3 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -720,6 +720,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 	BufferDesc *bufHdr;
 	Block		bufBlock;
 	bool		found;
+	bool		isCached;
 	bool		isExtend;
 	bool		isLocalBuf = SmgrIsTemp(smgr);
 
@@ -739,7 +740,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	/* Substitute proper block number if caller asked for P_NEW */
 	if (isExtend)
-		blockNum = smgrnblocks(smgr, forkNum);
+		blockNum = smgrnblocks(smgr, forkNum, &isCached);
 
 	if (isLocalBuf)
 	{
@@ -2852,11 +2853,14 @@ RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
 		case RELKIND_SEQUENCE:
 		case RELKIND_INDEX:
 		case RELKIND_PARTITIONED_INDEX:
-			/* Open it at the smgr level if not already done */
-			RelationOpenSmgr(relation);
+			{
+				bool		isCached;
 
-			return smgrnblocks(relation->rd_smgr, forkNum);
+				/* Open it at the smgr level if not already done */
+				RelationOpenSmgr(relation);
 
+				return smgrnblocks(relation->rd_smgr, forkNum, &isCached);
+			}
 		case RELKIND_RELATION:
 		case RELKIND_TOASTVALUE:
 		case RELKIND_MATVIEW:
diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 6a96126..f631878 100644
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -264,6 +264,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	FSMAddress	first_removed_address;
 	uint16		first_removed_slot;
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -317,7 +318,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	else
 	{
 		new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
-		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM) <= new_nfsmblocks)
+		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached) <= new_nfsmblocks)
 			return InvalidBlockNumber;	/* nothing to do; the FSM was already
 										 * smaller */
 	}
@@ -532,6 +533,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 {
 	BlockNumber blkno = fsm_logical_to_physical(addr);
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -547,7 +549,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 		/* Invalidate the cache so smgrnblocks asks the kernel. */
 		rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
 		if (smgrexists(rel->rd_smgr, FSM_FORKNUM))
-			smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+			smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = 0;
 	}
@@ -603,6 +605,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 {
 	BlockNumber fsm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -633,7 +636,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
-	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 
 	while (fsm_nblocks_now < fsm_nblocks)
 	{
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index f476b8e..d7d61ea 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -553,16 +553,25 @@ smgrwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
  *					 supplied relation.
  */
 BlockNumber
-smgrnblocks(SMgrRelation reln, ForkNumber forknum)
+smgrnblocks(SMgrRelation reln, ForkNumber forknum, bool *isCached)
 {
 	BlockNumber result;
 
+	*isCached = false;
+
 	/*
 	 * For now, we only use cached values in recovery due to lack of a shared
-	 * invalidation mechanism for changes in file size.
+	 * invalidation mechanism for changes in file size.  The cached values
+	 * could be smaller than the actual number of existing buffers of the file.
+	 * This is caused by lseek of buggy Linux kernels that might not have
+	 * accounted for the recent write.
 	 */
 	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+	{
+		*isCached = true;
+
 		return reln->smgr_cached_nblocks[forknum];
+	}
 
 	result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
 
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..e247cce 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -98,7 +98,8 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 					  BlockNumber blocknum, char *buffer, bool skipFsync);
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
-extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum,
+							   bool *isCached);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From 6ca5c03d6df13adae64a7bc0f3dc4520a4c110d8 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Thu, 8 Oct 2020 08:46:43 +0000
Subject: [PATCH 3/3] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 99 +++++++++++++++++++++++++++++++++----
 src/backend/storage/smgr/smgr.c     |  2 +-
 src/include/storage/bufmgr.h        |  2 +-
 3 files changed, 92 insertions(+), 11 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 45897a3..507b373 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULL_SCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2969,18 +2971,29 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		If the expected maximum number of buffers to be dropped is small
+ *		enough, individual buffer is located by BufTableLookup().  Otherwise,
+ *		the buffer pool is sequentially scanned. Since buffers must not be
+ *		left behind, the latter way is executed unless the sizes of all the
+ *		involved forks are known to be accurate. See smgrnblocks() for
+ *		more details.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	bool		isCached;
+	BlockNumber	nForkBlocks[MAX_FORKNUM];
+	BlockNumber	nBlocksToInvalidate = 0;
+	BlockNumber	nTotalBlocks = 0;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2994,10 +3007,79 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/*
+	 * Get the total number of cached blocks and to-be-invalidated blocks
+	 * of the relation.  The cached value returned by smgrnblocks could be
+	 * smaller than the actual number of existing buffers of the file.
+	 * This is caused by buggy Linux kernels that might not have accounted
+	 * for the recent write.  Give up the optimization if the block count
+	 * of any fork cannot be trusted.
+	 */
+	for (i = 0; i < nforks; i++)
+	{
+		/* Get the total nblocks for a relation's fork */
+		nForkBlocks[i] = smgrnblocks(smgr_reln, forkNum[i], &isCached);
+
+		if (!isCached)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks[i];
+		nBlocksToInvalidate += (nForkBlocks[i] - firstDelBlock[i]);
+	}
+
+	/*
+	 * Look up the buffer in the hashtable if the block size is known to
+	 * be accurate and the total blocks to be invalidated is below the
+	 * full scan threshold.  Otherwise, give up the optimization.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nForkBlocks[j]; curBlock++)
+			{
+				uint32		bufHash;		/* hash value for tag */
+				BufferTag	bufTag;			/* identity of requested block */
+				LWLock	   	*bufPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(bufTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				bufHash = BufTableHashCode(&bufTag);
+				bufPartitionLock = BufMappingPartitionLock(bufHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(bufPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&bufTag, bufHash);
+				LWLockRelease(bufPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= cur_block)
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3248,8 +3330,7 @@ PrintPinnedBufs(void)
  *		XXX currently it sequentially searches the buffer pool, should be
  *		changed to more clever ways of searching.  This routine is not
  *		used in any performance-critical code paths, so it's not worth
- *		adding additional overhead to normal paths to make it go faster;
- *		but see also DropRelFileNodeBuffers.
+ *		adding additional overhead to normal paths to make it go faster.
  * --------------------------------------------------------------------
  */
 void
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index d7d61ea..6253c13 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -599,7 +599,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1

From f357f48100c3856a173f8644db6e5c7fb90b5f9f Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 23 Sep 2020 07:15:30 +0000
Subject: [PATCH 1/3] Prevent invalidating blocks in smgrextend() during
 recovery.

DropRelFileNodeBuffers relies on the behavior that cached blocks
returned by smgrnblocks() won't be invalidated by file extension
during recovery.
---
 src/backend/storage/smgr/smgr.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index dcc09df..f476b8e 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -474,7 +474,14 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 	if (reln->smgr_cached_nblocks[forknum] == blocknum)
 		reln->smgr_cached_nblocks[forknum] = blocknum + 1;
 	else
+	{
+		/*
+		 * DropRelFileNodeBuffers relies on the behavior that cached nblocks
+		 * won't be invalidated by file extension during recovery.
+		 */
+		Assert(!InRecovery);
 		reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
+	}
 }
 
 /*
-- 
1.8.3.1

From 5b5bccc7cb6cd7b55a5c244d9ab1e73c746a8cca Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Wed, 7 Oct 2020 09:57:53 +0000
Subject: [PATCH 2/3] Add bool param in smgrnblocks() for cached blocks.

---
 src/backend/access/gist/gistbuild.c       |  4 +++-
 src/backend/access/heap/visibilitymap.c   |  9 ++++++---
 src/backend/access/table/tableam.c        |  5 +++--
 src/backend/access/transam/xlogutils.c    |  3 ++-
 src/backend/catalog/storage.c             |  6 ++++--
 src/backend/storage/buffer/bufmgr.c       | 12 ++++++++----
 src/backend/storage/freespace/freespace.c |  9 ++++++---
 src/backend/storage/smgr/smgr.c           | 13 +++++++++++--
 src/include/storage/smgr.h                |  3 ++-
 9 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c
index 28bc585..d599655 100644
--- a/src/backend/access/gist/gistbuild.c
+++ b/src/backend/access/gist/gistbuild.c
@@ -808,6 +808,7 @@ gistBuildCallback(Relation index,
 	GISTBuildState *buildstate = (GISTBuildState *) state;
 	IndexTuple	itup;
 	MemoryContext oldCtx;
+	bool		isCached;
 
 	oldCtx = MemoryContextSwitchTo(buildstate->giststate->tempCxt);
 
@@ -856,7 +857,8 @@ gistBuildCallback(Relation index,
 	 */
 	if ((buildstate->buildMode == GIST_BUFFERING_AUTO &&
 		 buildstate->indtuples % BUFFERING_MODE_SWITCH_CHECK_STEP == 0 &&
-		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM)) ||
+		 effective_cache_size < smgrnblocks(index->rd_smgr, MAIN_FORKNUM,
+											&isCached)) ||
 		(buildstate->buildMode == GIST_BUFFERING_STATS &&
 		 buildstate->indtuples >= BUFFERING_MODE_TUPLE_SIZE_STATS_TARGET))
 	{
diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c
index b107218..6d2be35 100644
--- a/src/backend/access/heap/visibilitymap.c
+++ b/src/backend/access/heap/visibilitymap.c
@@ -445,6 +445,7 @@ BlockNumber
 visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 {
 	BlockNumber newnblocks;
+	bool	cached;
 
 	/* last remaining block, byte, and bit */
 	BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
@@ -528,7 +529,7 @@ visibilitymap_prepare_truncate(Relation rel, BlockNumber nheapblocks)
 	else
 		newnblocks = truncBlock;
 
-	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM) <= newnblocks)
+	if (smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached) <= newnblocks)
 	{
 		/* nothing to do, the file was already smaller than requested size */
 		return InvalidBlockNumber;
@@ -547,6 +548,7 @@ static Buffer
 vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 {
 	Buffer		buf;
+	bool		cached;
 
 	/*
 	 * We might not have opened the relation at the smgr level yet, or we
@@ -564,7 +566,7 @@ vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
 	if (rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == InvalidBlockNumber)
 	{
 		if (smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
-			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+			smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = 0;
 	}
@@ -618,6 +620,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 {
 	BlockNumber vm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -647,7 +650,7 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = InvalidBlockNumber;
-	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
+	vm_nblocks_now = smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM, &cached);
 
 	/* Now extend the file */
 	while (vm_nblocks_now < vm_nblocks)
diff --git a/src/backend/access/table/tableam.c b/src/backend/access/table/tableam.c
index 6438c45..e64451f 100644
--- a/src/backend/access/table/tableam.c
+++ b/src/backend/access/table/tableam.c
@@ -628,6 +628,7 @@ uint64
 table_block_relation_size(Relation rel, ForkNumber forkNumber)
 {
 	uint64		nblocks = 0;
+	bool		cached;
 
 	/* Open it at the smgr level if not already done */
 	RelationOpenSmgr(rel);
@@ -636,10 +637,10 @@ table_block_relation_size(Relation rel, ForkNumber forkNumber)
 	if (forkNumber == InvalidForkNumber)
 	{
 		for (int i = 0; i < MAX_FORKNUM; i++)
-			nblocks += smgrnblocks(rel->rd_smgr, i);
+			nblocks += smgrnblocks(rel->rd_smgr, i, &cached);
 	}
 	else
-		nblocks = smgrnblocks(rel->rd_smgr, forkNumber);
+		nblocks = smgrnblocks(rel->rd_smgr, forkNumber, &cached);
 
 	return nblocks * BLCKSZ;
 }
diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c
index 7e915bc..20eda81 100644
--- a/src/backend/access/transam/xlogutils.c
+++ b/src/backend/access/transam/xlogutils.c
@@ -444,6 +444,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	BlockNumber lastblock;
 	Buffer		buffer;
 	SMgrRelation smgr;
+	bool		cached;
 
 	Assert(blkno != P_NEW);
 
@@ -460,7 +461,7 @@ XLogReadBufferExtended(RelFileNode rnode, ForkNumber forknum,
 	 */
 	smgrcreate(smgr, forknum, true);
 
-	lastblock = smgrnblocks(smgr, forknum);
+	lastblock = smgrnblocks(smgr, forknum, &cached);
 
 	if (blkno < lastblock)
 	{
diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
index dbbd3aa..057e53b 100644
--- a/src/backend/catalog/storage.c
+++ b/src/backend/catalog/storage.c
@@ -410,6 +410,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 {
 	PGAlignedBlock buf;
 	Page		page;
+	bool		cached;
 	bool		use_wal;
 	bool		copying_initfork;
 	BlockNumber nblocks;
@@ -434,7 +435,7 @@ RelationCopyStorage(SMgrRelation src, SMgrRelation dst,
 	use_wal = XLogIsNeeded() &&
 		(relpersistence == RELPERSISTENCE_PERMANENT || copying_initfork);
 
-	nblocks = smgrnblocks(src, forkNum);
+	nblocks = smgrnblocks(src, forkNum, &cached);
 
 	for (blkno = 0; blkno < nblocks; blkno++)
 	{
@@ -703,6 +704,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 		BlockNumber nblocks[MAX_FORKNUM + 1];
 		BlockNumber total_blocks = 0;
 		SMgrRelation srel;
+		bool		cached;
 
 		srel = smgropen(pendingsync->rnode, InvalidBackendId);
 
@@ -720,7 +722,7 @@ smgrDoPendingSyncs(bool isCommit, bool isParallelWorker)
 			{
 				if (smgrexists(srel, fork))
 				{
-					BlockNumber n = smgrnblocks(srel, fork);
+					BlockNumber n = smgrnblocks(srel, fork, &cached);
 
 					/* we shouldn't come here for unlogged relations */
 					Assert(fork != INIT_FORKNUM);
diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index e549fa1..45897a3 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -720,6 +720,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 	BufferDesc *bufHdr;
 	Block		bufBlock;
 	bool		found;
+	bool		isCached;
 	bool		isExtend;
 	bool		isLocalBuf = SmgrIsTemp(smgr);
 
@@ -739,7 +740,7 @@ ReadBuffer_common(SMgrRelation smgr, char relpersistence, ForkNumber forkNum,
 
 	/* Substitute proper block number if caller asked for P_NEW */
 	if (isExtend)
-		blockNum = smgrnblocks(smgr, forkNum);
+		blockNum = smgrnblocks(smgr, forkNum, &isCached);
 
 	if (isLocalBuf)
 	{
@@ -2852,11 +2853,14 @@ RelationGetNumberOfBlocksInFork(Relation relation, ForkNumber forkNum)
 		case RELKIND_SEQUENCE:
 		case RELKIND_INDEX:
 		case RELKIND_PARTITIONED_INDEX:
-			/* Open it at the smgr level if not already done */
-			RelationOpenSmgr(relation);
+			{
+				bool		isCached;
 
-			return smgrnblocks(relation->rd_smgr, forkNum);
+				/* Open it at the smgr level if not already done */
+				RelationOpenSmgr(relation);
 
+				return smgrnblocks(relation->rd_smgr, forkNum, &isCached);
+			}
 		case RELKIND_RELATION:
 		case RELKIND_TOASTVALUE:
 		case RELKIND_MATVIEW:
diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 6a96126..f631878 100644
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -264,6 +264,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	FSMAddress	first_removed_address;
 	uint16		first_removed_slot;
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -317,7 +318,7 @@ FreeSpaceMapPrepareTruncateRel(Relation rel, BlockNumber nblocks)
 	else
 	{
 		new_nfsmblocks = fsm_logical_to_physical(first_removed_address);
-		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM) <= new_nfsmblocks)
+		if (smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached) <= new_nfsmblocks)
 			return InvalidBlockNumber;	/* nothing to do; the FSM was already
 										 * smaller */
 	}
@@ -532,6 +533,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 {
 	BlockNumber blkno = fsm_logical_to_physical(addr);
 	Buffer		buf;
+	bool		cached;
 
 	RelationOpenSmgr(rel);
 
@@ -547,7 +549,7 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
 		/* Invalidate the cache so smgrnblocks asks the kernel. */
 		rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
 		if (smgrexists(rel->rd_smgr, FSM_FORKNUM))
-			smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+			smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 		else
 			rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = 0;
 	}
@@ -603,6 +605,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 {
 	BlockNumber fsm_nblocks_now;
 	PGAlignedBlock pg;
+	bool	cached;
 
 	PageInit((Page) pg.data, BLCKSZ, 0);
 
@@ -633,7 +636,7 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
 
 	/* Invalidate cache so that smgrnblocks() asks the kernel. */
 	rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
-	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
+	fsm_nblocks_now = smgrnblocks(rel->rd_smgr, FSM_FORKNUM, &cached);
 
 	while (fsm_nblocks_now < fsm_nblocks)
 	{
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index f476b8e..d7d61ea 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -553,16 +553,25 @@ smgrwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
  *					 supplied relation.
  */
 BlockNumber
-smgrnblocks(SMgrRelation reln, ForkNumber forknum)
+smgrnblocks(SMgrRelation reln, ForkNumber forknum, bool *isCached)
 {
 	BlockNumber result;
 
+	*isCached = false;
+
 	/*
 	 * For now, we only use cached values in recovery due to lack of a shared
-	 * invalidation mechanism for changes in file size.
+	 * invalidation mechanism for changes in file size.  The cached values
+	 * could be smaller than the actual number of existing buffers of the file.
+	 * This is caused by lseek of buggy Linux kernels that might not have
+	 * accounted for the recent write.
 	 */
 	if (InRecovery && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+	{
+		*isCached = true;
+
 		return reln->smgr_cached_nblocks[forknum];
+	}
 
 	result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
 
diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index f28a842..e247cce 100644
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -98,7 +98,8 @@ extern void smgrwrite(SMgrRelation reln, ForkNumber forknum,
 					  BlockNumber blocknum, char *buffer, bool skipFsync);
 extern void smgrwriteback(SMgrRelation reln, ForkNumber forknum,
 						  BlockNumber blocknum, BlockNumber nblocks);
-extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum);
+extern BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum,
+							   bool *isCached);
 extern void smgrtruncate(SMgrRelation reln, ForkNumber *forknum,
 						 int nforks, BlockNumber *nblocks);
 extern void smgrimmedsync(SMgrRelation reln, ForkNumber forknum);
-- 
1.8.3.1

From ed50ec8abe7ae01fcb2c70f849e8e5dd808efdd6 Mon Sep 17 00:00:00 2001
From: Kirk Jamison <k.jamison@jp.fujitsu.com>
Date: Thu, 8 Oct 2020 08:46:43 +0000
Subject: [PATCH 3/3] Optimize DropRelFileNodeBuffers() during recovery.

The recovery path of DropRelFileNodeBuffers() is optimized so that
scanning of the whole buffer pool is avoided when the relation
is small enough, or the the total number of blocks to be invalidated
is below the threshold of full scanning.

While recovery, we can get a reliable cached value of nblocks for
supplied relation's fork, and it's safe because there are no other
processes but the startup process that changes the relation size
during recovery.  Otherwise, or if not in recovery, proceed to
sequential search of the whole buffer pool.
---
 src/backend/storage/buffer/bufmgr.c | 99 +++++++++++++++++++++++++++++++++----
 src/backend/storage/smgr/smgr.c     |  2 +-
 src/include/storage/bufmgr.h        |  2 +-
 3 files changed, 92 insertions(+), 11 deletions(-)

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 45897a3..8798ad0 100644
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -70,6 +70,8 @@
 
 #define RELS_BSEARCH_THRESHOLD		20
 
+#define BUF_DROP_FULL_SCAN_THRESHOLD		(uint32)(NBuffers / 512)
+
 typedef struct PrivateRefCountEntry
 {
 	Buffer		buffer;
@@ -2969,18 +2971,29 @@ BufferGetLSNAtomic(Buffer buffer)
  *		that no other process could be trying to load more pages of the
  *		relation into buffers.
  *
- *		XXX currently it sequentially searches the buffer pool, should be
- *		changed to more clever ways of searching.  However, this routine
- *		is used only in code paths that aren't very performance-critical,
- *		and we shouldn't slow down the hot paths to make it faster ...
+ *		If the expected maximum number of buffers to be dropped is small
+ *		enough, individual buffer is located by BufTableLookup().  Otherwise,
+ *		the buffer pool is sequentially scanned. Since buffers must not be
+ *		left behind, the latter way is executed unless the sizes of all the
+ *		involved forks are known to be accurate. See smgrnblocks() for
+ *		more details.
  * --------------------------------------------------------------------
  */
 void
-DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+DropRelFileNodeBuffers(SMgrRelation smgr_reln, ForkNumber *forkNum,
 					   int nforks, BlockNumber *firstDelBlock)
 {
 	int			i;
 	int			j;
+	RelFileNodeBackend	rnode;
+	bool		isCached;
+	BlockNumber	nForkBlocks[MAX_FORKNUM];
+	BlockNumber	nBlocksToInvalidate = 0;
+	BlockNumber	nTotalBlocks = 0;
+	BufferDesc	*bufHdr;
+	uint32		buf_state;
+
+	rnode = smgr_reln->smgr_rnode;
 
 	/* If it's a local relation, it's localbuf.c's problem. */
 	if (RelFileNodeBackendIsTemp(rnode))
@@ -2994,10 +3007,79 @@ DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
 		return;
 	}
 
+	/*
+	 * Get the total number of cached blocks and to-be-invalidated blocks
+	 * of the relation.  The cached value returned by smgrnblocks could be
+	 * smaller than the actual number of existing buffers of the file.
+	 * This is caused by buggy Linux kernels that might not have accounted
+	 * for the recent write.  Give up the optimization if the block count
+	 * of any fork cannot be trusted.
+	 */
+	for (i = 0; i < nforks; i++)
+	{
+		/* Get the total nblocks for a relation's fork */
+		nForkBlocks[i] = smgrnblocks(smgr_reln, forkNum[i], &isCached);
+
+		if (!isCached)
+		{
+			nTotalBlocks = InvalidBlockNumber;
+			break;
+		}
+		nTotalBlocks += nForkBlocks[i];
+		nBlocksToInvalidate += (nForkBlocks[i] - firstDelBlock[i]);
+	}
+
+	/*
+	 * Look up the buffer in the hashtable if the block size is known to
+	 * be accurate and the total blocks to be invalidated is below the
+	 * full scan threshold.  Otherwise, give up the optimization.
+	 */
+	if (nTotalBlocks != InvalidBlockNumber &&
+		nBlocksToInvalidate < BUF_DROP_FULL_SCAN_THRESHOLD)
+	{
+		for (j = 0; j < nforks; j++)
+		{
+			BlockNumber		curBlock;
+
+			for (curBlock = firstDelBlock[j]; curBlock < nForkBlocks[j]; curBlock++)
+			{
+				uint32		bufHash;		/* hash value for tag */
+				BufferTag	bufTag;			/* identity of requested block */
+				LWLock	   	*bufPartitionLock;	/* buffer partition lock for it */
+				int		buf_id;
+
+				/* create a tag so we can lookup the buffer */
+				INIT_BUFFERTAG(bufTag, rnode.node, forkNum[j], curBlock);
+
+				/* determine its hash code and partition lock ID */
+				bufHash = BufTableHashCode(&bufTag);
+				bufPartitionLock = BufMappingPartitionLock(bufHash);
+
+				/* Check that it is in the buffer pool. If not, do nothing. */
+				LWLockAcquire(bufPartitionLock, LW_SHARED);
+				buf_id = BufTableLookup(&bufTag, bufHash);
+				LWLockRelease(bufPartitionLock);
+
+				if (buf_id < 0)
+					continue;
+
+				bufHdr = GetBufferDescriptor(buf_id);
+
+				buf_state = LockBufHdr(bufHdr);
+
+				if (RelFileNodeEquals(bufHdr->tag.rnode, rnode.node) &&
+					bufHdr->tag.forkNum == forkNum[j] &&
+					bufHdr->tag.blockNum >= curBlock)
+					InvalidateBuffer(bufHdr);	/* releases spinlock */
+				else
+					UnlockBufHdr(bufHdr, buf_state);
+			}
+		}
+		return;
+	}
 	for (i = 0; i < NBuffers; i++)
 	{
-		BufferDesc *bufHdr = GetBufferDescriptor(i);
-		uint32		buf_state;
+		bufHdr = GetBufferDescriptor(i);
 
 		/*
 		 * We can make this a tad faster by prechecking the buffer tag before
@@ -3248,8 +3330,7 @@ PrintPinnedBufs(void)
  *		XXX currently it sequentially searches the buffer pool, should be
  *		changed to more clever ways of searching.  This routine is not
  *		used in any performance-critical code paths, so it's not worth
- *		adding additional overhead to normal paths to make it go faster;
- *		but see also DropRelFileNodeBuffers.
+ *		adding additional overhead to normal paths to make it go faster.
  * --------------------------------------------------------------------
  */
 void
diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index d7d61ea..6253c13 100644
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -599,7 +599,7 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
 	 * Get rid of any buffers for the about-to-be-deleted blocks. bufmgr will
 	 * just drop them without bothering to write the contents.
 	 */
-	DropRelFileNodeBuffers(reln->smgr_rnode, forknum, nforks, nblocks);
+	DropRelFileNodeBuffers(reln, forknum, nforks, nblocks);
 
 	/*
 	 * Send a shared-inval message to force other backends to close any smgr
diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index ee91b8f..056f65e 100644
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -203,7 +203,7 @@ extern void FlushOneBuffer(Buffer buffer);
 extern void FlushRelationBuffers(Relation rel);
 extern void FlushRelationsAllBuffers(struct SMgrRelationData **smgrs, int nrels);
 extern void FlushDatabaseBuffers(Oid dbid);
-extern void DropRelFileNodeBuffers(RelFileNodeBackend rnode, ForkNumber *forkNum,
+extern void DropRelFileNodeBuffers(struct SMgrRelationData *smgr_reln, ForkNumber *forkNum,
 								   int nforks, BlockNumber *firstDelBlock);
 extern void DropRelFileNodesAllBuffers(RelFileNodeBackend *rnodes, int nnodes);
 extern void DropDatabaseBuffers(Oid dbid);
-- 
1.8.3.1