nodeIncrementalSort.h File Reference

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

Include dependency graph for nodeIncrementalSort.h:

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

Go to the source code of this file.

Functions
IncrementalSortState *	ExecInitIncrementalSort (IncrementalSort *node, EState *estate, int eflags)
void	ExecEndIncrementalSort (IncrementalSortState *node)
void	ExecReScanIncrementalSort (IncrementalSortState *node)
void	ExecIncrementalSortEstimate (IncrementalSortState *node, ParallelContext *pcxt)
void	ExecIncrementalSortInitializeDSM (IncrementalSortState *node, ParallelContext *pcxt)
void	ExecIncrementalSortInitializeWorker (IncrementalSortState *node, ParallelWorkerContext *pwcxt)
void	ExecIncrementalSortRetrieveInstrumentation (IncrementalSortState *node)

Function Documentation

ExecEndIncrementalSort()

void ExecEndIncrementalSort

(

IncrementalSortState *

node

)

Definition at line 1077 of file nodeIncrementalSort.c.

{
    SO_printf("ExecEndIncrementalSort: shutting down sort node\n");
 
    ExecDropSingleTupleTableSlot(node->group_pivot);
    ExecDropSingleTupleTableSlot(node->transfer_tuple);
 
    /*
     * Release tuplesort resources.
     */
    if (node->fullsort_state != NULL)
    {
        tuplesort_end(node->fullsort_state);
        node->fullsort_state = NULL;
    }
    if (node->prefixsort_state != NULL)
    {
        tuplesort_end(node->prefixsort_state);
        node->prefixsort_state = NULL;
    }
 
    /*
     * Shut down the subplan.
     */
    ExecEndNode(outerPlanState(node));
 
    SO_printf("ExecEndIncrementalSort: sort node shutdown\n");
}

References ExecDropSingleTupleTableSlot(), ExecEndNode(), IncrementalSortState::fullsort_state, IncrementalSortState::group_pivot, outerPlanState, IncrementalSortState::prefixsort_state, SO_printf, IncrementalSortState::transfer_tuple, and tuplesort_end().

Referenced by ExecEndNode().

ExecIncrementalSortEstimate()

void ExecIncrementalSortEstimate	(	IncrementalSortState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1173 of file nodeIncrementalSort.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = mul_size(pcxt->nworkers, sizeof(IncrementalSortInfo));
    size = add_size(size, offsetof(SharedIncrementalSortInfo, sinfo));
    shm_toc_estimate_chunk(&pcxt->estimator, size);
    shm_toc_estimate_keys(&pcxt->estimator, 1);
}

References add_size(), ParallelContext::estimator, PlanState::instrument, mul_size(), ParallelContext::nworkers, ScanState::ps, shm_toc_estimate_chunk, shm_toc_estimate_keys, and IncrementalSortState::ss.

Referenced by ExecParallelEstimate().

ExecIncrementalSortInitializeDSM()

void ExecIncrementalSortInitializeDSM	(	IncrementalSortState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1194 of file nodeIncrementalSort.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = offsetof(SharedIncrementalSortInfo, sinfo)
        + pcxt->nworkers * sizeof(IncrementalSortInfo);
    node->shared_info = shm_toc_allocate(pcxt->toc, size);
    /* ensure any unfilled slots will contain zeroes */
    memset(node->shared_info, 0, size);
    node->shared_info->num_workers = pcxt->nworkers;
    shm_toc_insert(pcxt->toc, node->ss.ps.plan->plan_node_id,
                   node->shared_info);
}

References PlanState::instrument, SharedIncrementalSortInfo::num_workers, ParallelContext::nworkers, PlanState::plan, Plan::plan_node_id, ScanState::ps, IncrementalSortState::shared_info, shm_toc_allocate(), shm_toc_insert(), IncrementalSortState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecIncrementalSortInitializeWorker()

void ExecIncrementalSortInitializeWorker	(	IncrementalSortState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 1219 of file nodeIncrementalSort.c.

{
    node->shared_info =
        shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, true);
    node->am_worker = true;
}

References IncrementalSortState::am_worker, PlanState::plan, Plan::plan_node_id, ScanState::ps, IncrementalSortState::shared_info, shm_toc_lookup(), IncrementalSortState::ss, and ParallelWorkerContext::toc.

Referenced by ExecParallelInitializeWorker().

ExecIncrementalSortRetrieveInstrumentation()

