#include "postgres.h"
#include <unistd.h>
#include "executor/executor.h"
#include "executor/instrument.h"
#include "executor/tuptable.h"
#include "nodes/execnodes.h"
#include "portability/instr_time.h"
#include "utils/guc_hooks.h"

Include dependency graph for instrument.c:

Functions
static void	BufferUsageAdd (BufferUsage dst, const BufferUsage add)

static void	WalUsageAdd (WalUsage dst, WalUsage add)

Instrumentation *	InstrAlloc (int instrument_options)

void	InstrInitOptions (Instrumentation *instr, int instrument_options)

void	InstrStart (Instrumentation *instr)

static void	InstrStopCommon (Instrumentation instr, instr_time accum_time)

void	InstrStop (Instrumentation *instr)

NodeInstrumentation *	InstrAllocNode (int instrument_options, bool async_mode)

void	InstrInitNode (NodeInstrumentation *instr, int instrument_options, bool async_mode)

void	InstrStartNode (NodeInstrumentation *instr)

void	InstrStopNode (NodeInstrumentation *instr, double nTuples)

TupleTableSlot *	ExecProcNodeInstr (PlanState *node)

void	InstrUpdateTupleCount (NodeInstrumentation *instr, double nTuples)

void	InstrEndLoop (NodeInstrumentation *instr)

void	InstrAggNode (NodeInstrumentation dst, NodeInstrumentation add)

TriggerInstrumentation *	InstrAllocTrigger (int n, int instrument_options)

void	InstrStartTrigger (TriggerInstrumentation *tginstr)

void	InstrStopTrigger (TriggerInstrumentation *tginstr, int64 firings)

void	InstrStartParallelQuery (void)

void	InstrEndParallelQuery (BufferUsage bufusage, WalUsage walusage)

void	InstrAccumParallelQuery (BufferUsage bufusage, WalUsage walusage)

void	BufferUsageAccumDiff (BufferUsage dst, const BufferUsage add, const BufferUsage *sub)

void	WalUsageAccumDiff (WalUsage dst, const WalUsage add, const WalUsage *sub)

bool	check_timing_clock_source (int newval, void *extra, GucSource source)

void	assign_timing_clock_source (int newval, void *extra)

const char *	show_timing_clock_source (void)

Variables
BufferUsage	pgBufferUsage

static BufferUsage	save_pgBufferUsage

WalUsage	pgWalUsage

static WalUsage	save_pgWalUsage

Function Documentation

◆ assign_timing_clock_source()

void assign_timing_clock_source	(	int	newval,
		void *	extra
	)

Definition at line 409 of file instrument.c.

{
#ifdef EXEC_BACKEND
    if (!timing_initialized)
        return;
#else
    Assert(timing_initialized);
#endif
 
    /*
     * Ignore the return code since the check hook already verified TSC is
     * usable if it's explicitly requested.
     */
    pg_set_timing_clock_source(newval);
}

References Assert, newval, pg_set_timing_clock_source(), and timing_initialized.

◆ BufferUsageAccumDiff()

void BufferUsageAccumDiff	(	BufferUsage *	dst,
		const BufferUsage *	add,
		const BufferUsage *	sub
	)

inline

Definition at line 327 of file instrument.c.

{
    dst->shared_blks_hit += add->shared_blks_hit - sub->shared_blks_hit;
    dst->shared_blks_read += add->shared_blks_read - sub->shared_blks_read;
    dst->shared_blks_dirtied += add->shared_blks_dirtied - sub->shared_blks_dirtied;
    dst->shared_blks_written += add->shared_blks_written - sub->shared_blks_written;
    dst->local_blks_hit += add->local_blks_hit - sub->local_blks_hit;
    dst->local_blks_read += add->local_blks_read - sub->local_blks_read;
    dst->local_blks_dirtied += add->local_blks_dirtied - sub->local_blks_dirtied;
    dst->local_blks_written += add->local_blks_written - sub->local_blks_written;
    dst->temp_blks_read += add->temp_blks_read - sub->temp_blks_read;
    dst->temp_blks_written += add->temp_blks_written - sub->temp_blks_written;
    INSTR_TIME_ACCUM_DIFF(dst->shared_blk_read_time,
                          add->shared_blk_read_time, sub->shared_blk_read_time);
    INSTR_TIME_ACCUM_DIFF(dst->shared_blk_write_time,
                          add->shared_blk_write_time, sub->shared_blk_write_time);
    INSTR_TIME_ACCUM_DIFF(dst->local_blk_read_time,
                          add->local_blk_read_time, sub->local_blk_read_time);
    INSTR_TIME_ACCUM_DIFF(dst->local_blk_write_time,
                          add->local_blk_write_time, sub->local_blk_write_time);
    INSTR_TIME_ACCUM_DIFF(dst->temp_blk_read_time,
                          add->temp_blk_read_time, sub->temp_blk_read_time);
    INSTR_TIME_ACCUM_DIFF(dst->temp_blk_write_time,
                          add->temp_blk_write_time, sub->temp_blk_write_time);
}

