nodeBitmapHeapscan.h File Reference

#include "access/parallel.h"
#include "nodes/execnodes.h"

Include dependency graph for nodeBitmapHeapscan.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
BitmapHeapScanState *	ExecInitBitmapHeapScan (BitmapHeapScan *node, EState *estate, int eflags)
void	ExecEndBitmapHeapScan (BitmapHeapScanState *node)
void	ExecReScanBitmapHeapScan (BitmapHeapScanState *node)
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

ExecBitmapHeapEstimate()

void ExecBitmapHeapEstimate	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 868 of file nodeBitmapHeapscan.c.

References add_size(), EState::es_snapshot, EstimateSnapshotSpace(), ParallelContext::estimator, offsetof, ScanState::ps, BitmapHeapScanState::pscan_len, shm_toc_estimate_chunk, shm_toc_estimate_keys, BitmapHeapScanState::ss, and PlanState::state.

Referenced by ExecParallelEstimate().

{
    EState     *estate = node->ss.ps.state;

    node->pscan_len = add_size(offsetof(ParallelBitmapHeapState,
                                        phs_snapshot_data),
                               EstimateSnapshotSpace(estate->es_snapshot));

    shm_toc_estimate_chunk(&pcxt->estimator, node->pscan_len);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

ExecBitmapHeapInitializeDSM()

void ExecBitmapHeapInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 888 of file nodeBitmapHeapscan.c.

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

Referenced by ExecParallelInitializeDSM().

{
    ParallelBitmapHeapState *pstate;
    EState     *estate = node->ss.ps.state;
    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, node->pscan_len);

    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);
    SerializeSnapshot(estate->es_snapshot, pstate->phs_snapshot_data);

    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id, pstate);
    node->pstate = pstate;
}

ExecBitmapHeapInitializeWorker()

void ExecBitmapHeapInitializeWorker	(	BitmapHeapScanState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 953 of file nodeBitmapHeapscan.c.

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

Referenced by ExecParallelInitializeWorker().

{
    ParallelBitmapHeapState *pstate;
    Snapshot    snapshot;

    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;

    snapshot = RestoreSnapshot(pstate->phs_snapshot_data);
    table_scan_update_snapshot(node->ss.ss_currentScanDesc, snapshot);
}

ExecBitmapHeapReInitializeDSM()

void ExecBitmapHeapReInitializeDSM	(	BitmapHeapScanState *	node,
		ParallelContext *	pcxt
	)

Definition at line 924 of file nodeBitmapHeapscan.c.

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().

{
    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;
}

ExecEndBitmapHeapScan()

void ExecEndBitmapHeapScan

(

BitmapHeapScanState *

node

)

Definition at line 649 of file nodeBitmapHeapscan.c.

References ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), InvalidBuffer, outerPlanState, BitmapHeapScanState::prefetch_iterator, ScanState::ps, PlanState::ps_ResultTupleSlot, BitmapHeapScanState::pvmbuffer, ReleaseBuffer(), BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, ScanState::ss_currentScanDesc, ScanState::ss_ScanTupleSlot, table_endscan(), BitmapHeapScanState::tbm, tbm_end_iterate(), tbm_end_shared_iterate(), tbm_free(), BitmapHeapScanState::tbmiterator, and BitmapHeapScanState::vmbuffer.

Referenced by ExecEndNode().

{
    TableScanDesc scanDesc;

    /*
     * extract information from the node
     */
    scanDesc = node->ss.ss_currentScanDesc;

    /*
     * Free the exprcontext
     */
    ExecFreeExprContext(&node->ss.ps);

    /*
     * clear out tuple table slots
     */
    if (node->ss.ps.ps_ResultTupleSlot)
        ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
    ExecClearTuple(node->ss.ss_ScanTupleSlot);

    /*
     * 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->vmbuffer != InvalidBuffer)
        ReleaseBuffer(node->vmbuffer);
    if (node->pvmbuffer != InvalidBuffer)
        ReleaseBuffer(node->pvmbuffer);

    /*
     * close heap scan
     */
    table_endscan(scanDesc);
}

ExecInitBitmapHeapScan()

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

Definition at line 706 of file nodeBitmapHeapscan.c.

