Cache smgrnblocks() results in recovery.

Avoid repeatedly calling lseek(SEEK_END) during recovery by caching
the size of each fork.  For now, we can't use the same technique in
other processes, because we lack a shared invalidation mechanism.

Do this by generalizing the pre-existing caching used by FSM and VM
to support all forks.

Discussion: https://postgr.es/m/CAEepm%3D3SSw-Ty1DFcK%3D1rU-K6GSzYzfdD4d%2BZwapdN7dTa6%3DnQ%40mail.gmail.com

diff --git a/contrib/pg_visibility/pg_visibility.c b/contrib/pg_visibility/pg_visibility.c
index 68d580ed1e02c65c97d41c0f82bf442dc6a6485a..e731161734ae2e6998549dc396212c4fdcecd239 100644 (file)
--- a/contrib/pg_visibility/pg_visibility.c
+++ b/contrib/pg_visibility/pg_visibility.c
@@ -392,7 +392,7 @@ pg_truncate_visibility_map(PG_FUNCTION_ARGS)
        check_relation_relkind(rel);
 
        RelationOpenSmgr(rel);
-       rel->rd_smgr->smgr_vm_nblocks = InvalidBlockNumber;
+       rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = InvalidBlockNumber;
 
        block = visibilitymap_prepare_truncate(rel, 0);
        if (BlockNumberIsValid(block))

diff --git a/src/backend/access/heap/visibilitymap.c b/src/backend/access/heap/visibilitymap.c
index 0a51678c40df103c1c36e83a7cfba061ffa9c24c..b1072183bcd6ddac4e2ae24b2b41d637d50f1edd 100644 (file)
--- a/src/backend/access/heap/visibilitymap.c
+++ b/src/backend/access/heap/visibilitymap.c
@@ -561,17 +561,16 @@ vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
         * If we haven't cached the size of the visibility map fork yet, check it
         * first.
         */
-       if (rel->rd_smgr->smgr_vm_nblocks == InvalidBlockNumber)
+       if (rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == InvalidBlockNumber)
        {
                if (smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
-                       rel->rd_smgr->smgr_vm_nblocks = smgrnblocks(rel->rd_smgr,
-                                                                                                               VISIBILITYMAP_FORKNUM);
+                       smgrnblocks(rel->rd_smgr, VISIBILITYMAP_FORKNUM);
                else
-                       rel->rd_smgr->smgr_vm_nblocks = 0;
+                       rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] = 0;
        }
 
        /* Handle requests beyond EOF */
-       if (blkno >= rel->rd_smgr->smgr_vm_nblocks)
+       if (blkno >= rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM])
        {
                if (extend)
                        vm_extend(rel, blkno + 1);
@@ -641,11 +640,13 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
         * Create the file first if it doesn't exist.  If smgr_vm_nblocks is
         * positive then it must exist, no need for an smgrexists call.
         */
-       if ((rel->rd_smgr->smgr_vm_nblocks == 0 ||
-                rel->rd_smgr->smgr_vm_nblocks == InvalidBlockNumber) &&
+       if ((rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == 0 ||
+                rel->rd_smgr->smgr_cached_nblocks[VISIBILITYMAP_FORKNUM] == InvalidBlockNumber) &&
                !smgrexists(rel->rd_smgr, VISIBILITYMAP_FORKNUM))
                smgrcreate(rel->rd_smgr, VISIBILITYMAP_FORKNUM, false);
 
+       /* 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);
 
        /* Now extend the file */
@@ -667,8 +668,5 @@ vm_extend(Relation rel, BlockNumber vm_nblocks)
         */
        CacheInvalidateSmgr(rel->rd_smgr->smgr_rnode);
 
-       /* Update local cache with the up-to-date size */
-       rel->rd_smgr->smgr_vm_nblocks = vm_nblocks_now;
-
        UnlockRelationForExtension(rel, ExclusiveLock);
 }

diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
index ec143b640aabfd8dea4d9bbd168c471559011b0d..9e6e6c42d3c8372b6a8c5c0a9c0612f8c11724a0 100644 (file)
--- a/src/backend/catalog/storage.c
+++ b/src/backend/catalog/storage.c
@@ -290,8 +290,8 @@ RelationTruncate(Relation rel, BlockNumber nblocks)
         * Make sure smgr_targblock etc aren't pointing somewhere past new end
         */
        rel->rd_smgr->smgr_targblock = InvalidBlockNumber;
-       rel->rd_smgr->smgr_fsm_nblocks = InvalidBlockNumber;
-       rel->rd_smgr->smgr_vm_nblocks = InvalidBlockNumber;
+       for (int i = 0; i <= MAX_FORKNUM; ++i)
+               rel->rd_smgr->smgr_cached_nblocks[i] = InvalidBlockNumber;
 
        /* Prepare for truncation of MAIN fork of the relation */
        forks[nforks] = MAIN_FORKNUM;

diff --git a/src/backend/storage/freespace/freespace.c b/src/backend/storage/freespace/freespace.c
index 95a21f6cc383eac012f998b10b595817bcd77f66..6a96126b0c2ff33ecff58cd880689b83b0938dd5 100644 (file)
--- a/src/backend/storage/freespace/freespace.c
+++ b/src/backend/storage/freespace/freespace.c
@@ -541,18 +541,19 @@ fsm_readbuf(Relation rel, FSMAddress addr, bool extend)
         * value might be stale.  (We send smgr inval messages on truncation, but
         * not on extension.)
         */
-       if (rel->rd_smgr->smgr_fsm_nblocks == InvalidBlockNumber ||
-               blkno >= rel->rd_smgr->smgr_fsm_nblocks)
+       if (rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] == InvalidBlockNumber ||
+               blkno >= rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM])
        {
+               /* Invalidate the cache so smgrnblocks asks the kernel. */
+               rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = InvalidBlockNumber;
                if (smgrexists(rel->rd_smgr, FSM_FORKNUM))
-                       rel->rd_smgr->smgr_fsm_nblocks = smgrnblocks(rel->rd_smgr,
-                                                                                                                FSM_FORKNUM);
+                       smgrnblocks(rel->rd_smgr, FSM_FORKNUM);
                else
-                       rel->rd_smgr->smgr_fsm_nblocks = 0;
+                       rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] = 0;
        }
 
        /* Handle requests beyond EOF */