References fb(), INSTR_TIME_ACCUM_DIFF, BufferUsage::local_blk_read_time, BufferUsage::local_blk_write_time, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, BufferUsage::local_blks_written, BufferUsage::shared_blk_read_time, BufferUsage::shared_blk_write_time, BufferUsage::shared_blks_dirtied, BufferUsage::shared_blks_hit, BufferUsage::shared_blks_read, BufferUsage::shared_blks_written, BufferUsage::temp_blk_read_time, BufferUsage::temp_blk_write_time, BufferUsage::temp_blks_read, and BufferUsage::temp_blks_written.

Referenced by do_analyze_rel(), ExplainExecuteQuery(), heap_vacuum_rel(), InstrEndParallelQuery(), InstrStopCommon(), pgss_planner(), pgss_ProcessUtility(), serializeAnalyzeReceive(), and standard_ExplainOneQuery().

◆ BufferUsageAdd()

static void BufferUsageAdd	(	BufferUsage *	dst,
		const BufferUsage *	add
	)

static

Definition at line 305 of file instrument.c.

{
    dst->shared_blks_hit += add->shared_blks_hit;
    dst->shared_blks_read += add->shared_blks_read;
    dst->shared_blks_dirtied += add->shared_blks_dirtied;
    dst->shared_blks_written += add->shared_blks_written;
    dst->local_blks_hit += add->local_blks_hit;
    dst->local_blks_read += add->local_blks_read;
    dst->local_blks_dirtied += add->local_blks_dirtied;
    dst->local_blks_written += add->local_blks_written;
    dst->temp_blks_read += add->temp_blks_read;
    dst->temp_blks_written += add->temp_blks_written;
    INSTR_TIME_ADD(dst->shared_blk_read_time, add->shared_blk_read_time);
    INSTR_TIME_ADD(dst->shared_blk_write_time, add->shared_blk_write_time);
    INSTR_TIME_ADD(dst->local_blk_read_time, add->local_blk_read_time);
    INSTR_TIME_ADD(dst->local_blk_write_time, add->local_blk_write_time);
    INSTR_TIME_ADD(dst->temp_blk_read_time, add->temp_blk_read_time);
    INSTR_TIME_ADD(dst->temp_blk_write_time, add->temp_blk_write_time);
}

References fb(), and INSTR_TIME_ADD.

Referenced by InstrAccumParallelQuery(), and InstrAggNode().

◆ check_timing_clock_source()

bool check_timing_clock_source	(	int *	newval,
		void **	extra,
		GucSource	source
	)

Definition at line 379 of file instrument.c.

{
    /*
     * Do nothing if timing is not initialized. This is only expected on child
     * processes in EXEC_BACKEND builds, as GUC hooks can be called during
     * InitializeGUCOptions() before InitProcessGlobals() has had a chance to
     * run pg_initialize_timing(). Instead, TSC will be initialized via
     * restore_backend_variables.
     */
#ifdef EXEC_BACKEND
    if (!timing_initialized)
        return true;
#else
    Assert(timing_initialized);
#endif
 
#if PG_INSTR_TSC_CLOCK
    pg_initialize_timing_tsc();
 
    if (*newval == TIMING_CLOCK_SOURCE_TSC && timing_tsc_frequency_khz <= 0)
    {
        GUC_check_errdetail("TSC is not supported as timing clock source");
        return false;
    }
#endif
 
    return true;
}

References Assert, fb(), GUC_check_errdetail, newval, timing_initialized, and timing_tsc_frequency_khz.

◆ ExecProcNodeInstr()

TupleTableSlot * ExecProcNodeInstr ( PlanState * node )

Definition at line 181 of file instrument.c.

{
    TupleTableSlot *result;
 
    InstrStartNode(node->instrument);
 
    result = node->ExecProcNodeReal(node);
 
    InstrStopNode(node->instrument, TupIsNull(result) ? 0.0 : 1.0);
 
    return result;
}