void ExecIncrementalSortRetrieveInstrumentation

(

IncrementalSortState *

node

)

Definition at line 1233 of file nodeIncrementalSort.c.

{
    Size        size;
    SharedIncrementalSortInfo *si;
 
    if (node->shared_info == NULL)
        return;
 
    size = offsetof(SharedIncrementalSortInfo, sinfo)
        + node->shared_info->num_workers * sizeof(IncrementalSortInfo);
    si = palloc(size);
    memcpy(si, node->shared_info, size);
    node->shared_info = si;
}

References SharedIncrementalSortInfo::num_workers, palloc(), and IncrementalSortState::shared_info.

Referenced by ExecParallelRetrieveInstrumentation().

ExecInitIncrementalSort()

IncrementalSortState * ExecInitIncrementalSort	(	IncrementalSort *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 976 of file nodeIncrementalSort.c.

{
    IncrementalSortState *incrsortstate;
 
    SO_printf("ExecInitIncrementalSort: initializing sort node\n");
 
    /*
     * Incremental sort can't be used with EXEC_FLAG_BACKWARD or
     * EXEC_FLAG_MARK, because the current sort state contains only one sort
     * batch rather than the full result set.
     */
    Assert((eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)) == 0);
 
    /* Initialize state structure. */
    incrsortstate = makeNode(IncrementalSortState);
    incrsortstate->ss.ps.plan = (Plan *) node;
    incrsortstate->ss.ps.state = estate;
    incrsortstate->ss.ps.ExecProcNode = ExecIncrementalSort;
 
    incrsortstate->execution_status = INCSORT_LOADFULLSORT;
    incrsortstate->bounded = false;
    incrsortstate->outerNodeDone = false;
    incrsortstate->bound_Done = 0;
    incrsortstate->fullsort_state = NULL;
    incrsortstate->prefixsort_state = NULL;
    incrsortstate->group_pivot = NULL;
    incrsortstate->transfer_tuple = NULL;
    incrsortstate->n_fullsort_remaining = 0;
    incrsortstate->presorted_keys = NULL;
 
    if (incrsortstate->ss.ps.instrument != NULL)
    {
        IncrementalSortGroupInfo *fullsortGroupInfo =
            &incrsortstate->incsort_info.fullsortGroupInfo;
        IncrementalSortGroupInfo *prefixsortGroupInfo =
            &incrsortstate->incsort_info.prefixsortGroupInfo;
 
        fullsortGroupInfo->groupCount = 0;
        fullsortGroupInfo->maxDiskSpaceUsed = 0;
        fullsortGroupInfo->totalDiskSpaceUsed = 0;
        fullsortGroupInfo->maxMemorySpaceUsed = 0;
        fullsortGroupInfo->totalMemorySpaceUsed = 0;
        fullsortGroupInfo->sortMethods = 0;
        prefixsortGroupInfo->groupCount = 0;
        prefixsortGroupInfo->maxDiskSpaceUsed = 0;
        prefixsortGroupInfo->totalDiskSpaceUsed = 0;
        prefixsortGroupInfo->maxMemorySpaceUsed = 0;
        prefixsortGroupInfo->totalMemorySpaceUsed = 0;
        prefixsortGroupInfo->sortMethods = 0;
    }
 
    /*
     * Miscellaneous initialization
     *
     * Sort nodes don't initialize their ExprContexts because they never call
     * ExecQual or ExecProject.
     */
 
    /*
     * Initialize child nodes.
     *
     * Incremental sort does not support backwards scans and mark/restore, so
     * we don't bother removing the flags from eflags here. We allow passing a
     * REWIND flag, because although incremental sort can't use it, the child
     * nodes may be able to do something more useful.
     */
    outerPlanState(incrsortstate) = ExecInitNode(outerPlan(node), estate, eflags);
 
    /*
     * Initialize scan slot and type.
     */
    ExecCreateScanSlotFromOuterPlan(estate, &incrsortstate->ss, &TTSOpsMinimalTuple);
 
    /*
     * Initialize return slot and type. No need to initialize projection info
     * because we don't do any projections.
     */
    ExecInitResultTupleSlotTL(&incrsortstate->ss.ps, &TTSOpsMinimalTuple);
    incrsortstate->ss.ps.ps_ProjInfo = NULL;
 
    /*
     * Initialize standalone slots to store a tuple for pivot prefix keys and
     * for carrying over a tuple from one batch to the next.
     */
    incrsortstate->group_pivot =
        MakeSingleTupleTableSlot(ExecGetResultType(outerPlanState(incrsortstate)),
                                 &TTSOpsMinimalTuple);
    incrsortstate->transfer_tuple =
        MakeSingleTupleTableSlot(ExecGetResultType(outerPlanState(incrsortstate)),
                                 &TTSOpsMinimalTuple);
 
    SO_printf("ExecInitIncrementalSort: sort node initialized\n");
 
    return incrsortstate;
}