-       if (blkno >= rel->rd_smgr->smgr_fsm_nblocks)
+       if (blkno >= rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM])
        {
                if (extend)
                        fsm_extend(rel, blkno + 1);
@@ -621,14 +622,17 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
        RelationOpenSmgr(rel);
 
        /*
-        * Create the FSM file first if it doesn't exist.  If smgr_fsm_nblocks is
-        * positive then it must exist, no need for an smgrexists call.
+        * Create the FSM file first if it doesn't exist.  If
+        * smgr_cached_nblocks[FSM_FORKNUM] is positive then it must exist, no
+        * need for an smgrexists call.
         */
-       if ((rel->rd_smgr->smgr_fsm_nblocks == 0 ||
-                rel->rd_smgr->smgr_fsm_nblocks == InvalidBlockNumber) &&
+       if ((rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] == 0 ||
+                rel->rd_smgr->smgr_cached_nblocks[FSM_FORKNUM] == InvalidBlockNumber) &&
                !smgrexists(rel->rd_smgr, FSM_FORKNUM))
                smgrcreate(rel->rd_smgr, FSM_FORKNUM, false);
 
+       /* 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);
 
        while (fsm_nblocks_now < fsm_nblocks)
@@ -640,9 +644,6 @@ fsm_extend(Relation rel, BlockNumber fsm_nblocks)
                fsm_nblocks_now++;
        }
 
-       /* Update local cache with the up-to-date size */
-       rel->rd_smgr->smgr_fsm_nblocks = fsm_nblocks_now;
-
        UnlockRelationForExtension(rel, ExclusiveLock);
 }
 

diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c
index 7d667c6586f1fff05e6afa465432951053c53072..dcc09df0c7723343fdfc71ab45172e6625f67bfe 100644 (file)
--- a/src/backend/storage/smgr/smgr.c
+++ b/src/backend/storage/smgr/smgr.c
@@ -17,6 +17,7 @@
  */
 #include "postgres.h"
 
+#include "access/xlog.h"
 #include "lib/ilist.h"
 #include "storage/bufmgr.h"
 #include "storage/ipc.h"
@@ -174,8 +175,8 @@ smgropen(RelFileNode rnode, BackendId backend)
                /* hash_search already filled in the lookup key */
                reln->smgr_owner = NULL;
                reln->smgr_targblock = InvalidBlockNumber;
