Refactor bitmap heap scan in preparation for parallel support.

The final patch will be less messy if the prefetching support is
a bit better isolated, so do that.

Dilip Kumar, with some changes by me.  The larger patch set of which
this is a part has been reviewed and tested by (at least) Andres
Freund, Amit Khandekar, Tushar Ahuja, Rafia Sabih, Haribabu Kommi, and
Thomas Munro.

diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c
index c871aa0348287e1d4466e13f9024269ab9bfa209..c1aa9f13bdf5b3df609ddef3138f34c532762e87 100644 (file)
--- a/src/backend/executor/nodeBitmapHeapscan.c
+++ b/src/backend/executor/nodeBitmapHeapscan.c
@@ -53,6 +53,11 @@
 
 static TupleTableSlot *BitmapHeapNext(BitmapHeapScanState *node);
 static void bitgetpage(HeapScanDesc scan, TBMIterateResult *tbmres);
+static inline void BitmapAdjustPrefetchIterator(BitmapHeapScanState *node,
+                            TBMIterateResult *tbmres);
+static inline void BitmapAdjustPrefetchTarget(BitmapHeapScanState *node);
+static inline void BitmapPrefetch(BitmapHeapScanState *node,
+              HeapScanDesc scan);
 
 
 /* ----------------------------------------------------------------
@@ -69,10 +74,6 @@ BitmapHeapNext(BitmapHeapScanState *node)
    TIDBitmap  *tbm;
    TBMIterator *tbmiterator;
    TBMIterateResult *tbmres;
-
-#ifdef USE_PREFETCH
-   TBMIterator *prefetch_iterator;
-#endif
    OffsetNumber targoffset;
    TupleTableSlot *slot;
 
@@ -85,9 +86,6 @@ BitmapHeapNext(BitmapHeapScanState *node)
    tbm = node->tbm;
    tbmiterator = node->tbmiterator;
    tbmres = node->tbmres;
-#ifdef USE_PREFETCH
-   prefetch_iterator = node->prefetch_iterator;
-#endif
 
    /*
     * If we haven't yet performed the underlying index scan, do it, and begin
@@ -115,7 +113,7 @@ BitmapHeapNext(BitmapHeapScanState *node)
 #ifdef USE_PREFETCH
        if (node->prefetch_maximum > 0)
        {
-           node->prefetch_iterator = prefetch_iterator = tbm_begin_iterate(tbm);
+           node->prefetch_iterator = tbm_begin_iterate(tbm);
            node->prefetch_pages = 0;
            node->prefetch_target = -1;
        }
@@ -139,21 +137,7 @@ BitmapHeapNext(BitmapHeapScanState *node)
                break;
            }
 
-#ifdef USE_PREFETCH
-           if (node->prefetch_pages > 0)
-           {
-               /* The main iterator has closed the distance by one page */
-               node->prefetch_pages--;
-           }
-           else if (prefetch_iterator)
-           {
-               /* Do not let the prefetch iterator get behind the main one */
-               TBMIterateResult *tbmpre = tbm_iterate(prefetch_iterator);
-
-               if (tbmpre == NULL || tbmpre->blockno != tbmres->blockno)
-                   elog(ERROR, "prefetch and main iterators are out of sync");
-           }
-#endif   /* USE_PREFETCH */
+           BitmapAdjustPrefetchIterator(node, tbmres);
 
            /*
             * Ignore any claimed entries past what we think is the end of the
@@ -182,23 +166,8 @@ BitmapHeapNext(BitmapHeapScanState *node)
             */
            scan->rs_cindex = 0;
 
-#ifdef USE_PREFETCH
-
-           /*
-            * Increase prefetch target if it's not yet at the max.  Note that
-            * we will increase it to zero after fetching the very first
-            * page/tuple, then to one after the second tuple is fetched, then
-            * it doubles as later pages are fetched.
-            */
-           if (node->prefetch_target >= node->prefetch_maximum)
-                /* don't increase any further */ ;
-           else if (node->prefetch_target >= node->prefetch_maximum / 2)
-               node->prefetch_target = node->prefetch_maximum;
-           else if (node->prefetch_target > 0)
-               node->prefetch_target *= 2;
-           else
-               node->prefetch_target++;
-#endif   /* USE_PREFETCH */
+           /* Adjust the prefetch target */
+           BitmapAdjustPrefetchTarget(node);
        }
        else
        {
@@ -227,8 +196,6 @@ BitmapHeapNext(BitmapHeapScanState *node)
            continue;
        }
 