References Assert, BitmapHeapScan::bitmapqualorig, BitmapHeapScanState::can_skip_fetch, ComputeIoConcurrency(), effective_io_concurrency, EState::es_snapshot, BitmapHeapScanState::exact_pages, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecAssignScanProjectionInfo(), ExecBitmapHeapScan(), ExecInitNode(), ExecInitQual(), ExecInitResultTypeTL(), ExecInitScanTupleSlot(), ExecOpenScanRelation(), PlanState::ExecProcNode, get_tablespace_io_concurrency(), BitmapHeapScanState::initialized, InvalidBuffer, IsMVCCSnapshot, BitmapHeapScanState::lossy_pages, makeNode, NIL, outerPlan, outerPlanState, Scan::plan, PlanState::plan, BitmapHeapScanState::prefetch_iterator, BitmapHeapScanState::prefetch_maximum, BitmapHeapScanState::prefetch_pages, BitmapHeapScanState::prefetch_target, ScanState::ps, BitmapHeapScanState::pscan_len, BitmapHeapScanState::pstate, BitmapHeapScanState::pvmbuffer, Plan::qual, PlanState::qual, RelationData::rd_rel, RelationGetDescr, BitmapHeapScanState::return_empty_tuples, BitmapHeapScan::scan, Scan::scanrelid, BitmapHeapScanState::shared_prefetch_iterator, BitmapHeapScanState::shared_tbmiterator, BitmapHeapScanState::ss, PlanState::state, table_beginscan_bm(), table_slot_callbacks(), target_prefetch_pages, Plan::targetlist, BitmapHeapScanState::tbm, BitmapHeapScanState::tbmiterator, BitmapHeapScanState::tbmres, and BitmapHeapScanState::vmbuffer.

Referenced by ExecInitNode().

{
    BitmapHeapScanState *scanstate;
    Relation    currentRelation;
    int         io_concurrency;

    /* 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->return_empty_tuples = 0;
    scanstate->vmbuffer = InvalidBuffer;
    scanstate->pvmbuffer = InvalidBuffer;
    scanstate->exact_pages = 0;
    scanstate->lossy_pages = 0;
    scanstate->prefetch_iterator = NULL;
    scanstate->prefetch_pages = 0;
    scanstate->prefetch_target = 0;
    /* may be updated below */
    scanstate->prefetch_maximum = target_prefetch_pages;
    scanstate->pscan_len = 0;
    scanstate->initialized = false;
    scanstate->shared_tbmiterator = NULL;
    scanstate->shared_prefetch_iterator = NULL;
    scanstate->pstate = NULL;

    /*
     * 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.
     */
    scanstate->can_skip_fetch = (node->scan.plan.qual == NIL &&
                                 node->scan.plan.targetlist == NIL);

    /*
     * 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);

    /*
     * Determine the maximum for prefetch_target.  If the tablespace has a
     * specific IO concurrency set, use that to compute the corresponding
     * maximum value; otherwise, we already initialized to the value computed
     * by the GUC machinery.
     */
    io_concurrency =
        get_tablespace_io_concurrency(currentRelation->rd_rel->reltablespace);
    if (io_concurrency != effective_io_concurrency)
    {
        double      maximum;

        if (ComputeIoConcurrency(io_concurrency, &maximum))
            scanstate->prefetch_maximum = rint(maximum);
    }

    scanstate->ss.ss_currentRelation = currentRelation;

    scanstate->ss.ss_currentScanDesc = table_beginscan_bm(currentRelation,
                                                          estate->es_snapshot,
                                                          0,
                                                          NULL);

    /*
     * all done.
     */
    return scanstate;
}

ExecReScanBitmapHeapScan()

void ExecReScanBitmapHeapScan

(

BitmapHeapScanState *

node

)

Definition at line 602 of file nodeBitmapHeapscan.c.

References PlanState::chgParam, 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, BitmapHeapScanState::tbmres, and BitmapHeapScanState::vmbuffer.

Referenced by ExecReScan().

{
    PlanState  *outerPlan = outerPlanState(node);

    /* rescan to release any page pin */
    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->vmbuffer != InvalidBuffer)
        ReleaseBuffer(node->vmbuffer);
    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->vmbuffer = InvalidBuffer;
    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);
}