#include "postgres.h"
#include <math.h>
#include "access/relscan.h"
#include "access/tableam.h"
#include "access/visibilitymap.h"
#include "executor/executor.h"
#include "executor/nodeBitmapHeapscan.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/bufmgr.h"
#include "utils/rel.h"
#include "utils/snapmgr.h"
#include "utils/spccache.h"

Include dependency graph for nodeBitmapHeapscan.c:

Functions
static TupleTableSlot *	BitmapHeapNext (BitmapHeapScanState *node)

static void	BitmapDoneInitializingSharedState (ParallelBitmapHeapState *pstate)

static void	BitmapAdjustPrefetchIterator (BitmapHeapScanState *node, BlockNumber blockno)

static void	BitmapAdjustPrefetchTarget (BitmapHeapScanState *node)

static void	BitmapPrefetch (BitmapHeapScanState *node, TableScanDesc scan)

static bool	BitmapShouldInitializeSharedState (ParallelBitmapHeapState *pstate)

static bool	BitmapHeapRecheck (BitmapHeapScanState node, TupleTableSlot slot)

static TupleTableSlot *	ExecBitmapHeapScan (PlanState *pstate)

void	ExecReScanBitmapHeapScan (BitmapHeapScanState *node)

void	ExecEndBitmapHeapScan (BitmapHeapScanState *node)

BitmapHeapScanState *	ExecInitBitmapHeapScan (BitmapHeapScan node, EState estate, int eflags)

void	ExecBitmapHeapEstimate (BitmapHeapScanState node, ParallelContext pcxt)

void	ExecBitmapHeapInitializeDSM (BitmapHeapScanState node, ParallelContext pcxt)

void	ExecBitmapHeapReInitializeDSM (BitmapHeapScanState node, ParallelContext pcxt)

void	ExecBitmapHeapInitializeWorker (BitmapHeapScanState node, ParallelWorkerContext pwcxt)

Function Documentation

◆ BitmapAdjustPrefetchIterator()

static void BitmapAdjustPrefetchIterator	(	BitmapHeapScanState *	node,
		BlockNumber	blockno
	)

inlinestatic

Definition at line 344 of file nodeBitmapHeapscan.c.

 {
 #ifdef USE_PREFETCH
     ParallelBitmapHeapState *pstate = node->pstate;
  
     if (pstate == NULL)
     {
         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 != blockno)
                 elog(ERROR, "prefetch and main iterators are out of sync");
         }
         return;
     }
  
     if (node->prefetch_maximum > 0)
     {
         TBMSharedIterator *prefetch_iterator = node->shared_prefetch_iterator;
  
         SpinLockAcquire(&pstate->mutex);
         if (pstate->prefetch_pages > 0)
         {
             pstate->prefetch_pages--;
             SpinLockRelease(&pstate->mutex);
         }
         else
         {
             /* Release the mutex before iterating */
             SpinLockRelease(&pstate->mutex);
  
             /*
              * In case of shared mode, we can not ensure that the current
              * blockno of the main iterator and that of the prefetch iterator
              * are same.  It's possible that whatever blockno we are
              * prefetching will be processed by another process.  Therefore,
              * we don't validate the blockno here as we do in non-parallel
              * case.
              */
             if (prefetch_iterator)
                 tbm_shared_iterate(prefetch_iterator);
         }
     }
 #endif                          /* USE_PREFETCH */
 }

References TBMIterateResult::blockno, elog, ERROR, ParallelBitmapHeapState::mutex, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::prefetch_maximum, ParallelBitmapHeapState::prefetch_pages, BitmapHeapScanState::prefetch_pages, BitmapHeapScanState::pstate, BitmapHeapScanState::shared_prefetch_iterator, SpinLockAcquire, SpinLockRelease, tbm_iterate(), and tbm_shared_iterate().

Referenced by BitmapHeapNext().

◆ BitmapAdjustPrefetchTarget()

static void BitmapAdjustPrefetchTarget ( BitmapHeapScanState * node )