References PlanState::ExecProcNodeReal, InstrStartNode(), InstrStopNode(), PlanState::instrument, result, and TupIsNull.

Referenced by ExecProcNodeFirst().

◆ InstrAccumParallelQuery()

void InstrAccumParallelQuery	(	BufferUsage *	bufusage,
		WalUsage *	walusage
	)

Definition at line 297 of file instrument.c.

{
    BufferUsageAdd(&pgBufferUsage, bufusage);
    WalUsageAdd(&pgWalUsage, walusage);
}

References BufferUsageAdd(), pgBufferUsage, pgWalUsage, and WalUsageAdd().

Referenced by _brin_end_parallel(), _bt_end_parallel(), _gin_end_parallel(), ExecParallelFinish(), and parallel_vacuum_process_all_indexes().

◆ InstrAggNode()

void InstrAggNode	(	NodeInstrumentation *	dst,
		NodeInstrumentation *	add
	)

Definition at line 232 of file instrument.c.

{
    Assert(!add->running);
 
    INSTR_TIME_ADD(dst->startup, add->startup);
    INSTR_TIME_ADD(dst->instr.total, add->instr.total);
    dst->ntuples += add->ntuples;
    dst->ntuples2 += add->ntuples2;
    dst->nloops += add->nloops;
    dst->nfiltered1 += add->nfiltered1;
    dst->nfiltered2 += add->nfiltered2;
 
    if (dst->instr.need_bufusage)
        BufferUsageAdd(&dst->instr.bufusage, &add->instr.bufusage);
 
    if (dst->instr.need_walusage)
        WalUsageAdd(&dst->instr.walusage, &add->instr.walusage);
}

References Assert, BufferUsageAdd(), fb(), INSTR_TIME_ADD, and WalUsageAdd().

Referenced by ExecParallelReportInstrumentation(), and ExecParallelRetrieveInstrumentation().

◆ InstrAlloc()

Instrumentation * InstrAlloc ( int instrument_options )

Definition at line 36 of file instrument.c.

{
    Instrumentation *instr = palloc0_object(Instrumentation);
 
    InstrInitOptions(instr, instrument_options);
    return instr;
}

References InstrInitOptions(), and palloc0_object.

Referenced by standard_ExecutorStart().

◆ InstrAllocNode()

NodeInstrumentation * InstrAllocNode	(	int	instrument_options,
		bool	async_mode
	)

Definition at line 112 of file instrument.c.

{
    NodeInstrumentation *instr = palloc_object(NodeInstrumentation);
 
    InstrInitNode(instr, instrument_options, async_mode);
 
    return instr;
}

References InstrInitNode(), and palloc_object.

Referenced by ExecInitNode().

◆ InstrAllocTrigger()

TriggerInstrumentation * InstrAllocTrigger	(	int	n,
		int	instrument_options
	)

Definition at line 253 of file instrument.c.

{
    TriggerInstrumentation *tginstr = palloc0_array(TriggerInstrumentation, n);
    int         i;
 
    for (i = 0; i < n; i++)
        InstrInitOptions(&tginstr[i].instr, instrument_options);
 
    return tginstr;
}

References fb(), i, InstrInitOptions(), and palloc0_array.

Referenced by InitResultRelInfo().

◆ InstrEndLoop()

void InstrEndLoop ( NodeInstrumentation * instr )

Definition at line 204 of file instrument.c.

{
    /* Skip if nothing has happened, or already shut down */
    if (!instr->running)
        return;
 
    if (!INSTR_TIME_IS_ZERO(instr->instr.starttime))
        elog(ERROR, "InstrEndLoop called on running node");
 
    /* Accumulate per-cycle statistics into totals */
    INSTR_TIME_ADD(instr->startup, instr->firsttuple);
    INSTR_TIME_ADD(instr->instr.total, instr->counter);
    instr->ntuples += instr->tuplecount;
    instr->nloops += 1;
 
    /* Reset for next cycle (if any) */
    instr->running = false;
    INSTR_TIME_SET_ZERO(instr->instr.starttime);
    INSTR_TIME_SET_ZERO(instr->counter);
    INSTR_TIME_SET_ZERO(instr->firsttuple);
    instr->tuplecount = 0;
}

