nodeMemoize.h File Reference

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

Include dependency graph for nodeMemoize.h:

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

Go to the source code of this file.

Functions
MemoizeState *	ExecInitMemoize (Memoize *node, EState *estate, int eflags)
void	ExecEndMemoize (MemoizeState *node)
void	ExecReScanMemoize (MemoizeState *node)
double	ExecEstimateCacheEntryOverheadBytes (double ntuples)
void	ExecMemoizeEstimate (MemoizeState *node, ParallelContext *pcxt)
void	ExecMemoizeInitializeDSM (MemoizeState *node, ParallelContext *pcxt)
void	ExecMemoizeInitializeWorker (MemoizeState *node, ParallelWorkerContext *pwcxt)
void	ExecMemoizeRetrieveInstrumentation (MemoizeState *node)

Function Documentation

ExecEndMemoize()

void ExecEndMemoize

(

MemoizeState *

node

)

Definition at line 1041 of file nodeMemoize.c.

{
#ifdef USE_ASSERT_CHECKING
    /* Validate the memory accounting code is correct in assert builds. */
    {
        int         count;
        uint64      mem = 0;
        memoize_iterator i;
        MemoizeEntry *entry;
 
        memoize_start_iterate(node->hashtable, &i);
 
        count = 0;
        while ((entry = memoize_iterate(node->hashtable, &i)) != NULL)
        {
            MemoizeTuple *tuple = entry->tuplehead;
 
            mem += EMPTY_ENTRY_MEMORY_BYTES(entry);
            while (tuple != NULL)
            {
                mem += CACHE_TUPLE_BYTES(tuple);
                tuple = tuple->next;
            }
            count++;
        }
 
        Assert(count == node->hashtable->members);
        Assert(mem == node->mem_used);
    }
#endif
 
    /*
     * When ending a parallel worker, copy the statistics gathered by the
     * worker back into shared memory so that it can be picked up by the main
     * process to report in EXPLAIN ANALYZE.
     */
    if (node->shared_info != NULL && IsParallelWorker())
    {
        MemoizeInstrumentation *si;
 
        /* Make mem_peak available for EXPLAIN */
        if (node->stats.mem_peak == 0)
            node->stats.mem_peak = node->mem_used;
 
        Assert(ParallelWorkerNumber <= node->shared_info->num_workers);
        si = &node->shared_info->sinstrument[ParallelWorkerNumber];
        memcpy(si, &node->stats, sizeof(MemoizeInstrumentation));
    }
 
    /* Remove the cache context */
    MemoryContextDelete(node->tableContext);
 
    ExecClearTuple(node->ss.ss_ScanTupleSlot);
    /* must drop pointer to cache result tuple */
    ExecClearTuple(node->ss.ps.ps_ResultTupleSlot);
 
    /*
     * free exprcontext
     */
    ExecFreeExprContext(&node->ss.ps);
 
    /*
     * shut down the subplan
     */
    ExecEndNode(outerPlanState(node));

References Assert(), CACHE_TUPLE_BYTES, EMPTY_ENTRY_MEMORY_BYTES, ExecClearTuple(), ExecEndNode(), ExecFreeExprContext(), MemoizeState::hashtable, i, IsParallelWorker, MemoizeInstrumentation::mem_peak, MemoizeState::mem_used, MemoryContextDelete(), MemoizeTuple::next, outerPlanState, ParallelWorkerNumber, ScanState::ps, PlanState::ps_ResultTupleSlot, MemoizeState::shared_info, SharedMemoizeInfo::sinstrument, MemoizeState::ss, ScanState::ss_ScanTupleSlot, MemoizeState::stats, MemoizeState::tableContext, and MemoizeEntry::tuplehead.

Referenced by ExecEndNode().

ExecEstimateCacheEntryOverheadBytes()

double ExecEstimateCacheEntryOverheadBytes

(

double

ntuples

)

Definition at line 1141 of file nodeMemoize.c.

{
    return sizeof(MemoizeEntry) + sizeof(MemoizeKey) + sizeof(MemoizeTuple) *
        ntuples;

Referenced by cost_memoize_rescan().

ExecInitMemoize()

MemoizeState* ExecInitMemoize	(	Memoize *	node,
		EState *	estate,
		int	eflags
	)

Definition at line 916 of file nodeMemoize.c.

{
    MemoizeState *mstate = makeNode(MemoizeState);
    Plan       *outerNode;
    int         i;
    int         nkeys;
    Oid        *eqfuncoids;
 
    /* check for unsupported flags */
    Assert(!(eflags & (EXEC_FLAG_BACKWARD | EXEC_FLAG_MARK)));
 
    mstate->ss.ps.plan = (Plan *) node;
    mstate->ss.ps.state = estate;
    mstate->ss.ps.ExecProcNode = ExecMemoize;
 
    /*
     * Miscellaneous initialization
     *
     * create expression context for node
     */
    ExecAssignExprContext(estate, &mstate->ss.ps);
 
    outerNode = outerPlan(node);
    outerPlanState(mstate) = ExecInitNode(outerNode, estate, eflags);
 
    /*
     * Initialize return slot and type. No need to initialize projection info
     * because this node doesn't do projections.
     */
    ExecInitResultTupleSlotTL(&mstate->ss.ps, &TTSOpsMinimalTuple);
    mstate->ss.ps.ps_ProjInfo = NULL;
 
    /*
     * Initialize scan slot and type.
     */
    ExecCreateScanSlotFromOuterPlan(estate, &mstate->ss, &TTSOpsMinimalTuple);
 
    /*
     * Set the state machine to lookup the cache.  We won't find anything
     * until we cache something, but this saves a special case to create the
     * first entry.
     */
    mstate->mstatus = MEMO_CACHE_LOOKUP;
 
    mstate->nkeys = nkeys = node->numKeys;
    mstate->hashkeydesc = ExecTypeFromExprList(node->param_exprs);
    mstate->tableslot = MakeSingleTupleTableSlot(mstate->hashkeydesc,
                                                 &TTSOpsMinimalTuple);
    mstate->probeslot = MakeSingleTupleTableSlot(mstate->hashkeydesc,
                                                 &TTSOpsVirtual);
 
    mstate->param_exprs = (ExprState **) palloc(nkeys * sizeof(ExprState *));
    mstate->collations = node->collations;  /* Just point directly to the plan
                                             * data */
    mstate->hashfunctions = (FmgrInfo *) palloc(nkeys * sizeof(FmgrInfo));
 
    eqfuncoids = palloc(nkeys * sizeof(Oid));
 
    for (i = 0; i < nkeys; i++)
    {
        Oid         hashop = node->hashOperators[i];
        Oid         left_hashfn;
        Oid         right_hashfn;
        Expr       *param_expr = (Expr *) list_nth(node->param_exprs, i);
 
        if (!get_op_hash_functions(hashop, &left_hashfn, &right_hashfn))
            elog(ERROR, "could not find hash function for hash operator %u",
                 hashop);
 
        fmgr_info(left_hashfn, &mstate->hashfunctions[i]);
 
        mstate->param_exprs[i] = ExecInitExpr(param_expr, (PlanState *) mstate);
        eqfuncoids[i] = get_opcode(hashop);
    }
 
    mstate->cache_eq_expr = ExecBuildParamSetEqual(mstate->hashkeydesc,
                                                   &TTSOpsMinimalTuple,
                                                   &TTSOpsVirtual,
                                                   eqfuncoids,
                                                   node->collations,
                                                   node->param_exprs,
                                                   (PlanState *) mstate);
 
    pfree(eqfuncoids);
    mstate->mem_used = 0;
 
    /* Limit the total memory consumed by the cache to this */
    mstate->mem_limit = get_hash_memory_limit();
 
    /* A memory context dedicated for the cache */
    mstate->tableContext = AllocSetContextCreate(CurrentMemoryContext,
                                                 "MemoizeHashTable",
                                                 ALLOCSET_DEFAULT_SIZES);
 
    dlist_init(&mstate->lru_list);
    mstate->last_tuple = NULL;
    mstate->entry = NULL;
 
    /*
     * Mark if we can assume the cache entry is completed after we get the
     * first record for it.  Some callers might not call us again after
     * getting the first match. e.g. A join operator performing a unique join
     * is able to skip to the next outer tuple after getting the first
     * matching inner tuple.  In this case, the cache entry is complete after
     * getting the first tuple.  This allows us to mark it as so.
     */
    mstate->singlerow = node->singlerow;
    mstate->keyparamids = node->keyparamids;
 
    /*
     * Record if the cache keys should be compared bit by bit, or logically
     * using the type's hash equality operator
     */
    mstate->binary_mode = node->binary_mode;
 
    /* Zero the statistics counters */
    memset(&mstate->stats, 0, sizeof(MemoizeInstrumentation));
 
    /* Allocate and set up the actual cache */
    build_hash_table(mstate, node->est_entries);
 
    return mstate;

References ALLOCSET_DEFAULT_SIZES, AllocSetContextCreate, Assert(), MemoizeState::binary_mode, Memoize::binary_mode, build_hash_table(), MemoizeState::cache_eq_expr, MemoizeState::collations, CurrentMemoryContext, dlist_init(), elog(), MemoizeState::entry, ERROR, Memoize::est_entries, EXEC_FLAG_BACKWARD, EXEC_FLAG_MARK, ExecAssignExprContext(), ExecBuildParamSetEqual(), ExecCreateScanSlotFromOuterPlan(), ExecInitExpr(), ExecInitNode(), ExecInitResultTupleSlotTL(), ExecMemoize(), PlanState::ExecProcNode, ExecTypeFromExprList(), fmgr_info(), get_hash_memory_limit(), get_op_hash_functions(), get_opcode(), MemoizeState::hashfunctions, MemoizeState::hashkeydesc, i, MemoizeState::keyparamids, Memoize::keyparamids, MemoizeState::last_tuple, list_nth(), MemoizeState::lru_list, makeNode, MakeSingleTupleTableSlot(), MemoizeState::mem_limit, MemoizeState::mem_used, MEMO_CACHE_LOOKUP, MemoizeState::mstatus, MemoizeState::nkeys, Memoize::numKeys, outerPlan, outerPlanState, palloc(), MemoizeState::param_exprs, Memoize::param_exprs, pfree(), PlanState::plan, MemoizeState::probeslot, ScanState::ps, PlanState::ps_ProjInfo, MemoizeState::singlerow, Memoize::singlerow, MemoizeState::ss, PlanState::state, MemoizeState::stats, MemoizeState::tableContext, MemoizeState::tableslot, TTSOpsMinimalTuple, and TTSOpsVirtual.

Referenced by ExecInitNode().

ExecMemoizeEstimate()

void ExecMemoizeEstimate	(	MemoizeState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1159 of file nodeMemoize.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(MemoizeInstrumentation));
    size = add_size(size, offsetof(SharedMemoizeInfo, sinstrument));
    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 MemoizeState::ss.

Referenced by ExecParallelEstimate().

ExecMemoizeInitializeDSM()

void ExecMemoizeInitializeDSM	(	MemoizeState *	node,
		ParallelContext *	pcxt
	)

Definition at line 1180 of file nodeMemoize.c.

{
    Size        size;
 
    /* don't need this if not instrumenting or no workers */
    if (!node->ss.ps.instrument || pcxt->nworkers == 0)
        return;
 
    size = offsetof(SharedMemoizeInfo, sinstrument)
        + pcxt->nworkers * sizeof(MemoizeInstrumentation);
    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, SharedMemoizeInfo::num_workers, ParallelContext::nworkers, PlanState::plan, Plan::plan_node_id, ScanState::ps, MemoizeState::shared_info, shm_toc_allocate(), shm_toc_insert(), MemoizeState::ss, and ParallelContext::toc.

Referenced by ExecParallelInitializeDSM().

ExecMemoizeInitializeWorker()

void ExecMemoizeInitializeWorker	(	MemoizeState *	node,
		ParallelWorkerContext *	pwcxt
	)

Definition at line 1205 of file nodeMemoize.c.

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

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

Referenced by ExecParallelInitializeWorker().

ExecMemoizeRetrieveInstrumentation()

void ExecMemoizeRetrieveInstrumentation

(

MemoizeState *

node

)

Definition at line 1218 of file nodeMemoize.c.

{
    Size        size;
    SharedMemoizeInfo *si;
 
    if (node->shared_info == NULL)
        return;
 
    size = offsetof(SharedMemoizeInfo, sinstrument)
        + node->shared_info->num_workers * sizeof(MemoizeInstrumentation);
    si = palloc(size);
    memcpy(si, node->shared_info, size);
    node->shared_info = si;

References SharedMemoizeInfo::num_workers, palloc(), and MemoizeState::shared_info.

Referenced by ExecParallelRetrieveInstrumentation().

ExecReScanMemoize()

void ExecReScanMemoize

(

MemoizeState *

node

)

Definition at line 1109 of file nodeMemoize.c.

{
    PlanState  *outerPlan = outerPlanState(node);
 
    /* Mark that we must lookup the cache for a new set of parameters */
    node->mstatus = MEMO_CACHE_LOOKUP;
 
    /* nullify pointers used for the last scan */
    node->entry = NULL;
    node->last_tuple = NULL;
 
    /*
     * if chgParam of subnode is not null then plan will be re-scanned by
     * first ExecProcNode.
     */
    if (outerPlan->chgParam == NULL)
        ExecReScan(outerPlan);
 
    /*
     * Purge the entire cache if a parameter changed that is not part of the
     * cache key.
     */
    if (bms_nonempty_difference(outerPlan->chgParam, node->keyparamids))
        cache_purge_all(node);

References bms_nonempty_difference(), cache_purge_all(), MemoizeState::entry, ExecReScan(), MemoizeState::keyparamids, MemoizeState::last_tuple, MEMO_CACHE_LOOKUP, MemoizeState::mstatus, outerPlan, and outerPlanState.

Referenced by ExecReScan().