inlinestatic

Definition at line 409 of file nodeBitmapHeapscan.c.

 {
 #ifdef USE_PREFETCH
     ParallelBitmapHeapState *pstate = node->pstate;
  
     if (pstate == NULL)
     {
         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++;
         return;
     }
  
     /* Do an unlocked check first to save spinlock acquisitions. */
     if (pstate->prefetch_target < node->prefetch_maximum)
     {
         SpinLockAcquire(&pstate->mutex);
         if (pstate->prefetch_target >= node->prefetch_maximum)
              /* don't increase any further */ ;
         else if (pstate->prefetch_target >= node->prefetch_maximum / 2)
             pstate->prefetch_target = node->prefetch_maximum;
         else if (pstate->prefetch_target > 0)
             pstate->prefetch_target *= 2;
         else
             pstate->prefetch_target++;
         SpinLockRelease(&pstate->mutex);
     }
 #endif                          /* USE_PREFETCH */
 }

References ParallelBitmapHeapState::mutex, BitmapHeapScanState::prefetch_maximum, ParallelBitmapHeapState::prefetch_target, BitmapHeapScanState::prefetch_target, BitmapHeapScanState::pstate, SpinLockAcquire, and SpinLockRelease.

Referenced by BitmapHeapNext().

◆ BitmapDoneInitializingSharedState()

static void BitmapDoneInitializingSharedState ( ParallelBitmapHeapState * pstate )

inlinestatic

Definition at line 332 of file nodeBitmapHeapscan.c.

 {
     SpinLockAcquire(&pstate->mutex);
     pstate->state = BM_FINISHED;
     SpinLockRelease(&pstate->mutex);
     ConditionVariableBroadcast(&pstate->cv);
 }

References BM_FINISHED, ConditionVariableBroadcast(), ParallelBitmapHeapState::cv, ParallelBitmapHeapState::mutex, SpinLockAcquire, SpinLockRelease, and ParallelBitmapHeapState::state.

Referenced by BitmapHeapNext().

◆ BitmapHeapNext()

static TupleTableSlot * BitmapHeapNext ( BitmapHeapScanState * node )

static

