instrument.c File Reference

#include "postgres.h"
#include <unistd.h>
#include "executor/instrument.h"

Include dependency graph for instrument.c:

Go to the source code of this file.

Functions
static void	BufferUsageAdd (BufferUsage *dst, const BufferUsage *add)
static void	WalUsageAdd (WalUsage *dst, WalUsage *add)
Instrumentation *	InstrAlloc (int n, int instrument_options, bool async_mode)
void	InstrInit (Instrumentation *instr, int instrument_options)
void	InstrStartNode (Instrumentation *instr)
void	InstrStopNode (Instrumentation *instr, double nTuples)
void	InstrUpdateTupleCount (Instrumentation *instr, double nTuples)
void	InstrEndLoop (Instrumentation *instr)
void	InstrAggNode (Instrumentation *dst, Instrumentation *add)
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)

Variables
BufferUsage	pgBufferUsage
static BufferUsage	save_pgBufferUsage
WalUsage	pgWalUsage
static WalUsage	save_pgWalUsage

Function Documentation

BufferUsageAccumDiff()

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

Definition at line 248 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 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(), InstrStopNode(), pgss_planner(), pgss_ProcessUtility(), serializeAnalyzeReceive(), and standard_ExplainOneQuery().

BufferUsageAdd()

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

static

Definition at line 226 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 INSTR_TIME_ADD, 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 InstrAccumParallelQuery(), and InstrAggNode().

InstrAccumParallelQuery()

void InstrAccumParallelQuery	(	BufferUsage *	bufusage,
		WalUsage *	walusage
	)

Definition at line 218 of file instrument.c.

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

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

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

InstrAggNode()

void InstrAggNode	(	Instrumentation *	dst,
		Instrumentation *	add
	)

Definition at line 169 of file instrument.c.

{
    if (!dst->running && add->running)
    {
        dst->running = true;
        dst->firsttuple = add->firsttuple;
    }
    else if (dst->running && add->running && dst->firsttuple > add->firsttuple)
        dst->firsttuple = add->firsttuple;
 
    INSTR_TIME_ADD(dst->counter, add->counter);
 
    dst->tuplecount += add->tuplecount;
    dst->startup += add->startup;
    dst->total += add->total;
    dst->ntuples += add->ntuples;
    dst->ntuples2 += add->ntuples2;
    dst->nloops += add->nloops;
    dst->nfiltered1 += add->nfiltered1;
    dst->nfiltered2 += add->nfiltered2;
 
    /* Add delta of buffer usage since entry to node's totals */
    if (dst->need_bufusage)
        BufferUsageAdd(&dst->bufusage, &add->bufusage);
 
    if (dst->need_walusage)
        WalUsageAdd(&dst->walusage, &add->walusage);
}

References BufferUsageAdd(), Instrumentation::bufusage, Instrumentation::counter, Instrumentation::firsttuple, INSTR_TIME_ADD, Instrumentation::need_bufusage, Instrumentation::need_walusage, Instrumentation::nfiltered1, Instrumentation::nfiltered2, Instrumentation::nloops, Instrumentation::ntuples, Instrumentation::ntuples2, Instrumentation::running, Instrumentation::startup, Instrumentation::total, Instrumentation::tuplecount, Instrumentation::walusage, and WalUsageAdd().

Referenced by ExecParallelReportInstrumentation(), and ExecParallelRetrieveInstrumentation().

InstrAlloc()

Instrumentation* InstrAlloc	(	int	n,
		int	instrument_options,
		bool	async_mode
	)

Definition at line 31 of file instrument.c.

{
    Instrumentation *instr;
 
    /* initialize all fields to zeroes, then modify as needed */
    instr = palloc0(n * sizeof(Instrumentation));
    if (instrument_options & (INSTRUMENT_BUFFERS | INSTRUMENT_TIMER | INSTRUMENT_WAL))
    {
        bool        need_buffers = (instrument_options & INSTRUMENT_BUFFERS) != 0;
        bool        need_wal = (instrument_options & INSTRUMENT_WAL) != 0;
        bool        need_timer = (instrument_options & INSTRUMENT_TIMER) != 0;
        int         i;
 
        for (i = 0; i < n; i++)
        {
            instr[i].need_bufusage = need_buffers;
            instr[i].need_walusage = need_wal;
            instr[i].need_timer = need_timer;
            instr[i].async_mode = async_mode;
        }
    }
 
    return instr;
}

References Instrumentation::async_mode, i, INSTRUMENT_BUFFERS, INSTRUMENT_TIMER, INSTRUMENT_WAL, Instrumentation::need_bufusage, Instrumentation::need_timer, Instrumentation::need_walusage, and palloc0().

Referenced by ExecInitNode(), explain_ExecutorStart(), InitResultRelInfo(), and pgss_ExecutorStart().

InstrEndLoop()

void InstrEndLoop

(

Instrumentation *

instr

)

Definition at line 140 of file instrument.c.

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

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

Referenced by ExecParallelReportInstrumentation(), ExecReScan(), explain_ExecutorEnd(), ExplainNode(), pgss_ExecutorEnd(), report_triggers(), and show_modifytable_info().

InstrEndParallelQuery()

void InstrEndParallelQuery	(	BufferUsage *	bufusage,
		WalUsage *	walusage
	)

Definition at line 208 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(), pgBufferUsage, pgWalUsage, save_pgBufferUsage, save_pgWalUsage, and WalUsageAccumDiff().

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

