[フレーム]

Data Structures | Typedefs | Enumerations | Functions | Variables

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 WorkerInstrumentation

Typedefs

typedef struct BufferUsage BufferUsage

typedef struct WalUsage WalUsage

typedef enum InstrumentOption InstrumentOption

typedef struct Instrumentation Instrumentation

typedef struct WorkerInstrumentation WorkerInstrumentation

Enumerations

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

Functions

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

PGDLLIMPORT BufferUsage pgBufferUsage

PGDLLIMPORT WalUsage pgWalUsage

Typedef Documentation

◆ BufferUsage

typedef struct BufferUsage BufferUsage

◆ Instrumentation

typedef struct Instrumentation Instrumentation

◆ InstrumentOption

typedef enum InstrumentOption InstrumentOption

◆ WalUsage

typedef struct WalUsage WalUsage

◆ WorkerInstrumentation

typedef struct WorkerInstrumentation WorkerInstrumentation

Enumeration Type Documentation

◆ InstrumentOption

enum InstrumentOption

Enumerator
INSTRUMENT_TIMER
INSTRUMENT_BUFFERS
INSTRUMENT_ROWS
INSTRUMENT_WAL
INSTRUMENT_ALL

Definition at line 60 of file instrument.h.

61{

62 INSTRUMENT_TIMER = 1 << 0, /* needs timer (and row counts) */

63 INSTRUMENT_BUFFERS = 1 << 1, /* needs buffer usage */

64 INSTRUMENT_ROWS = 1 << 2, /* needs row count */

65 INSTRUMENT_WAL = 1 << 3, /* needs WAL usage */

66 INSTRUMENT_ALL = PG_INT32_MAX

67} InstrumentOption;

PG_INT32_MAX

#define PG_INT32_MAX

Definition: c.h:594

InstrumentOption

Definition: instrument.h:61

INSTRUMENT_ALL

@ INSTRUMENT_ALL

Definition: instrument.h:66

INSTRUMENT_TIMER

@ INSTRUMENT_TIMER

Definition: instrument.h:62

INSTRUMENT_BUFFERS

@ INSTRUMENT_BUFFERS

Definition: instrument.h:63

INSTRUMENT_WAL

@ INSTRUMENT_WAL

Definition: instrument.h:65

INSTRUMENT_ROWS

@ INSTRUMENT_ROWS

Definition: instrument.h:64

Function Documentation

◆ BufferUsageAccumDiff()

void BufferUsageAccumDiff ( BufferUsage * dst,

const BufferUsage * add,

const BufferUsage * sub

)

Definition at line 248 of file instrument.c.

251{

252 dst->shared_blks_hit += add->shared_blks_hit - sub->shared_blks_hit;

253 dst->shared_blks_read += add->shared_blks_read - sub->shared_blks_read;

254 dst->shared_blks_dirtied += add->shared_blks_dirtied - sub->shared_blks_dirtied;

255 dst->shared_blks_written += add->shared_blks_written - sub->shared_blks_written;

256 dst->local_blks_hit += add->local_blks_hit - sub->local_blks_hit;

257 dst->local_blks_read += add->local_blks_read - sub->local_blks_read;

258 dst->local_blks_dirtied += add->local_blks_dirtied - sub->local_blks_dirtied;

259 dst->local_blks_written += add->local_blks_written - sub->local_blks_written;

260 dst->temp_blks_read += add->temp_blks_read - sub->temp_blks_read;

261 dst->temp_blks_written += add->temp_blks_written - sub->temp_blks_written;

262 INSTR_TIME_ACCUM_DIFF(dst->shared_blk_read_time,

263 add->shared_blk_read_time, sub->shared_blk_read_time);

264 INSTR_TIME_ACCUM_DIFF(dst->shared_blk_write_time,

265 add->shared_blk_write_time, sub->shared_blk_write_time);

266 INSTR_TIME_ACCUM_DIFF(dst->local_blk_read_time,

267 add->local_blk_read_time, sub->local_blk_read_time);

268 INSTR_TIME_ACCUM_DIFF(dst->local_blk_write_time,

269 add->local_blk_write_time, sub->local_blk_write_time);

270 INSTR_TIME_ACCUM_DIFF(dst->temp_blk_read_time,

271 add->temp_blk_read_time, sub->temp_blk_read_time);

272 INSTR_TIME_ACCUM_DIFF(dst->temp_blk_write_time,

273 add->temp_blk_write_time, sub->temp_blk_write_time);

274}