Definition at line 69 of file nodeBitmapHeapscan.c.

 {
     ExprContext *econtext;
     TableScanDesc scan;
     TIDBitmap  *tbm;
     TBMIterator *tbmiterator = NULL;
     TBMSharedIterator *shared_tbmiterator = NULL;
     TBMIterateResult *tbmres;
     TupleTableSlot *slot;
     ParallelBitmapHeapState *pstate = node->pstate;
     dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
  
     /*
      * extract necessary information from index scan node
      */
     econtext = node->ss.ps.ps_ExprContext;
     slot = node->ss.ss_ScanTupleSlot;
     scan = node->ss.ss_currentScanDesc;
     tbm = node->tbm;
     if (pstate == NULL)
         tbmiterator = node->tbmiterator;
     else
         shared_tbmiterator = node->shared_tbmiterator;
     tbmres = node->tbmres;
  
     /*
      * If we haven't yet performed the underlying index scan, do it, and begin
      * the iteration over the bitmap.
      *
      * For prefetching, we use *two* iterators, one for the pages we are
      * actually scanning and another that runs ahead of the first for
      * prefetching.  node->prefetch_pages tracks exactly how many pages ahead
      * the prefetch iterator is.  Also, node->prefetch_target tracks the
      * desired prefetch distance, which starts small and increases up to the
      * node->prefetch_maximum.  This is to avoid doing a lot of prefetching in
      * a scan that stops after a few tuples because of a LIMIT.
      */
     if (!node->initialized)
     {
         if (!pstate)
         {
             tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node));
  
             if (!tbm || !IsA(tbm, TIDBitmap))
                 elog(ERROR, "unrecognized result from subplan");
  
             node->tbm = tbm;
             node->tbmiterator = tbmiterator = tbm_begin_iterate(tbm);
             node->tbmres = tbmres = NULL;
  
 #ifdef USE_PREFETCH
             if (node->prefetch_maximum > 0)
             {
                 node->prefetch_iterator = tbm_begin_iterate(tbm);
                 node->prefetch_pages = 0;
                 node->prefetch_target = -1;
             }
 #endif                          /* USE_PREFETCH */
         }
         else
         {
             /*
              * The leader will immediately come out of the function, but
              * others will be blocked until leader populates the TBM and wakes
              * them up.
              */
             if (BitmapShouldInitializeSharedState(pstate))
             {
                 tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node));
                 if (!tbm || !IsA(tbm, TIDBitmap))
                     elog(ERROR, "unrecognized result from subplan");
  
                 node->tbm = tbm;
  
                 /*
                  * Prepare to iterate over the TBM. This will return the
                  * dsa_pointer of the iterator state which will be used by
                  * multiple processes to iterate jointly.
                  */
                 pstate->tbmiterator = tbm_prepare_shared_iterate(tbm);
 #ifdef USE_PREFETCH
                 if (node->prefetch_maximum > 0)
                 {
                     pstate->prefetch_iterator =
                         tbm_prepare_shared_iterate(tbm);
  
                     /*
                      * We don't need the mutex here as we haven't yet woke up
                      * others.
                      */
                     pstate->prefetch_pages = 0;
                     pstate->prefetch_target = -1;
                 }
 #endif
  
                 /* We have initialized the shared state so wake up others. */
                 BitmapDoneInitializingSharedState(pstate);
             }
  
             /* Allocate a private iterator and attach the shared state to it */
             node->shared_tbmiterator = shared_tbmiterator =
                 tbm_attach_shared_iterate(dsa, pstate->tbmiterator);
             node->tbmres = tbmres = NULL;
  
 #ifdef USE_PREFETCH
             if (node->prefetch_maximum > 0)
             {
                 node->shared_prefetch_iterator =
                     tbm_attach_shared_iterate(dsa, pstate->prefetch_iterator);
             }
 #endif                          /* USE_PREFETCH */
         }
  
         /*
          * If this is the first scan of the underlying table, create the table
          * scan descriptor and begin the scan.
          */
         if (!scan)
         {
             bool        need_tuples = false;
  
             /*
              * We can potentially skip fetching heap pages if we do not need
              * any columns of the table, either for checking non-indexable
              * quals or for returning data.  This test is a bit simplistic, as
              * it checks the stronger condition that there's no qual or return
              * tlist at all. But in most cases it's probably not worth working
              * harder than that.
              */
             need_tuples = (node->ss.ps.plan->qual != NIL ||
                            node->ss.ps.plan->targetlist != NIL);
  
             scan = table_beginscan_bm(node->ss.ss_currentRelation,
                                       node->ss.ps.state->es_snapshot,
                                       0,
                                       NULL,
                                       need_tuples);
  
             node->ss.ss_currentScanDesc = scan;
         }
  
         node->initialized = true;
     }
  
     for (;;)
     {
         bool        valid_block;
  
         CHECK_FOR_INTERRUPTS();
  
         /*
          * Get next page of results if needed
          */
         if (tbmres == NULL)
         {
             if (!pstate)
                 node->tbmres = tbmres = tbm_iterate(tbmiterator);
             else
                 node->tbmres = tbmres = tbm_shared_iterate(shared_tbmiterator);
             if (tbmres == NULL)
             {
                 /* no more entries in the bitmap */
                 break;
             }
  
             BitmapAdjustPrefetchIterator(node, tbmres->blockno);
  
             valid_block = table_scan_bitmap_next_block(scan, tbmres);
  
             if (tbmres->ntuples >= 0)
                 node->exact_pages++;
             else
                 node->lossy_pages++;
  
             if (!valid_block)
             {
                 /* AM doesn't think this block is valid, skip */
                 continue;
             }
  
             /* Adjust the prefetch target */
             BitmapAdjustPrefetchTarget(node);
         }
         else
         {
             /*
              * Continuing in previously obtained page.
              */
  
 #ifdef USE_PREFETCH
  
             /*
              * Try to prefetch at least a few pages even before we get to the
              * second page if we don't stop reading after the first tuple.
              */
             if (!pstate)
             {
                 if (node->prefetch_target < node->prefetch_maximum)
                     node->prefetch_target++;
             }
             else if (pstate->prefetch_target < node->prefetch_maximum)
             {
                 /* take spinlock while updating shared state */
                 SpinLockAcquire(&pstate->mutex);
                 if (pstate->prefetch_target < node->prefetch_maximum)
                     pstate->prefetch_target++;
                 SpinLockRelease(&pstate->mutex);
             }
 #endif                          /* 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
          * should happen only when we have determined there is still something
          * to do on the current page, else we may uselessly prefetch the same
          * page we are just about to request for real.
          */
         BitmapPrefetch(node, scan);
  
         /*
          * Attempt to fetch tuple from AM.
          */
         if (!table_scan_bitmap_next_tuple(scan, tbmres, slot))
         {
             /* nothing more to look at on this page */
             node->tbmres = tbmres = NULL;
             continue;
         }
  
         /*
          * If we are using lossy info, we have to recheck the qual conditions
          * at every tuple.
          */
         if (tbmres->recheck)
         {
             econtext->ecxt_scantuple = slot;
             if (!ExecQualAndReset(node->bitmapqualorig, econtext))
             {
                 /* Fails recheck, so drop it and loop back for another */
                 InstrCountFiltered2(node, 1);
                 ExecClearTuple(slot);
                 continue;
             }
         }
  
         /* OK to return this tuple */
         return slot;
     }
  
     /*
      * if we get here it means we are at the end of the scan..
      */
     return ExecClearTuple(slot);
 }

