Use pre-fetching for ANALYZE

When we have posix_fadvise() available, we can improve the performance
of an ANALYZE by quite a bit by using it to inform the kernel of the
blocks that we're going to be asking for.  Similar to bitmap index
scans, the number of buffers pre-fetched is based off of the
maintenance_io_concurrency setting (for the particular tablespace or,
if not set, globally, via get_tablespace_maintenance_io_concurrency()).

Reviewed-By: Heikki Linnakangas, Tomas Vondra
Discussion: https://www.postgresql.org/message-id/VI1PR0701MB69603A433348EDCF783C6ECBF6EF0%40VI1PR0701MB6960.eurprd07.prod.outlook.com

diff --git a/src/backend/commands/analyze.c b/src/backend/commands/analyze.c
index 596bab2f104431c65a8575ac10f04e7c4b354583..f84616d3d2c6070335a8549da99d1281271f6a2f 100644 (file)
--- a/src/backend/commands/analyze.c
+++ b/src/backend/commands/analyze.c
@@ -63,6 +63,7 @@
 #include "utils/pg_rusage.h"
 #include "utils/sampling.h"
 #include "utils/sortsupport.h"
+#include "utils/spccache.h"
 #include "utils/syscache.h"
 #include "utils/timestamp.h"
 
@@ -1127,6 +1128,7 @@ acquire_sample_rows(Relation onerel, int elevel,
    double      liverows = 0;   /* # live rows seen */
    double      deadrows = 0;   /* # dead rows seen */
    double      rowstoskip = -1;    /* -1 means not set yet */
+   long        randseed;       /* Seed for block sampler(s) */
    BlockNumber totalblocks;
    TransactionId OldestXmin;
    BlockSamplerData bs;
@@ -1135,6 +1137,10 @@ acquire_sample_rows(Relation onerel, int elevel,
    TableScanDesc scan;
    BlockNumber nblocks;
    BlockNumber blksdone = 0;
+#ifdef USE_PREFETCH
+   int         prefetch_maximum = 0;   /* blocks to prefetch if enabled */
+   BlockSamplerData prefetch_bs;
+#endif
 
    Assert(targrows > 0);
 
@@ -1144,7 +1150,15 @@ acquire_sample_rows(Relation onerel, int elevel,
    OldestXmin = GetOldestNonRemovableTransactionId(onerel);
 
    /* Prepare for sampling block numbers */
-   nblocks = BlockSampler_Init(&bs, totalblocks, targrows, random());
+   randseed = random();
+   nblocks = BlockSampler_Init(&bs, totalblocks, targrows, randseed);
+
+#ifdef USE_PREFETCH
+   prefetch_maximum = get_tablespace_io_concurrency(onerel->rd_rel->reltablespace);
+   /* Create another BlockSampler, using the same seed, for prefetching */
+   if (prefetch_maximum)
+       (void) BlockSampler_Init(&prefetch_bs, totalblocks, targrows, randseed);
+#endif
 
    /* Report sampling block numbers */
    pgstat_progress_update_param(PROGRESS_ANALYZE_BLOCKS_TOTAL,
@@ -1156,14 +1170,69 @@ acquire_sample_rows(Relation onerel, int elevel,
    scan = table_beginscan_analyze(onerel);
    slot = table_slot_create(onerel, NULL);
 
+#ifdef USE_PREFETCH
+
+   /*
+    * If we are doing prefetching, then go ahead and tell the kernel about
+    * the first set of pages we are going to want.  This also moves our
+    * iterator out ahead of the main one being used, where we will keep it so
+    * that we're always pre-fetching out prefetch_maximum number of blocks
+    * ahead.
+    */
+   if (prefetch_maximum)
+   {
+       for (int i = 0; i < prefetch_maximum; i++)
+       {
+           BlockNumber prefetch_block;
+
+           if (!BlockSampler_HasMore(&prefetch_bs))
+               break;
+
+           prefetch_block = BlockSampler_Next(&prefetch_bs);
+           PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, prefetch_block);
+       }
+   }
+#endif
+
    /* Outer loop over blocks to sample */
    while (BlockSampler_HasMore(&bs))
    {
+       bool        block_accepted;
        BlockNumber targblock = BlockSampler_Next(&bs);
+#ifdef USE_PREFETCH
+       BlockNumber prefetch_targblock = InvalidBlockNumber;
+
+       /*
+        * Make sure that every time the main BlockSampler is moved forward
+        * that our prefetch BlockSampler also gets moved forward, so that we
+        * always stay out ahead.
+        */
+       if (prefetch_maximum && BlockSampler_HasMore(&prefetch_bs))
+           prefetch_targblock = BlockSampler_Next(&prefetch_bs);
+#endif
 
        vacuum_delay_point();
 
-       if (!table_scan_analyze_next_block(scan, targblock, vac_strategy))
+       block_accepted = table_scan_analyze_next_block(scan, targblock, vac_strategy);
+
+#ifdef USE_PREFETCH
+
+       /*
+        * When pre-fetching, after we get a block, tell the kernel about the
+        * next one we will want, if there's any left.
+        *
+        * We want to do this even if the table_scan_analyze_next_block() call
+        * above decides against analyzing the block it picked.
+        */
+       if (prefetch_maximum && prefetch_targblock != InvalidBlockNumber)
+           PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, prefetch_targblock);
+#endif
+
+       /*
+        * Don't analyze if table_scan_analyze_next_block() indicated this
+        * block is unsuitable for analyzing.
+        */
+       if (!block_accepted)
            continue;
 
        while (table_scan_analyze_next_tuple(scan, OldestXmin, &liverows, &deadrows, slot))