InstrInit()

void InstrInit	(	Instrumentation *	instr,
		int	instrument_options
	)

Definition at line 58 of file instrument.c.

{
    memset(instr, 0, sizeof(Instrumentation));
    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 ExecInitParallelPlan().

InstrStartNode()

void InstrStartNode

(

Instrumentation *

instr

)

Definition at line 68 of file instrument.c.

{
    if (instr->need_timer &&
        !INSTR_TIME_SET_CURRENT_LAZY(instr->starttime))
        elog(ERROR, "InstrStartNode called twice in a row");
 
    /* save buffer usage totals at node entry, 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_SET_CURRENT_LAZY, Instrumentation::need_bufusage, Instrumentation::need_timer, Instrumentation::need_walusage, pgBufferUsage, pgWalUsage, Instrumentation::starttime, and Instrumentation::walusage_start.

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

InstrStartParallelQuery()

void InstrStartParallelQuery

(

void

)

Definition at line 200 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(), parallel_vacuum_main(), and ParallelQueryMain().

InstrStopNode()

void InstrStopNode	(	Instrumentation *	instr,
		double	nTuples
	)

Definition at line 84 of file instrument.c.

{
    double      save_tuplecount = instr->tuplecount;
    instr_time  endtime;
 
    /* count the returned tuples */
    instr->tuplecount += nTuples;
 
    /* let's update the time only if the timer was requested */
    if (instr->need_timer)
    {
        if (INSTR_TIME_IS_ZERO(instr->starttime))
            elog(ERROR, "InstrStopNode called without start");
 
        INSTR_TIME_SET_CURRENT(endtime);
        INSTR_TIME_ACCUM_DIFF(instr->counter, endtime, instr->starttime);
 
        INSTR_TIME_SET_ZERO(instr->starttime);
    }
 
    /* Add delta of buffer usage since entry to node's totals */
    if (instr->need_bufusage)
        BufferUsageAccumDiff(&instr->bufusage,
                             &pgBufferUsage, &instr->bufusage_start);
 
    if (instr->need_walusage)
        WalUsageAccumDiff(&instr->walusage,
                          &pgWalUsage, &instr->walusage_start);
 
    /* Is this the first tuple of this cycle? */
    if (!instr->running)
    {
        instr->running = true;
        instr->firsttuple = INSTR_TIME_GET_DOUBLE(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_TIME_GET_DOUBLE(instr->counter);
    }
}

References Instrumentation::async_mode, BufferUsageAccumDiff(), Instrumentation::bufusage, Instrumentation::bufusage_start, Instrumentation::counter, elog, ERROR, Instrumentation::firsttuple, INSTR_TIME_ACCUM_DIFF, INSTR_TIME_GET_DOUBLE, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT, INSTR_TIME_SET_ZERO, Instrumentation::need_bufusage, Instrumentation::need_timer, Instrumentation::need_walusage, pgBufferUsage, pgWalUsage, Instrumentation::running, Instrumentation::starttime, Instrumentation::tuplecount, Instrumentation::walusage, Instrumentation::walusage_start, and WalUsageAccumDiff().

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

InstrUpdateTupleCount()

void InstrUpdateTupleCount	(	Instrumentation *	instr,
		double	nTuples
	)

Definition at line 132 of file instrument.c.

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

References Instrumentation::tuplecount.

Referenced by complete_pending_request().

WalUsageAccumDiff()

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

Definition at line 286 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;
}

References WalUsage::wal_bytes, WalUsage::wal_fpi, and WalUsage::wal_records.

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

WalUsageAdd()

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

static

Definition at line 278 of file instrument.c.

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

References WalUsage::wal_bytes, WalUsage::wal_fpi, and WalUsage::wal_records.

Referenced by InstrAccumParallelQuery(), and InstrAggNode().

Variable Documentation

pgBufferUsage

BufferUsage pgBufferUsage

Definition at line 20 of file instrument.c.

Referenced by BufFileDumpBuffer(), BufFileLoadBuffer(), do_analyze_rel(), ExplainExecuteQuery(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStartNode(), InstrStartParallelQuery(), InstrStopNode(), MarkBufferDirty(), MarkBufferDirtyHint(), MarkLocalBufferDirty(), pgss_planner(), pgss_ProcessUtility(), pgstat_count_io_op_time(), PinBufferForBlock(), ReadRecentBuffer(), serializeAnalyzeReceive(), standard_ExplainOneQuery(), and WaitReadBuffers().

pgWalUsage

WalUsage pgWalUsage

Definition at line 22 of file instrument.c.

Referenced by do_analyze_rel(), heap_page_prune_and_freeze(), heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStartNode(), InstrStartParallelQuery(), InstrStopNode(), pgss_planner(), pgss_ProcessUtility(), pgstat_wal_flush_cb(), pgstat_wal_have_pending_cb(), pgstat_wal_init_backend_cb(), and XLogInsertRecord().

save_pgBufferUsage

BufferUsage save_pgBufferUsage

static

Definition at line 21 of file instrument.c.

Referenced by InstrEndParallelQuery(), and InstrStartParallelQuery().

save_pgWalUsage

WalUsage save_pgWalUsage

static

Definition at line 23 of file instrument.c.

Referenced by InstrEndParallelQuery(), and InstrStartParallelQuery().