Referenced by ExecBitmapHeapScan().

◆ BitmapHeapRecheck()

static bool BitmapHeapRecheck	(	BitmapHeapScanState *	node,
		TupleTableSlot *	slot
	)

static

Definition at line 548 of file nodeBitmapHeapscan.c.

 {
     ExprContext *econtext;
  
     /*
      * extract necessary information from index scan node
      */
     econtext = node->ss.ps.ps_ExprContext;
  
     /* Does the tuple meet the original qual conditions? */
     econtext->ecxt_scantuple = slot;
     return ExecQualAndReset(node->bitmapqualorig, econtext);
 }

References BitmapHeapScanState::bitmapqualorig, ExprContext::ecxt_scantuple, ExecQualAndReset(), ScanState::ps, PlanState::ps_ExprContext, and BitmapHeapScanState::ss.

Referenced by ExecBitmapHeapScan().

◆ BitmapPrefetch()

static void BitmapPrefetch	(	BitmapHeapScanState *	node,
		TableScanDesc	scan
	)

inlinestatic

Definition at line 448 of file nodeBitmapHeapscan.c.

 {
 #ifdef USE_PREFETCH
     ParallelBitmapHeapState *pstate = node->pstate;
  
     if (pstate == NULL)
     {
         TBMIterator *prefetch_iterator = node->prefetch_iterator;
  
         if (prefetch_iterator)
         {
             while (node->prefetch_pages < node->prefetch_target)
             {
                 TBMIterateResult *tbmpre = tbm_iterate(prefetch_iterator);
                 bool        skip_fetch;
  
                 if (tbmpre == NULL)
                 {
                     /* No more pages to prefetch */
                     tbm_end_iterate(prefetch_iterator);
                     node->prefetch_iterator = NULL;
                     break;
                 }
                 node->prefetch_pages++;
  
                 /*
                  * If we expect not to have to actually read this heap page,
                  * skip this prefetch call, but continue to run the prefetch
                  * logic normally.  (Would it be better not to increment
                  * prefetch_pages?)
                  */
                 skip_fetch = (!(scan->rs_flags & SO_NEED_TUPLES) &&
                               !tbmpre->recheck &&
                               VM_ALL_VISIBLE(node->ss.ss_currentRelation,
                                              tbmpre->blockno,
                                              &node->pvmbuffer));
  
                 if (!skip_fetch)
                     PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno);
             }
         }
  
         return;
     }
  
     if (pstate->prefetch_pages < pstate->prefetch_target)
     {
         TBMSharedIterator *prefetch_iterator = node->shared_prefetch_iterator;
  
         if (prefetch_iterator)
         {
             while (1)
             {
                 TBMIterateResult *tbmpre;
                 bool        do_prefetch = false;
                 bool        skip_fetch;
  
                 /*
                  * Recheck under the mutex. If some other process has already
                  * done enough prefetching then we need not to do anything.
                  */
                 SpinLockAcquire(&pstate->mutex);
                 if (pstate->prefetch_pages < pstate->prefetch_target)
                 {
                     pstate->prefetch_pages++;
                     do_prefetch = true;
                 }
                 SpinLockRelease(&pstate->mutex);
  
                 if (!do_prefetch)
                     return;
  
                 tbmpre = tbm_shared_iterate(prefetch_iterator);
                 if (tbmpre == NULL)
                 {
                     /* No more pages to prefetch */
                     tbm_end_shared_iterate(prefetch_iterator);
                     node->shared_prefetch_iterator = NULL;
                     break;
                 }
  
                 /* As above, skip prefetch if we expect not to need page */
                 skip_fetch = (!(scan->rs_flags & SO_NEED_TUPLES) &&
                               !tbmpre->recheck &&
                               VM_ALL_VISIBLE(node->ss.ss_currentRelation,
                                              tbmpre->blockno,
                                              &node->pvmbuffer));
  
                 if (!skip_fetch)
                     PrefetchBuffer(scan->rs_rd, MAIN_FORKNUM, tbmpre->blockno);
             }
         }
     }
 #endif                          /* USE_PREFETCH */
 }