-               reln->smgr_fsm_nblocks = InvalidBlockNumber;
-               reln->smgr_vm_nblocks = InvalidBlockNumber;
+               for (int i = 0; i <= MAX_FORKNUM; ++i)
+                       reln->smgr_cached_nblocks[i] = InvalidBlockNumber;
                reln->smgr_which = 0;   /* we only have md.c at present */
 
                /* implementation-specific initialization */
@@ -464,6 +465,16 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 {
        smgrsw[reln->smgr_which].smgr_extend(reln, forknum, blocknum,
                                                                                 buffer, skipFsync);
+
+       /*
+        * Normally we expect this to increase nblocks by one, but if the cached
+        * value isn't as expected, just invalidate it so the next call asks the
+        * kernel.
+        */
+       if (reln->smgr_cached_nblocks[forknum] == blocknum)
+               reln->smgr_cached_nblocks[forknum] = blocknum + 1;
+       else
+               reln->smgr_cached_nblocks[forknum] = InvalidBlockNumber;
 }
 
 /*
@@ -537,7 +548,20 @@ smgrwriteback(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
 BlockNumber
 smgrnblocks(SMgrRelation reln, ForkNumber forknum)
 {
-       return smgrsw[reln->smgr_which].smgr_nblocks(reln, 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 && reln->smgr_cached_nblocks[forknum] != InvalidBlockNumber)
+               return reln->smgr_cached_nblocks[forknum];
+
+       result = smgrsw[reln->smgr_which].smgr_nblocks(reln, forknum);
+
+       reln->smgr_cached_nblocks[forknum] = result;
+
+       return result;
 }
 
 /*
@@ -576,20 +600,19 @@ smgrtruncate(SMgrRelation reln, ForkNumber *forknum, int nforks, BlockNumber *nb
        /* Do the truncation */
        for (i = 0; i < nforks; i++)
        {
+               /* Make the cached size is invalid if we encounter an error. */
+               reln->smgr_cached_nblocks[forknum[i]] = InvalidBlockNumber;
+
                smgrsw[reln->smgr_which].smgr_truncate(reln, forknum[i], nblocks[i]);
 
                /*
-                * We might as well update the local smgr_fsm_nblocks and
-                * smgr_vm_nblocks settings. The smgr cache inval message that this
-                * function sent will cause other backends to invalidate their copies
-                * of smgr_fsm_nblocks and smgr_vm_nblocks, and these ones too at the
-                * next command boundary. But these ensure they aren't outright wrong
-                * until then.
+                * We might as well update the local smgr_cached_nblocks values. The
+                * smgr cache inval message that this function sent will cause other
+                * backends to invalidate their copies of smgr_fsm_nblocks and
+                * smgr_vm_nblocks, and these ones too at the next command boundary.
+                * But these ensure they aren't outright wrong until then.
                 */
-               if (forknum[i] == FSM_FORKNUM)
-                       reln->smgr_fsm_nblocks = nblocks[i];
-               if (forknum[i] == VISIBILITYMAP_FORKNUM)
-                       reln->smgr_vm_nblocks = nblocks[i];
+               reln->smgr_cached_nblocks[forknum[i]] = nblocks[i];
        }
 }
 

diff --git a/src/include/storage/smgr.h b/src/include/storage/smgr.h
index 656665959319ee98dc3a6d9e35195f48ef6817c1..f28a842401326ada8b3bc0e66b4629508f20f4c8 100644 (file)
--- a/src/include/storage/smgr.h
+++ b/src/include/storage/smgr.h
@@ -45,15 +45,13 @@ typedef struct SMgrRelationData
        struct SMgrRelationData **smgr_owner;
 
        /*
-        * These next three fields are not actually used or manipulated by smgr,
-        * except that they are reset to InvalidBlockNumber upon a cache flush
-        * event (in particular, upon truncation of the relation).  Higher levels
-        * store cached state here so that it will be reset when truncation
-        * happens.  In all three cases, InvalidBlockNumber means "unknown".
+        * The following fields are reset to InvalidBlockNumber upon a cache flush
+        * event, and hold the last known size for each fork.  This information is
+        * currently only reliable during recovery, since there is no cache
+        * invalidation for fork extension.
         */
        BlockNumber smgr_targblock; /* current insertion target block */
-       BlockNumber smgr_fsm_nblocks;   /* last known size of fsm fork */
-       BlockNumber smgr_vm_nblocks;    /* last known size of vm fork */
+       BlockNumber smgr_cached_nblocks[MAX_FORKNUM + 1];       /* last known size */
 
        /* additional public fields may someday exist here */