-#ifdef USE_PREFETCH
-
        /*
         * We issue prefetch requests *after* fetching the current page to try
         * to avoid having prefetching interfere with the main I/O. Also, this
@@ -236,24 +203,7 @@ BitmapHeapNext(BitmapHeapScanState *node)
         * to do on the current page, else we may uselessly prefetch the same
         * page we are just about to request for real.
         */
-       if (prefetch_iterator)
-       {
-           while (node->prefetch_pages < node->prefetch_target)
-           {
-               TBMIterateResult *tbmpre = tbm_iterate(prefetch_iterator);
-
-               if (tbmpre == NULL)
-               {
-                   /* No more pages to prefetch */
-                   tbm_end_iterate(prefetch_iterator);
-                   node->prefetch_iterator = prefetch_iterator = NULL;
-                   break;
-               }
-               node->prefetch_pages++;
-               PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno);
-           }
-       }
-#endif   /* USE_PREFETCH */
+       BitmapPrefetch(node, scan);
 
        /*
         * Okay to fetch the tuple
@@ -411,6 +361,84 @@ bitgetpage(HeapScanDesc scan, TBMIterateResult *tbmres)
    scan->rs_ntuples = ntup;
 }
 
+/*
+ * BitmapAdjustPrefetchIterator - Adjust the prefetch iterator
+ */
+static inline void
+BitmapAdjustPrefetchIterator(BitmapHeapScanState *node,
+                            TBMIterateResult *tbmres)
+{
+#ifdef USE_PREFETCH
+   TBMIterator *prefetch_iterator = node->prefetch_iterator;
+
+   if (node->prefetch_pages > 0)
+   {
+       /* The main iterator has closed the distance by one page */
+       node->prefetch_pages--;
+   }
+   else if (prefetch_iterator)
+   {
+       /* Do not let the prefetch iterator get behind the main one */
+       TBMIterateResult *tbmpre = tbm_iterate(prefetch_iterator);
+
+       if (tbmpre == NULL || tbmpre->blockno != tbmres->blockno)
+           elog(ERROR, "prefetch and main iterators are out of sync");
+   }
+#endif   /* USE_PREFETCH */
+}
+
+/*
+ * BitmapAdjustPrefetchTarget - Adjust the prefetch target
+ *
+ * Increase prefetch target if it's not yet at the max.  Note that
+ * we will increase it to zero after fetching the very first
+ * page/tuple, then to one after the second tuple is fetched, then
+ * it doubles as later pages are fetched.
+ */
+static inline void
+BitmapAdjustPrefetchTarget(BitmapHeapScanState *node)
+{
+#ifdef USE_PREFETCH
+   if (node->prefetch_target >= node->prefetch_maximum)
+        /* don't increase any further */ ;
+   else if (node->prefetch_target >= node->prefetch_maximum / 2)
+       node->prefetch_target = node->prefetch_maximum;
+   else if (node->prefetch_target > 0)
+       node->prefetch_target *= 2;
+   else
+       node->prefetch_target++;
+#endif   /* USE_PREFETCH */
+}
+
+/*
+ * BitmapPrefetch - Prefetch, if prefetch_pages are behind prefetch_target
+ */
+static inline void
+BitmapPrefetch(BitmapHeapScanState *node, HeapScanDesc scan)
+{
+#ifdef USE_PREFETCH
+   TBMIterator *prefetch_iterator = node->prefetch_iterator;
+
+   if (prefetch_iterator)
+   {
+       while (node->prefetch_pages < node->prefetch_target)
+       {
+           TBMIterateResult *tbmpre = tbm_iterate(prefetch_iterator);
+
+           if (tbmpre == NULL)
+           {
+               /* No more pages to prefetch */
+               tbm_end_iterate(prefetch_iterator);
+               node->prefetch_iterator = NULL;
+               break;
+           }
+           node->prefetch_pages++;
+           PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno);
+       }
+   }
+#endif   /* USE_PREFETCH */
+}
+
 /*
  * BitmapHeapRecheck -- access method routine to recheck a tuple in EvalPlanQual
  */