References TBMIterateResult::blockno, MAIN_FORKNUM, ParallelBitmapHeapState::mutex, BitmapHeapScanState::prefetch_iterator, ParallelBitmapHeapState::prefetch_pages, BitmapHeapScanState::prefetch_pages, ParallelBitmapHeapState::prefetch_target, BitmapHeapScanState::prefetch_target, PrefetchBuffer(), BitmapHeapScanState::pstate, BitmapHeapScanState::pvmbuffer, TBMIterateResult::recheck, TableScanDescData::rs_flags, TableScanDescData::rs_rd, BitmapHeapScanState::shared_prefetch_iterator, SO_NEED_TUPLES, SpinLockAcquire, SpinLockRelease, BitmapHeapScanState::ss, ScanState::ss_currentRelation, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_iterate(), tbm_shared_iterate(), and VM_ALL_VISIBLE.

Referenced by BitmapHeapNext().

◆ BitmapShouldInitializeSharedState()

static bool BitmapShouldInitializeSharedState ( ParallelBitmapHeapState * pstate )

static

Definition at line 770 of file nodeBitmapHeapscan.c.

 {
     SharedBitmapState state;
  
     while (1)
     {
         SpinLockAcquire(&pstate->mutex);
         state = pstate->state;
         if (pstate->state == BM_INITIAL)
             pstate->state = BM_INPROGRESS;
         SpinLockRelease(&pstate->mutex);
  
         /* Exit if bitmap is done, or if we're the leader. */
         if (state != BM_INPROGRESS)
             break;
  
         /* Wait for the leader to wake us up. */
         ConditionVariableSleep(&pstate->cv, WAIT_EVENT_PARALLEL_BITMAP_SCAN);
     }
  
     ConditionVariableCancelSleep();
  
     return (state == BM_INITIAL);
 }

References BM_INITIAL, BM_INPROGRESS, ConditionVariableCancelSleep(), ConditionVariableSleep(), ParallelBitmapHeapState::cv, ParallelBitmapHeapState::mutex, SpinLockAcquire, SpinLockRelease, and ParallelBitmapHeapState::state.

