instrument.h File Reference

#include "portability/instr_time.h"

Include dependency graph for instrument.h:

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

Go to the source code of this file.

Data Structures
struct	BufferUsage
struct	WalUsage
struct	Instrumentation
struct	NodeInstrumentation
struct	WorkerNodeInstrumentation
struct	TriggerInstrumentation

Typedefs
typedef struct BufferUsage	BufferUsage
typedef struct WalUsage	WalUsage
typedef enum InstrumentOption	InstrumentOption
typedef struct Instrumentation	Instrumentation
typedef struct NodeInstrumentation	NodeInstrumentation
typedef struct WorkerNodeInstrumentation	WorkerNodeInstrumentation
typedef struct TriggerInstrumentation	TriggerInstrumentation

Enumerations
enum	InstrumentOption {   INSTRUMENT_TIMER = 1 << 0 , INSTRUMENT_BUFFERS = 1 << 1 , INSTRUMENT_ROWS = 1 << 2 , INSTRUMENT_WAL = 1 << 3 ,   INSTRUMENT_IO = 1 << 4 , INSTRUMENT_ALL = PG_INT32_MAX }

Functions
Instrumentation *	InstrAlloc (int instrument_options)
void	InstrInitOptions (Instrumentation *instr, int instrument_options)
void	InstrStart (Instrumentation *instr)
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)
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)

Variables
PGDLLIMPORT BufferUsage	pgBufferUsage
PGDLLIMPORT WalUsage	pgWalUsage

Typedef Documentation

BufferUsage

typedef struct BufferUsage BufferUsage

Instrumentation

typedef struct Instrumentation Instrumentation

InstrumentOption

typedef enum InstrumentOption InstrumentOption

NodeInstrumentation

typedef struct NodeInstrumentation NodeInstrumentation

TriggerInstrumentation

typedef struct TriggerInstrumentation TriggerInstrumentation

WalUsage

typedef struct WalUsage WalUsage

WorkerNodeInstrumentation

typedef struct WorkerNodeInstrumentation WorkerNodeInstrumentation

Enumeration Type Documentation

InstrumentOption

enum InstrumentOption

Enumerator
INSTRUMENT_TIMER
INSTRUMENT_BUFFERS
INSTRUMENT_ROWS
INSTRUMENT_WAL
INSTRUMENT_IO
INSTRUMENT_ALL

Definition at line 61 of file instrument.h.

{
    INSTRUMENT_TIMER = 1 << 0,  /* needs timer (and row counts) */
    INSTRUMENT_BUFFERS = 1 << 1,    /* needs buffer usage */
    INSTRUMENT_ROWS = 1 << 2,   /* needs row count */
    INSTRUMENT_WAL = 1 << 3,    /* needs WAL usage */
    INSTRUMENT_IO = 1 << 4,     /* needs IO usage */
    INSTRUMENT_ALL = PG_INT32_MAX
} InstrumentOption;

Function Documentation

BufferUsageAccumDiff()

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

externinline

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().

InstrAccumParallelQuery()

void InstrAccumParallelQuery ( BufferUsage *  bufusage, WalUsage *  walusage  )

extern

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  )

extern

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 )

extern

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  )

extern

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  )

extern

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 )

extern

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  )

extern

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  )

extern

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  )

extern

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 )

externinline

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 )

externinline

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  )

extern

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 )

extern

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 )

extern

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().

InstrStopNode()

void InstrStopNode ( NodeInstrumentation *  instr, double  nTuples  )

externinline

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  )

extern

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  )

extern

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().

WalUsageAccumDiff()

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

externinline

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().

Variable Documentation

pgBufferUsage

PGDLLIMPORT BufferUsage pgBufferUsage

extern

Definition at line 25 of file instrument.c.

Referenced by AsyncReadBuffers(), BufFileDumpBuffer(), BufFileLoadBuffer(), do_analyze_rel(), ExplainExecuteQuery(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStart(), InstrStartParallelQuery(), InstrStopCommon(), MarkBufferDirty(), MarkLocalBufferDirty(), MarkSharedBufferDirtyHint(), pgss_planner(), pgss_ProcessUtility(), pgstat_count_io_op_time(), ReadRecentBuffer(), serializeAnalyzeReceive(), standard_ExplainOneQuery(), and TrackBufferHit().

pgWalUsage

PGDLLIMPORT WalUsage pgWalUsage

extern

Definition at line 27 of file instrument.c.

Referenced by AdvanceXLInsertBuffer(), do_analyze_rel(), heap_page_prune_and_freeze(), heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStart(), InstrStartParallelQuery(), InstrStopCommon(), pgss_planner(), pgss_ProcessUtility(), pgstat_backend_wal_have_pending(), pgstat_create_backend(), pgstat_flush_backend_entry_wal(), pgstat_wal_flush_cb(), pgstat_wal_have_pending(), pgstat_wal_init_backend_cb(), and XLogInsertRecord().