References NodeInstrumentation::counter, elog, ERROR, NodeInstrumentation::firsttuple, NodeInstrumentation::instr, INSTR_TIME_ADD, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_ZERO, NodeInstrumentation::nloops, NodeInstrumentation::ntuples, NodeInstrumentation::running, Instrumentation::starttime, NodeInstrumentation::startup, Instrumentation::total, and NodeInstrumentation::tuplecount.

Referenced by ExecParallelReportInstrumentation(), ExecReScan(), ExplainNode(), and show_modifytable_info().

◆ InstrEndParallelQuery()

void InstrEndParallelQuery	(	BufferUsage *	bufusage,
		WalUsage *	walusage
	)

Definition at line 287 of file instrument.c.

{
    memset(bufusage, 0, sizeof(BufferUsage));
    BufferUsageAccumDiff(bufusage, &pgBufferUsage, &save_pgBufferUsage);
    memset(walusage, 0, sizeof(WalUsage));
    WalUsageAccumDiff(walusage, &pgWalUsage, &save_pgWalUsage);
}

References BufferUsageAccumDiff(), fb(), pgBufferUsage, pgWalUsage, save_pgBufferUsage, save_pgWalUsage, and WalUsageAccumDiff().

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), parallel_vacuum_main(), and ParallelQueryMain().

◆ InstrInitNode()

void InstrInitNode	(	NodeInstrumentation *	instr,
		int	instrument_options,
		bool	async_mode
	)

Definition at line 123 of file instrument.c.

{
    memset(instr, 0, sizeof(NodeInstrumentation));
    InstrInitOptions(&instr->instr, instrument_options);
    instr->async_mode = async_mode;
}

References NodeInstrumentation::async_mode, fb(), NodeInstrumentation::instr, and InstrInitOptions().

Referenced by ExecInitParallelPlan(), and InstrAllocNode().

◆ InstrInitOptions()

void InstrInitOptions	(	Instrumentation *	instr,
		int	instrument_options
	)

Definition at line 45 of file instrument.c.

{
    instr->need_bufusage = (instrument_options & INSTRUMENT_BUFFERS) != 0;
    instr->need_walusage = (instrument_options & INSTRUMENT_WAL) != 0;
    instr->need_timer = (instrument_options & INSTRUMENT_TIMER) != 0;
}

References INSTRUMENT_BUFFERS, INSTRUMENT_TIMER, INSTRUMENT_WAL, Instrumentation::need_bufusage, Instrumentation::need_timer, and Instrumentation::need_walusage.

Referenced by InstrAlloc(), InstrAllocTrigger(), and InstrInitNode().

◆ InstrStart()

void InstrStart ( Instrumentation * instr )

inline

Definition at line 53 of file instrument.c.

{
    if (instr->need_timer)
    {
        if (!INSTR_TIME_IS_ZERO(instr->starttime))
            elog(ERROR, "InstrStart called twice in a row");
        else
            INSTR_TIME_SET_CURRENT_FAST(instr->starttime);
    }
 
    /* save buffer usage totals at start, if needed */
    if (instr->need_bufusage)
        instr->bufusage_start = pgBufferUsage;
 
    if (instr->need_walusage)
        instr->walusage_start = pgWalUsage;
}

References Instrumentation::bufusage_start, elog, ERROR, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT_FAST, Instrumentation::need_bufusage, Instrumentation::need_timer, Instrumentation::need_walusage, pgBufferUsage, pgWalUsage, Instrumentation::starttime, and Instrumentation::walusage_start.

Referenced by InstrStartNode(), InstrStartTrigger(), standard_ExecutorFinish(), and standard_ExecutorRun().

◆ InstrStartNode()

void InstrStartNode ( NodeInstrumentation * instr )

inline

Definition at line 132 of file instrument.c.

{
    InstrStart(&instr->instr);
}

References NodeInstrumentation::instr, and InstrStart().

Referenced by ExecAsyncConfigureWait(), ExecAsyncNotify(), ExecAsyncRequest(), ExecProcNodeInstr(), ExecShutdownNode_walker(), MultiExecBitmapAnd(), MultiExecBitmapIndexScan(), MultiExecBitmapOr(), and MultiExecHash().

◆ InstrStartParallelQuery()

void InstrStartParallelQuery ( void )

Definition at line 279 of file instrument.c.

{
    save_pgBufferUsage = pgBufferUsage;
    save_pgWalUsage = pgWalUsage;
}

References pgBufferUsage, pgWalUsage, save_pgBufferUsage, and save_pgWalUsage.

Referenced by _brin_parallel_build_main(), _bt_parallel_build_main(), _gin_parallel_build_main(), parallel_vacuum_main(), and ParallelQueryMain().