Referenced by BitmapHeapNext().

◆ ExecBitmapHeapEstimate()

void ExecBitmapHeapEstimate	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 803 of file nodeBitmapHeapscan.c.

 {
     shm_toc_estimate_chunk(&pcxt->estimator, sizeof(ParallelBitmapHeapState));
     shm_toc_estimate_keys(&pcxt->estimator, 1);
 }

References ParallelContext::estimator, shm_toc_estimate_chunk, and shm_toc_estimate_keys.

Referenced by ExecParallelEstimate().

◆ ExecBitmapHeapInitializeDSM()

void ExecBitmapHeapInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 817 of file nodeBitmapHeapscan.c.

 {
     ParallelBitmapHeapState *pstate;
     dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
  
     /* If there's no DSA, there are no workers; initialize nothing. */
     if (dsa == NULL)
         return;
  
     pstate = shm_toc_allocate(pcxt->toc, sizeof(ParallelBitmapHeapState));
  
     pstate->tbmiterator = 0;
     pstate->prefetch_iterator = 0;
  
     /* Initialize the mutex */
     SpinLockInit(&pstate->mutex);
     pstate->prefetch_pages = 0;
     pstate->prefetch_target = 0;
     pstate->state = BM_INITIAL;
  
     ConditionVariableInit(&pstate->cv);
  
     shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pstate);
     node->pstate = pstate;
 }

References BM_INITIAL, ConditionVariableInit(), ParallelBitmapHeapState::cv, EState::es_query_dsa, ParallelBitmapHeapState::mutex, PlanState::plan, Plan::plan_node_id, ParallelBitmapHeapState::prefetch_iterator, ParallelBitmapHeapState::prefetch_pages, ParallelBitmapHeapState::prefetch_target, ScanState::ps, BitmapHeapScanState::pstate, shm_toc_allocate(), shm_toc_insert(), SpinLockInit, BitmapHeapScanState::ss, PlanState::state, ParallelBitmapHeapState::state, ParallelBitmapHeapState::tbmiterator, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

◆ ExecBitmapHeapInitializeWorker()

void ExecBitmapHeapInitializeWorker	(	BitmapHeapScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 880 of file nodeBitmapHeapscan.c.

 {
     ParallelBitmapHeapState *pstate;
  
     Assert(node->ss.ps.state->es_query_dsa != NULL);
  
     pstate = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false);
     node->pstate = pstate;
 }

References Assert, EState::es_query_dsa, PlanState::plan, Plan::plan_node_id, ScanState::ps, BitmapHeapScanState::pstate, shm_toc_lookup(), BitmapHeapScanState::ss, PlanState::state, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

◆ ExecBitmapHeapReInitializeDSM()

void ExecBitmapHeapReInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 851 of file nodeBitmapHeapscan.c.

 {
     ParallelBitmapHeapState *pstate = node->pstate;
     dsa_area   *dsa = node->ss.ps.state->es_query_dsa;
  
     /* If there's no DSA, there are no workers; do nothing. */
     if (dsa == NULL)
         return;
  
     pstate->state = BM_INITIAL;
  
     if (DsaPointerIsValid(pstate->tbmiterator))
         tbm_free_shared_area(dsa, pstate->tbmiterator);
  
     if (DsaPointerIsValid(pstate->prefetch_iterator))
         tbm_free_shared_area(dsa, pstate->prefetch_iterator);
  
     pstate->tbmiterator = InvalidDsaPointer;
     pstate->prefetch_iterator = InvalidDsaPointer;
 }

References BM_INITIAL, DsaPointerIsValid, EState::es_query_dsa, InvalidDsaPointer, ParallelBitmapHeapState::prefetch_iterator, ScanState::ps, BitmapHeapScanState::pstate, BitmapHeapScanState::ss, PlanState::state, ParallelBitmapHeapState::state, tbm_free_shared_area(), and ParallelBitmapHeapState::tbmiterator.

