PostgreSQL Source Code git master
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)
 
InstrumentationInstrAlloc (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.

251{
256 dst->local_blks_hit += add->local_blks_hit - sub->local_blks_hit;
260 dst->temp_blks_read += add->temp_blks_read - sub->temp_blks_read;
274}
#define INSTR_TIME_ACCUM_DIFF(x, y, z)
Definition: instr_time.h:184
instr_time local_blk_read_time
Definition: instrument.h:38
int64 shared_blks_dirtied
Definition: instrument.h:28
int64 local_blks_hit
Definition: instrument.h:30
instr_time temp_blk_write_time
Definition: instrument.h:41
instr_time shared_blk_read_time
Definition: instrument.h:36
instr_time shared_blk_write_time
Definition: instrument.h:37
int64 local_blks_written
Definition: instrument.h:33
instr_time temp_blk_read_time
Definition: instrument.h:40
instr_time local_blk_write_time
Definition: instrument.h:39
int64 temp_blks_read
Definition: instrument.h:34
int64 shared_blks_read
Definition: instrument.h:27
int64 shared_blks_written
Definition: instrument.h:29
int64 temp_blks_written
Definition: instrument.h:35
int64 local_blks_read
Definition: instrument.h:31
int64 local_blks_dirtied
Definition: instrument.h:32
int64 shared_blks_hit
Definition: instrument.h:26

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.

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.

219{
220 BufferUsageAdd(&pgBufferUsage, bufusage);
221 WalUsageAdd(&pgWalUsage, walusage);
222}
static void BufferUsageAdd(BufferUsage *dst, const BufferUsage *add)
Definition: instrument.c:226
static void WalUsageAdd(WalUsage *dst, WalUsage *add)
Definition: instrument.c:278
WalUsage pgWalUsage
Definition: instrument.c:22
BufferUsage pgBufferUsage
Definition: instrument.c:20

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 ( Instrumentation dst,
Instrumentation add 
)

Definition at line 169 of file instrument.c.

170{
171 if (!dst->running && add->running)
172 {
173 dst->running = true;
174 dst->firsttuple = add->firsttuple;
175 }
176 else if (dst->running && add->running && dst->firsttuple > add->firsttuple)
177 dst->firsttuple = add->firsttuple;
178
179 INSTR_TIME_ADD(dst->counter, add->counter);
180
181 dst->tuplecount += add->tuplecount;
182 dst->startup += add->startup;
183 dst->total += add->total;
184 dst->ntuples += add->ntuples;
185 dst->ntuples2 += add->ntuples2;
186 dst->nloops += add->nloops;
187 dst->nfiltered1 += add->nfiltered1;
188 dst->nfiltered2 += add->nfiltered2;
189
190 /* Add delta of buffer usage since entry to node's totals */
191 if (dst->need_bufusage)
192 BufferUsageAdd(&dst->bufusage, &add->bufusage);
193
194 if (dst->need_walusage)
195 WalUsageAdd(&dst->walusage, &add->walusage);
196}
double nfiltered2
Definition: instrument.h:91
double nfiltered1
Definition: instrument.h:90
double startup
Definition: instrument.h:85
WalUsage walusage
Definition: instrument.h:93
bool need_bufusage
Definition: instrument.h:73
double ntuples
Definition: instrument.h:87
BufferUsage bufusage
Definition: instrument.h:92
bool need_walusage
Definition: instrument.h:74
instr_time counter
Definition: instrument.h:79
double firsttuple
Definition: instrument.h:80
double ntuples2
Definition: instrument.h:88
double tuplecount
Definition: instrument.h:81

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.

32{
33 Instrumentation *instr;
34
35 /* initialize all fields to zeroes, then modify as needed */
36 instr = palloc0(n * sizeof(Instrumentation));
37 if (instrument_options & (INSTRUMENT_BUFFERS | INSTRUMENT_TIMER | INSTRUMENT_WAL))
38 {
39 bool need_buffers = (instrument_options & INSTRUMENT_BUFFERS) != 0;
40 bool need_wal = (instrument_options & INSTRUMENT_WAL) != 0;
41 bool need_timer = (instrument_options & INSTRUMENT_TIMER) != 0;
42 int i;
43
44 for (i = 0; i < n; i++)
45 {
46 instr[i].need_bufusage = need_buffers;
47 instr[i].need_walusage = need_wal;
48 instr[i].need_timer = need_timer;
49 instr[i].async_mode = async_mode;
50 }
51 }
52
53 return instr;
54}
@ INSTRUMENT_TIMER
Definition: instrument.h:62
@ INSTRUMENT_BUFFERS
Definition: instrument.h:63
@ INSTRUMENT_WAL
Definition: instrument.h:65
int i
Definition: isn.c:74
void * palloc0(Size size)
Definition: mcxt.c:1347

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.

141{
142 double totaltime;
143
144 /* Skip if nothing has happened, or already shut down */
145 if (!instr->running)
146 return;
147
148 if (!INSTR_TIME_IS_ZERO(instr->starttime))
149 elog(ERROR, "InstrEndLoop called on running node");
150
151 /* Accumulate per-cycle statistics into totals */
152 totaltime = INSTR_TIME_GET_DOUBLE(instr->counter);
153
154 instr->startup += instr->firsttuple;
155 instr->total += totaltime;
156 instr->ntuples += instr->tuplecount;
157 instr->nloops += 1;
158
159 /* Reset for next cycle (if any) */
160 instr->running = false;
163 instr->firsttuple = 0;
164 instr->tuplecount = 0;
165}
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:225
#define INSTR_TIME_IS_ZERO(t)
Definition: instr_time.h:169
#define INSTR_TIME_GET_DOUBLE(t)
Definition: instr_time.h:188
#define INSTR_TIME_SET_ZERO(t)
Definition: instr_time.h:172
instr_time starttime
Definition: instrument.h:78

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.

209{
210 memset(bufusage, 0, sizeof(BufferUsage));
212 memset(walusage, 0, sizeof(WalUsage));
214}
static BufferUsage save_pgBufferUsage
Definition: instrument.c:21
static WalUsage save_pgWalUsage
Definition: instrument.c:23
void WalUsageAccumDiff(WalUsage *dst, const WalUsage *add, const WalUsage *sub)
Definition: instrument.c:287
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition: instrument.c:248

References BufferUsageAccumDiff(), 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().

◆ InstrInit()

void InstrInit ( Instrumentation instr,
int  instrument_options 
)

Definition at line 58 of file instrument.c.

59{
60 memset(instr, 0, sizeof(Instrumentation));
61 instr->need_bufusage = (instrument_options & INSTRUMENT_BUFFERS) != 0;
62 instr->need_walusage = (instrument_options & INSTRUMENT_WAL) != 0;
63 instr->need_timer = (instrument_options & INSTRUMENT_TIMER) != 0;
64}

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

Referenced by ExecInitParallelPlan().

◆ InstrStartNode()

◆ InstrStartParallelQuery()

◆ InstrStopNode()

void InstrStopNode ( Instrumentation instr,
double  nTuples 
)

Definition at line 84 of file instrument.c.

85{
86 double save_tuplecount = instr->tuplecount;
87 instr_time endtime;
88
89 /* count the returned tuples */
90 instr->tuplecount += nTuples;
91
92 /* let's update the time only if the timer was requested */
93 if (instr->need_timer)
94 {
95 if (INSTR_TIME_IS_ZERO(instr->starttime))
96 elog(ERROR, "InstrStopNode called without start");
97
99 INSTR_TIME_ACCUM_DIFF(instr->counter, endtime, instr->starttime);
100
102 }
103
104 /* Add delta of buffer usage since entry to node's totals */
105 if (instr->need_bufusage)
107 &pgBufferUsage, &instr->bufusage_start);
108
109 if (instr->need_walusage)
111 &pgWalUsage, &instr->walusage_start);
112
113 /* Is this the first tuple of this cycle? */
114 if (!instr->running)
115 {
116 instr->running = true;
118 }
119 else
120 {
121 /*
122 * In async mode, if the plan node hadn't emitted any tuples before,
123 * this might be the first tuple
124 */
125 if (instr->async_mode && save_tuplecount < 1.0)
127 }
128}
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:122

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.

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

References Instrumentation::tuplecount.

Referenced by complete_pending_request().

◆ WalUsageAccumDiff()

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

◆ WalUsageAdd()

static void WalUsageAdd ( WalUsage dst,
WalUsage add 
)
static

Definition at line 278 of file instrument.c.

279{
280 dst->wal_bytes += add->wal_bytes;
281 dst->wal_records += add->wal_records;
282 dst->wal_fpi += add->wal_fpi;
284}

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

Referenced by InstrAccumParallelQuery(), and InstrAggNode().

Variable Documentation

◆ pgBufferUsage

◆ pgWalUsage

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