Provide ReadRecentBuffer() to re-pin buffers by ID.

If you know the ID of a buffer that recently held a block that you would
like to pin, this function can be used check if it's still there.  It
can be used to avoid a second lookup in the buffer mapping table after
PrefetchBuffer() reports a cache hit.

Reviewed-by: Andres Freund <andres@anarazel.de>
Discussion: https://postgr.es/m/CA+hUKGJ4VJN8ttxScUFM8dOKX0BrBiboo5uz1cq=AovOddfHpA@mail.gmail.com

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 852138f9c93a1b4bd5e613e40b0f813d0761f5eb..0c5b87864b90bac45c928c11c94f796cd4c11b21 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -610,6 +610,84 @@ PrefetchBuffer(Relation reln, ForkNumber forkNum, BlockNumber blockNum)
    }
 }
 
+/*
+ * ReadRecentBuffer -- try to pin a block in a recently observed buffer
+ *
+ * Compared to ReadBuffer(), this avoids a buffer mapping lookup when it's
+ * successful.  Return true if the buffer is valid and still has the expected
+ * tag.  In that case, the buffer is pinned and the usage count is bumped.
+ */
+bool
+ReadRecentBuffer(RelFileNode rnode, ForkNumber forkNum, BlockNumber blockNum,
+                Buffer recent_buffer)
+{
+   BufferDesc *bufHdr;
+   BufferTag   tag;
+   uint32      buf_state;
+   bool        have_private_ref;
+
+   Assert(BufferIsValid(recent_buffer));
+
+   ResourceOwnerEnlargeBuffers(CurrentResourceOwner);
+   ReservePrivateRefCountEntry();
+   INIT_BUFFERTAG(tag, rnode, forkNum, blockNum);
+
+   if (BufferIsLocal(recent_buffer))
+   {
+       bufHdr = GetBufferDescriptor(-recent_buffer - 1);
+       buf_state = pg_atomic_read_u32(&bufHdr->state);
+
+       /* Is it still valid and holding the right tag? */
+       if ((buf_state & BM_VALID) && BUFFERTAGS_EQUAL(tag, bufHdr->tag))
+       {
+           /* Bump local buffer's ref and usage counts. */
+           ResourceOwnerRememberBuffer(CurrentResourceOwner, recent_buffer);
+           LocalRefCount[-recent_buffer - 1]++;
+           if (BUF_STATE_GET_USAGECOUNT(buf_state) < BM_MAX_USAGE_COUNT)
+               pg_atomic_write_u32(&bufHdr->state,
+                                   buf_state + BUF_USAGECOUNT_ONE);
+
+           return true;
+       }
+   }
+   else
+   {
+       bufHdr = GetBufferDescriptor(recent_buffer - 1);
+       have_private_ref = GetPrivateRefCount(recent_buffer) > 0;
+
+       /*
+        * Do we already have this buffer pinned with a private reference?  If
+        * so, it must be valid and it is safe to check the tag without
+        * locking.  If not, we have to lock the header first and then check.
+        */
+       if (have_private_ref)
+           buf_state = pg_atomic_read_u32(&bufHdr->state);
+       else
+           buf_state = LockBufHdr(bufHdr);
+
+       if ((buf_state & BM_VALID) && BUFFERTAGS_EQUAL(tag, bufHdr->tag))
+       {
+           /*
+            * It's now safe to pin the buffer.  We can't pin first and ask
+            * questions later, because because it might confuse code paths
+            * like InvalidateBuffer() if we pinned a random non-matching
+            * buffer.
+            */
+           if (have_private_ref)
+               PinBuffer(bufHdr, NULL);    /* bump pin count */
+           else
+               PinBuffer_Locked(bufHdr);   /* pin for first time */
+
+           return true;
+       }
+
+       /* If we locked the header above, now unlock. */
+       if (!have_private_ref)
+           UnlockBufHdr(bufHdr, buf_state);
+   }
+
+   return false;
+}
 
 /*
  * ReadBuffer -- a shorthand for ReadBufferExtended, for reading from main

diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index fb00fda6a7f21fbcc4f1a5337a64ff2643dafb6d..aa64fb42ec45d78bf21af2d48cd154fc6b209dd3 100644 (file)
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -176,6 +176,8 @@ extern PrefetchBufferResult PrefetchSharedBuffer(struct SMgrRelationData *smgr_r
                                                 BlockNumber blockNum);
 extern PrefetchBufferResult PrefetchBuffer(Relation reln, ForkNumber forkNum,
                                           BlockNumber blockNum);
+extern bool ReadRecentBuffer(RelFileNode rnode, ForkNumber forkNum,
+                            BlockNumber blockNum, Buffer recent_buffer);
 extern Buffer ReadBuffer(Relation reln, BlockNumber blockNum);
 extern Buffer ReadBufferExtended(Relation reln, ForkNumber forkNum,
                                 BlockNumber blockNum, ReadBufferMode mode,