Referenced by ExecParallelReInitializeDSM().

◆ ExecBitmapHeapScan()

static TupleTableSlot* ExecBitmapHeapScan ( PlanState * pstate )

static

Definition at line 567 of file nodeBitmapHeapscan.c.

 {
     BitmapHeapScanState *node = castNode(BitmapHeapScanState, pstate);
  
     return ExecScan(&node->ss,
                     (ExecScanAccessMtd) BitmapHeapNext,
                     (ExecScanRecheckMtd) BitmapHeapRecheck);
 }

References BitmapHeapNext(), BitmapHeapRecheck(), castNode, ExecScan(), and BitmapHeapScanState::ss.

Referenced by ExecInitBitmapHeapScan().

◆ ExecEndBitmapHeapScan()

void ExecEndBitmapHeapScan ( BitmapHeapScanState * node )

Definition at line 626 of file nodeBitmapHeapscan.c.

 {
     TableScanDesc scanDesc;
  
     /*
      * extract information from the node
      */
     scanDesc = node->ss.ss_currentScanDesc;
  
     /*
      * close down subplans
      */
     ExecEndNode(outerPlanState(node));
  
     /*
      * release bitmaps and buffers if any
      */
     if (node->tbmiterator)
         tbm_end_iterate(node->tbmiterator);
     if (node->prefetch_iterator)
         tbm_end_iterate(node->prefetch_iterator);
     if (node->tbm)
         tbm_free(node->tbm);
     if (node->shared_tbmiterator)
         tbm_end_shared_iterate(node->shared_tbmiterator);
     if (node->shared_prefetch_iterator)
         tbm_end_shared_iterate(node->shared_prefetch_iterator);
     if (node->pvmbuffer != InvalidBuffer)
         ReleaseBuffer(node->pvmbuffer);
  
     /*
      * close heap scan
      */
     if (scanDesc)
         table_endscan(scanDesc);
  
 }

References ExecEndNode(), InvalidBuffer, outerPlanState, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::pvmbuffer, ReleaseBuffer(), BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, table_endscan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_free(), and BitmapHeapScanState::tbmiterator.

Referenced by ExecEndNode().

◆ ExecInitBitmapHeapScan()