◆ InstrStartTrigger()

void InstrStartTrigger ( TriggerInstrumentation * tginstr )

Definition at line 265 of file instrument.c.

{
    InstrStart(&tginstr->instr);
}

References fb(), and InstrStart().

Referenced by AfterTriggerExecute(), and ExecCallTriggerFunc().

◆ InstrStop()

void InstrStop ( Instrumentation * instr )

Definition at line 103 of file instrument.c.

{
    InstrStopCommon(instr, &instr->total);
}

References InstrStopCommon(), and Instrumentation::total.

Referenced by InstrStopTrigger(), standard_ExecutorFinish(), and standard_ExecutorRun().

◆ InstrStopCommon()

static void InstrStopCommon	(	Instrumentation *	instr,
		instr_time *	accum_time
	)

inlinestatic

Definition at line 76 of file instrument.c.

{
    instr_time  endtime;
 
    /* update the time only if the timer was requested */
    if (instr->need_timer)
    {
        if (INSTR_TIME_IS_ZERO(instr->starttime))
            elog(ERROR, "InstrStop called without start");
 
        INSTR_TIME_SET_CURRENT_FAST(endtime);
        INSTR_TIME_ACCUM_DIFF(*accum_time, endtime, instr->starttime);
 
        INSTR_TIME_SET_ZERO(instr->starttime);
    }
 
    /* Add delta of buffer usage since InstrStart to the totals */
    if (instr->need_bufusage)
        BufferUsageAccumDiff(&instr->bufusage,
                             &pgBufferUsage, &instr->bufusage_start);
 
    if (instr->need_walusage)
        WalUsageAccumDiff(&instr->walusage,
                          &pgWalUsage, &instr->walusage_start);
}

References BufferUsageAccumDiff(), Instrumentation::bufusage, Instrumentation::bufusage_start, elog, ERROR, fb(), INSTR_TIME_ACCUM_DIFF, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT_FAST, INSTR_TIME_SET_ZERO, Instrumentation::need_bufusage, Instrumentation::need_timer, Instrumentation::need_walusage, pgBufferUsage, pgWalUsage, Instrumentation::starttime, Instrumentation::walusage, Instrumentation::walusage_start, and WalUsageAccumDiff().

Referenced by InstrStop(), and InstrStopNode().

◆ InstrStopNode()

void InstrStopNode	(	NodeInstrumentation *	instr,
		double	nTuples
	)

inline

Definition at line 139 of file instrument.c.

{
    double      save_tuplecount = instr->tuplecount;
 
    /* count the returned tuples */
    instr->tuplecount += nTuples;
 
    /*
     * Note that in contrast to InstrStop() the time is accumulated into
     * NodeInstrumentation->counter, with total only getting updated in
     * InstrEndLoop.  We need the separate counter variable because we need to
     * calculate start-up time for the first tuple in each cycle, and then
     * accumulate it together.
     */
    InstrStopCommon(&instr->instr, &instr->counter);
 
    /* Is this the first tuple of this cycle? */
    if (!instr->running)
    {
        instr->running = true;
        instr->firsttuple = instr->counter;
    }
    else
    {
        /*
         * In async mode, if the plan node hadn't emitted any tuples before,
         * this might be the first tuple
         */
        if (instr->async_mode && save_tuplecount < 1.0)
            instr->firsttuple = instr->counter;
    }
}

References NodeInstrumentation::async_mode, NodeInstrumentation::counter, fb(), NodeInstrumentation::firsttuple, NodeInstrumentation::instr, InstrStopCommon(), NodeInstrumentation::running, and NodeInstrumentation::tuplecount.

Referenced by ExecAsyncConfigureWait(), ExecAsyncNotify(), ExecAsyncRequest(), ExecProcNodeInstr(), ExecShutdownNode_walker(), MultiExecBitmapAnd(), MultiExecBitmapIndexScan(), MultiExecBitmapOr(), and MultiExecHash().

◆ InstrStopTrigger()

void InstrStopTrigger	(	TriggerInstrumentation *	tginstr,
		int64	firings
	)

Definition at line 271 of file instrument.c.

{
    InstrStop(&tginstr->instr);
    tginstr->firings += firings;
}

References fb(), and InstrStop().

Referenced by AfterTriggerExecute(), and ExecCallTriggerFunc().

◆ InstrUpdateTupleCount()

