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 246 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->blk_read_time,
                          add->blk_read_time, sub->blk_read_time);
    INSTR_TIME_ACCUM_DIFF(dst->blk_write_time,
                          add->blk_write_time, sub->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 BufferUsage::blk_read_time, BufferUsage::blk_write_time, INSTR_TIME_ACCUM_DIFF, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, BufferUsage::local_blks_written, 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 ExplainExecuteQuery(), ExplainOneQuery(), InstrEndParallelQuery(), InstrStopNode(), pgss_planner(), and pgss_ProcessUtility().

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->blk_read_time, add->blk_read_time);
    INSTR_TIME_ADD(dst->blk_write_time, add->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 BufferUsage::blk_read_time, BufferUsage::blk_write_time, INSTR_TIME_ADD, BufferUsage::local_blks_dirtied, BufferUsage::local_blks_hit, BufferUsage::local_blks_read, BufferUsage::local_blks_written, 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 _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 _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 _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 280 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 heap_vacuum_rel(), InstrEndParallelQuery(), InstrStopNode(), pgss_planner(), pgss_ProcessUtility(), and pgstat_flush_wal().

WalUsageAdd()

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

static

Definition at line 272 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(), ExplainExecuteQuery(), ExplainOneQuery(), FlushBuffer(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStartNode(), InstrStartParallelQuery(), InstrStopNode(), LocalBufferAlloc(), MarkBufferDirty(), MarkBufferDirtyHint(), MarkLocalBufferDirty(), pgss_planner(), pgss_ProcessUtility(), ReadBuffer_common(), and ReadRecentBuffer().

pgWalUsage

WalUsage pgWalUsage

Definition at line 22 of file instrument.c.

Referenced by heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStartNode(), InstrStartParallelQuery(), InstrStopNode(), lazy_scan_prune(), pgss_planner(), pgss_ProcessUtility(), pgstat_flush_wal(), pgstat_have_pending_wal(), pgstat_init_wal(), 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().