BitmapHeapScanState* ExecInitBitmapHeapScan	(	BitmapHeapScan *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 671 of file nodeBitmapHeapscan.c.

 {
     BitmapHeapScanState *scanstate;
     Relation    currentRelation;
  
     /* check for unsupported flags */
     Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
  
     /*
      * Assert caller didn't ask for an unsafe snapshot --- see comments at
      * head of file.
      */
     Assert(IsMVCCSnapshot(estate->es_snapshot));
  
     /*
      * create state structure
      */
     scanstate = makeNode(BitmapHeapScanState);
     scanstate->ss.ps.plan = (Plan *) node;
     scanstate->ss.ps.state = estate;
     scanstate->ss.ps.ExecProcNode = ExecBitmapHeapScan;
  
     scanstate->tbm = NULL;
     scanstate->tbmiterator = NULL;
     scanstate->tbmres = NULL;
     scanstate->pvmbuffer = InvalidBuffer;
     scanstate->exact_pages = 0;
     scanstate->lossy_pages = 0;
     scanstate->prefetch_iterator = NULL;
     scanstate->prefetch_pages = 0;
     scanstate->prefetch_target = 0;
     scanstate->initialized = false;
     scanstate->shared_tbmiterator = NULL;
     scanstate->shared_prefetch_iterator = NULL;
     scanstate->pstate = NULL;
  
     /*
      * Miscellaneous initialization
      *
      * create expression context for node
      */
     ExecAssignExprContext(estate, &scanstate->ss.ps);
  
     /*
      * open the scan relation
      */
     currentRelation = ExecOpenScanRelation(estate, node->scan.scanrelid, eflags);
  
     /*
      * initialize child nodes
      */
     outerPlanState(scanstate) = ExecInitNode(outerPlan(node), estate, eflags);
  
     /*
      * get the scan type from the relation descriptor.
      */
     ExecInitScanTupleSlot(estate, &scanstate->ss,
                           RelationGetDescr(currentRelation),
                           table_slot_callbacks(currentRelation));
  
     /*
      * Initialize result type and projection.
      */
     ExecInitResultTypeTL(&scanstate->ss.ps);
     ExecAssignScanProjectionInfo(&scanstate->ss);
  
     /*
      * initialize child expressions
      */
     scanstate->ss.ps.qual =
         ExecInitQual(node->scan.plan.qual, (PlanState *) scanstate);
     scanstate->bitmapqualorig =
         ExecInitQual(node->bitmapqualorig, (PlanState *) scanstate);
  
     /*
      * Maximum number of prefetches for the tablespace if configured,
      * otherwise the current value of the effective_io_concurrency GUC.
      */
     scanstate->prefetch_maximum =
         get_tablespace_io_concurrency(currentRelation->rd_rel->reltablespace);
  
     scanstate->ss.ss_currentRelation = currentRelation;
  
     /*
      * all done.
      */
     return scanstate;
 }

Referenced by ExecInitNode().

◆ ExecReScanBitmapHeapScan()

void ExecReScanBitmapHeapScan ( BitmapHeapScanState * node )

Definition at line 581 of file nodeBitmapHeapscan.c.

 {
     PlanState  *outerPlan = outerPlanState(node);
  
     /* rescan to release any page pin */
     if (node->ss.ss_currentScanDesc)
         table_rescan(node->ss.ss_currentScanDesc, NULL);
  
     /* release bitmaps and buffers if any */
     if (node->tbmiterator)
         tbm_end_iterate(node->tbmiterator);
     if (node->prefetch_iterator)
         tbm_end_iterate(node->prefetch_iterator);
     if (node->shared_tbmiterator)
         tbm_end_shared_iterate(node->shared_tbmiterator);
     if (node->shared_prefetch_iterator)
         tbm_end_shared_iterate(node->shared_prefetch_iterator);
     if (node->tbm)
         tbm_free(node->tbm);
     if (node->pvmbuffer != InvalidBuffer)
         ReleaseBuffer(node->pvmbuffer);
     node->tbm = NULL;
     node->tbmiterator = NULL;
     node->tbmres = NULL;
     node->prefetch_iterator = NULL;
     node->initialized = false;
     node->shared_tbmiterator = NULL;
     node->shared_prefetch_iterator = NULL;
     node->pvmbuffer = InvalidBuffer;
  
     ExecScanReScan(&node->ss);
  
     /*
      * if chgParam of subnode is not null then plan will be re-scanned by
      * first ExecProcNode.
      */
     if (outerPlan->chgParam == NULL)
         ExecReScan(outerPlan);
 }

References ExecReScan(), ExecScanReScan(), BitmapHeapScanState::initialized, InvalidBuffer, outerPlan, outerPlanState, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::pvmbuffer, ReleaseBuffer(), BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, table_rescan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_free(), BitmapHeapScanState::tbmiterator, and BitmapHeapScanState::tbmres.

Referenced by ExecReScan().

Functions

Function Documentation

◆ BitmapAdjustPrefetchIterator()

◆ BitmapAdjustPrefetchTarget()

◆ BitmapDoneInitializingSharedState()

◆ BitmapHeapNext()

◆ BitmapHeapRecheck()

◆ BitmapPrefetch()

◆ BitmapShouldInitializeSharedState()

◆ ExecBitmapHeapEstimate()

◆ ExecBitmapHeapInitializeDSM()

◆ ExecBitmapHeapInitializeWorker()

◆ ExecBitmapHeapReInitializeDSM()

◆ ExecBitmapHeapScan()

◆ ExecEndBitmapHeapScan()

◆ ExecInitBitmapHeapScan()

◆ ExecReScanBitmapHeapScan()