void InstrUpdateTupleCount	(	NodeInstrumentation *	instr,
		double	nTuples
	)

Definition at line 196 of file instrument.c.

{
    /* count the returned tuples */
    instr->tuplecount += nTuples;
}

References NodeInstrumentation::tuplecount.

Referenced by complete_pending_request(), and ExecMergeMatched().

◆ show_timing_clock_source()

const char * show_timing_clock_source ( void )

Definition at line 426 of file instrument.c.

{
    switch (timing_clock_source)
    {
        case TIMING_CLOCK_SOURCE_AUTO:
#if PG_INSTR_TSC_CLOCK
            if (pg_current_timing_clock_source() == TIMING_CLOCK_SOURCE_TSC)
                return "auto (tsc)";
#endif
            return "auto (system)";
        case TIMING_CLOCK_SOURCE_SYSTEM:
            return "system";
#if PG_INSTR_TSC_CLOCK
        case TIMING_CLOCK_SOURCE_TSC:
            return "tsc";
#endif
    }
 
    /* unreachable */
    return "?";
}

References fb(), pg_current_timing_clock_source(), timing_clock_source, TIMING_CLOCK_SOURCE_AUTO, and TIMING_CLOCK_SOURCE_SYSTEM.

◆ WalUsageAccumDiff()

void WalUsageAccumDiff	(	WalUsage *	dst,
		const WalUsage *	add,
		const WalUsage *	sub
	)

inline

Definition at line 367 of file instrument.c.

{
    dst->wal_bytes += add->wal_bytes - sub->wal_bytes;
    dst->wal_records += add->wal_records - sub->wal_records;
    dst->wal_fpi += add->wal_fpi - sub->wal_fpi;
    dst->wal_fpi_bytes += add->wal_fpi_bytes - sub->wal_fpi_bytes;
    dst->wal_buffers_full += add->wal_buffers_full - sub->wal_buffers_full;
}

References fb(), WalUsage::wal_buffers_full, WalUsage::wal_bytes, WalUsage::wal_fpi, WalUsage::wal_fpi_bytes, and WalUsage::wal_records.

Referenced by do_analyze_rel(), heap_vacuum_rel(), InstrEndParallelQuery(), InstrStopCommon(), pgss_planner(), pgss_ProcessUtility(), pgstat_flush_backend_entry_wal(), and pgstat_wal_flush_cb().

◆ WalUsageAdd()

static void WalUsageAdd	(	WalUsage *	dst,
		WalUsage *	add
	)

inlinestatic

Definition at line 357 of file instrument.c.

{
    dst->wal_bytes += add->wal_bytes;
    dst->wal_records += add->wal_records;
    dst->wal_fpi += add->wal_fpi;
    dst->wal_fpi_bytes += add->wal_fpi_bytes;
    dst->wal_buffers_full += add->wal_buffers_full;
}

References fb().

Referenced by InstrAccumParallelQuery(), and InstrAggNode().

Variable Documentation

◆ pgBufferUsage

◆ pgWalUsage

◆ save_pgBufferUsage

BufferUsage save_pgBufferUsage

static

Definition at line 26 of file instrument.c.

Referenced by InstrEndParallelQuery(), and InstrStartParallelQuery().

◆ save_pgWalUsage

WalUsage save_pgWalUsage

static

Definition at line 28 of file instrument.c.

Referenced by InstrEndParallelQuery(), and InstrStartParallelQuery().

Functions

Variables

Function Documentation

◆ assign_timing_clock_source()

◆ BufferUsageAccumDiff()

◆ BufferUsageAdd()

◆ check_timing_clock_source()

◆ ExecProcNodeInstr()

◆ InstrAccumParallelQuery()

◆ InstrAggNode()

◆ InstrAlloc()

◆ InstrAllocNode()

◆ InstrAllocTrigger()

◆ InstrEndLoop()

◆ InstrEndParallelQuery()

◆ InstrInitNode()

◆ InstrInitOptions()

◆ InstrStart()

◆ InstrStartNode()

◆ InstrStartParallelQuery()

◆ InstrStartTrigger()

◆ InstrStop()

◆ InstrStopCommon()

◆ InstrStopNode()

◆ InstrStopTrigger()

◆ InstrUpdateTupleCount()

◆ show_timing_clock_source()

◆ WalUsageAccumDiff()

◆ WalUsageAdd()

Variable Documentation

◆ pgBufferUsage

◆ pgWalUsage

◆ save_pgBufferUsage

◆ save_pgWalUsage