INSTR_TIME_ACCUM_DIFF

#define INSTR_TIME_ACCUM_DIFF(x, y, z)

Definition: instr_time.h:184

BufferUsage::local_blk_read_time

instr_time local_blk_read_time

Definition: instrument.h:38

BufferUsage::shared_blks_dirtied

int64 shared_blks_dirtied

Definition: instrument.h:28

BufferUsage::local_blks_hit

int64 local_blks_hit

Definition: instrument.h:30

BufferUsage::temp_blk_write_time

instr_time temp_blk_write_time

Definition: instrument.h:41

BufferUsage::shared_blk_read_time

instr_time shared_blk_read_time

Definition: instrument.h:36

BufferUsage::shared_blk_write_time

instr_time shared_blk_write_time

Definition: instrument.h:37

BufferUsage::local_blks_written

int64 local_blks_written

Definition: instrument.h:33

BufferUsage::temp_blk_read_time

instr_time temp_blk_read_time

Definition: instrument.h:40

BufferUsage::local_blk_write_time

instr_time local_blk_write_time

Definition: instrument.h:39

BufferUsage::temp_blks_read

int64 temp_blks_read

Definition: instrument.h:34

BufferUsage::shared_blks_read

int64 shared_blks_read

Definition: instrument.h:27

BufferUsage::shared_blks_written

int64 shared_blks_written

Definition: instrument.h:29

BufferUsage::temp_blks_written

int64 temp_blks_written

Definition: instrument.h:35

BufferUsage::local_blks_read

int64 local_blks_read

Definition: instrument.h:31

BufferUsage::local_blks_dirtied

int64 local_blks_dirtied

Definition: instrument.h:32

BufferUsage::shared_blks_hit

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

◆ 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}

BufferUsageAdd

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

Definition: instrument.c:226

WalUsageAdd

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

Definition: instrument.c:278

pgWalUsage

WalUsage pgWalUsage

Definition: instrument.c:22

pgBufferUsage

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}

INSTR_TIME_ADD

#define INSTR_TIME_ADD(x, y)

Definition: instr_time.h:178

Instrumentation::nfiltered2

double nfiltered2

Definition: instrument.h:91

Instrumentation::nfiltered1

double nfiltered1

Definition: instrument.h:90

Instrumentation::startup

double startup

Definition: instrument.h:85

Instrumentation::walusage

WalUsage walusage

Definition: instrument.h:93

Instrumentation::need_bufusage

bool need_bufusage

Definition: instrument.h:73

Instrumentation::nloops

double nloops

Definition: instrument.h:89

Instrumentation::ntuples

double ntuples

Definition: instrument.h:87

Instrumentation::bufusage

BufferUsage bufusage

Definition: instrument.h:92

Instrumentation::need_walusage

bool need_walusage

Definition: instrument.h:74

Instrumentation::running

bool running

Definition: instrument.h:77

Instrumentation::total

double total

Definition: instrument.h:86

Instrumentation::counter

instr_time counter

Definition: instrument.h:79

Instrumentation::firsttuple

double firsttuple

Definition: instrument.h:80

Instrumentation::ntuples2

double ntuples2

Definition: instrument.h:88

Instrumentation::tuplecount

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}

i

int i

Definition: isn.c:77

palloc0

void * palloc0(Size size)

Definition: mcxt.c:1395

Instrumentation

Definition: instrument.h:70

Instrumentation::async_mode

bool async_mode

Definition: instrument.h:75

Instrumentation::need_timer

bool need_timer

Definition: instrument.h:72

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;

161 INSTR_TIME_SET_ZERO(instr->starttime);

162 INSTR_TIME_SET_ZERO(instr->counter);

163 instr->firsttuple = 0;

164 instr->tuplecount = 0;

165}

ERROR

#define ERROR

Definition: elog.h:39

elog

#define elog(elevel,...)

Definition: elog.h:226

INSTR_TIME_IS_ZERO

#define INSTR_TIME_IS_ZERO(t)

Definition: instr_time.h:169

INSTR_TIME_GET_DOUBLE

#define INSTR_TIME_GET_DOUBLE(t)

Definition: instr_time.h:188

INSTR_TIME_SET_ZERO