References Assert(), IncrementalSortState::bound_Done, IncrementalSortState::bounded, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecCreateScanSlotFromOuterPlan(), ExecGetResultType(), ExecIncrementalSort(), ExecInitNode(), ExecInitResultTupleSlotTL(), PlanState::ExecProcNode, IncrementalSortState::execution_status, IncrementalSortState::fullsort_state, IncrementalSortInfo::fullsortGroupInfo, IncrementalSortState::group_pivot, IncrementalSortGroupInfo::groupCount, IncrementalSortState::incsort_info, INCSORT_LOADFULLSORT, PlanState::instrument, makeNode, MakeSingleTupleTableSlot(), IncrementalSortGroupInfo::maxDiskSpaceUsed, IncrementalSortGroupInfo::maxMemorySpaceUsed, IncrementalSortState::n_fullsort_remaining, IncrementalSortState::outerNodeDone, outerPlan, outerPlanState, PlanState::plan, IncrementalSortState::prefixsort_state, IncrementalSortInfo::prefixsortGroupInfo, IncrementalSortState::presorted_keys, ScanState::ps, PlanState::ps_ProjInfo, SO_printf, IncrementalSortGroupInfo::sortMethods, IncrementalSortState::ss, PlanState::state, IncrementalSortGroupInfo::totalDiskSpaceUsed, IncrementalSortGroupInfo::totalMemorySpaceUsed, IncrementalSortState::transfer_tuple, and TTSOpsMinimalTuple.

Referenced by ExecInitNode().

ExecReScanIncrementalSort()

void ExecReScanIncrementalSort

(

IncrementalSortState *

node

)

Definition at line 1107 of file nodeIncrementalSort.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /*
     * Incremental sort doesn't support efficient rescan even when parameters
     * haven't changed (e.g., rewind) because unlike regular sort we don't
     * store all tuples at once for the full sort.
     *
     * So even if EXEC_FLAG_REWIND is set we just reset all of our state and
     * re-execute the sort along with the child node. Incremental sort itself
     * can't do anything smarter, but maybe the child nodes can.
     *
     * In theory if we've only filled the full sort with one batch (and
     * haven't reset it for a new batch yet) then we could efficiently rewind,
     * but that seems a narrow enough case that it's not worth handling
     * specially at this time.
     */
 
    /* must drop pointer to sort result tuple */
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    if (node->group_pivot != NULL)
        ExecClearTuple(node->group_pivot);
    if (node->transfer_tuple != NULL)
        ExecClearTuple(node->transfer_tuple);
 
    node->outerNodeDone = false;
    node->n_fullsort_remaining = 0;
    node->bound_Done = 0;
 
    node->execution_status = INCSORT_LOADFULLSORT;
 
    /*
     * If we've set up either of the sort states yet, we need to reset them.
     * We could end them and null out the pointers, but there's no reason to
     * repay the setup cost, and because ExecIncrementalSort guards presorted
     * column functions by checking to see if the full sort state has been
     * initialized yet, setting the sort states to null here might actually
     * cause a leak.
     */
    if (node->fullsort_state != NULL)
        tuplesort_reset(node->fullsort_state);
    if (node->prefixsort_state != NULL)
        tuplesort_reset(node->prefixsort_state);
 
    /*
     * If chgParam of subnode is not null, then the plan will be re-scanned by
     * the first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
}

References IncrementalSortState::bound_Done, ExecClearTuple(), ExecReScan(), IncrementalSortState::execution_status, IncrementalSortState::fullsort_state, IncrementalSortState::group_pivot, INCSORT_LOADFULLSORT, IncrementalSortState::n_fullsort_remaining, IncrementalSortState::outerNodeDone, outerPlan, outerPlanState, IncrementalSortState::prefixsort_state, ScanState::ps, PlanState::ps_ResultTupleSlot, IncrementalSortState::ss, IncrementalSortState::transfer_tuple, and tuplesort_reset().

Referenced by ExecReScan().