#define INSTR_TIME_SET_ZERO(t)

Definition: instr_time.h:172

Instrumentation::starttime

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));

211 BufferUsageAccumDiff(bufusage, &pgBufferUsage, &save_pgBufferUsage);

212 memset(walusage, 0, sizeof(WalUsage));

213 WalUsageAccumDiff(walusage, &pgWalUsage, &save_pgWalUsage);

214}

save_pgBufferUsage

static BufferUsage save_pgBufferUsage

Definition: instrument.c:21

save_pgWalUsage

static WalUsage save_pgWalUsage

Definition: instrument.c:23

WalUsageAccumDiff

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

Definition: instrument.c:287

BufferUsageAccumDiff

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

Definition: instrument.c:248

BufferUsage

Definition: instrument.h:25

WalUsage

Definition: instrument.h:52

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

void InstrStartNode ( Instrumentation * instr )

Definition at line 68 of file instrument.c.

69{

70 if (instr->need_timer &&

71 !INSTR_TIME_SET_CURRENT_LAZY(instr->starttime))

72 elog(ERROR, "InstrStartNode called twice in a row");

73

74 /* save buffer usage totals at node entry, if needed */

75 if (instr->need_bufusage)

76 instr->bufusage_start = pgBufferUsage;

77

78 if (instr->need_walusage)

79 instr->walusage_start = pgWalUsage;

80}

INSTR_TIME_SET_CURRENT_LAZY

#define INSTR_TIME_SET_CURRENT_LAZY(t)

Definition: instr_time.h:174

Instrumentation::bufusage_start

BufferUsage bufusage_start

Definition: instrument.h:82

Instrumentation::walusage_start

WalUsage walusage_start

Definition: instrument.h:83

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.

201{

202 save_pgBufferUsage = pgBufferUsage;

203 save_pgWalUsage = pgWalUsage;

204}

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

◆ 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

98 INSTR_TIME_SET_CURRENT(endtime);

99 INSTR_TIME_ACCUM_DIFF(instr->counter, endtime, instr->starttime);

100

101 INSTR_TIME_SET_ZERO(instr->starttime);

102 }

103

104 /* Add delta of buffer usage since entry to node's totals */

105 if (instr->need_bufusage)

106 BufferUsageAccumDiff(&instr->bufusage,

107 &pgBufferUsage, &instr->bufusage_start);

108

109 if (instr->need_walusage)

110 WalUsageAccumDiff(&instr->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;

117 instr->firsttuple = INSTR_TIME_GET_DOUBLE(instr->counter);

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)

126 instr->firsttuple = INSTR_TIME_GET_DOUBLE(instr->counter);

127 }

128}

INSTR_TIME_SET_CURRENT

#define INSTR_TIME_SET_CURRENT(t)

Definition: instr_time.h:122

instr_time

Definition: instr_time.h:70

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

)

Definition at line 287 of file instrument.c.

288{

289 dst->wal_bytes += add->wal_bytes - sub->wal_bytes;

290 dst->wal_records += add->wal_records - sub->wal_records;

291 dst->wal_fpi += add->wal_fpi - sub->wal_fpi;

292 dst->wal_buffers_full += add->wal_buffers_full - sub->wal_buffers_full;

293}

WalUsage::wal_buffers_full

int64 wal_buffers_full

Definition: instrument.h:56

WalUsage::wal_bytes

uint64 wal_bytes

Definition: instrument.h:55

WalUsage::wal_fpi

int64 wal_fpi

Definition: instrument.h:54

WalUsage::wal_records

int64 wal_records

Definition: instrument.h:53

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

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

Variable Documentation

◆ pgBufferUsage

PGDLLIMPORT BufferUsage pgBufferUsage

extern

Definition at line 20 of file instrument.c.

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

◆ pgWalUsage

PGDLLIMPORT WalUsage pgWalUsage

extern

Definition at line 22 of file instrument.c.

Referenced by AdvanceXLInsertBuffer(), do_analyze_rel(), heap_page_prune_and_freeze(), heap_vacuum_rel(), InstrAccumParallelQuery(), InstrEndParallelQuery(), InstrStartNode(), InstrStartParallelQuery(), InstrStopNode(), 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().

src
include
executor
instrument.h
Generated on Sun Oct 5 2025 06:13:26 for PostgreSQL Source Code by doxygen 1.9.4