PostgreSQL Source Code  git master
wait_event.h File Reference
#include "utils/wait_event_types.h"
Include dependency graph for wait_event.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define PG_WAIT_LWLOCK   0x01000000U
 
#define PG_WAIT_LOCK   0x03000000U
 
#define PG_WAIT_BUFFERPIN   0x04000000U
 
#define PG_WAIT_ACTIVITY   0x05000000U
 
#define PG_WAIT_CLIENT   0x06000000U
 
#define PG_WAIT_EXTENSION   0x07000000U
 
#define PG_WAIT_IPC   0x08000000U
 
#define PG_WAIT_TIMEOUT   0x09000000U
 
#define PG_WAIT_IO   0x0A000000U
 

Enumerations

enum  WaitEventExtension { WAIT_EVENT_EXTENSION = PG_WAIT_EXTENSION , WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED }
 

Functions

const char * pgstat_get_wait_event (uint32 wait_event_info)
 
const char * pgstat_get_wait_event_type (uint32 wait_event_info)
 
static void pgstat_report_wait_start (uint32 wait_event_info)
 
static void pgstat_report_wait_end (void)
 
void pgstat_set_wait_event_storage (uint32 *wait_event_info)
 
void pgstat_reset_wait_event_storage (void)
 
void WaitEventExtensionShmemInit (void)
 
Size WaitEventExtensionShmemSize (void)
 
uint32 WaitEventExtensionNew (const char *wait_event_name)
 
char ** GetWaitEventExtensionNames (int *nwaitevents)
 

Variables

PGDLLIMPORT uint32my_wait_event_info
 

Macro Definition Documentation

◆ PG_WAIT_ACTIVITY

#define PG_WAIT_ACTIVITY   0x05000000U

Definition at line 21 of file wait_event.h.

◆ PG_WAIT_BUFFERPIN

#define PG_WAIT_BUFFERPIN   0x04000000U

Definition at line 20 of file wait_event.h.

◆ PG_WAIT_CLIENT

#define PG_WAIT_CLIENT   0x06000000U

Definition at line 22 of file wait_event.h.

◆ PG_WAIT_EXTENSION

#define PG_WAIT_EXTENSION   0x07000000U

Definition at line 23 of file wait_event.h.

◆ PG_WAIT_IO

#define PG_WAIT_IO   0x0A000000U

Definition at line 26 of file wait_event.h.

◆ PG_WAIT_IPC

#define PG_WAIT_IPC   0x08000000U

Definition at line 24 of file wait_event.h.

◆ PG_WAIT_LOCK

#define PG_WAIT_LOCK   0x03000000U

Definition at line 19 of file wait_event.h.

◆ PG_WAIT_LWLOCK

#define PG_WAIT_LWLOCK   0x01000000U

Definition at line 18 of file wait_event.h.

◆ PG_WAIT_TIMEOUT

#define PG_WAIT_TIMEOUT   0x09000000U

Definition at line 25 of file wait_event.h.

Enumeration Type Documentation

◆ WaitEventExtension

Enumerator
WAIT_EVENT_EXTENSION 
WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED 

Definition at line 56 of file wait_event.h.

57 {
#define PG_WAIT_EXTENSION
Definition: wait_event.h:23
WaitEventExtension
Definition: wait_event.h:57
@ WAIT_EVENT_EXTENSION
Definition: wait_event.h:58
@ WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED
Definition: wait_event.h:59

Function Documentation

◆ GetWaitEventExtensionNames()

char** GetWaitEventExtensionNames ( int *  nwaitevents)

Definition at line 273 of file wait_event.c.

274 {
275  char **waiteventnames;
277  HASH_SEQ_STATUS hash_seq;
278  int index;
279  int els;
280 
281  LWLockAcquire(WaitEventExtensionLock, LW_SHARED);
282 
283  /* Now we can safely count the number of entries */
285 
286  /* Allocate enough space for all entries */
287  waiteventnames = palloc(els * sizeof(char *));
288 
289  /* Now scan the hash table to copy the data */
291 
292  index = 0;
293  while ((hentry = (WaitEventExtensionEntryByName *) hash_seq_search(&hash_seq)) != NULL)
294  {
295  waiteventnames[index] = pstrdup(hentry->wait_event_name);
296  index++;
297  }
298 
299  LWLockRelease(WaitEventExtensionLock);
300 
301  Assert(index == els);
302 
303  *nwaitevents = index;
304  return waiteventnames;
305 }
long hash_get_num_entries(HTAB *hashp)
Definition: dynahash.c:1377
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1431
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1421
Assert(fmt[strlen(fmt) - 1] !='\n')
bool LWLockAcquire(LWLock *lock, LWLockMode mode)
Definition: lwlock.c:1195
void LWLockRelease(LWLock *lock)
Definition: lwlock.c:1808
@ LW_SHARED
Definition: lwlock.h:117
char * pstrdup(const char *in)
Definition: mcxt.c:1644
void * palloc(Size size)
Definition: mcxt.c:1226
char wait_event_name[NAMEDATALEN]
Definition: wait_event.c:78
Definition: type.h:95
static HTAB * WaitEventExtensionHashByName
Definition: wait_event.c:64

References Assert(), hash_get_num_entries(), hash_seq_init(), hash_seq_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), palloc(), pstrdup(), WaitEventExtensionEntryByName::wait_event_name, and WaitEventExtensionHashByName.

Referenced by pg_get_wait_events().

◆ pgstat_get_wait_event()

const char* pgstat_get_wait_event ( uint32  wait_event_info)

Definition at line 395 of file wait_event.c.

396 {
397  uint32 classId;
398  uint16 eventId;
399  const char *event_name;
400 
401  /* report process as not waiting. */
402  if (wait_event_info == 0)
403  return NULL;
404 
405  classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
406  eventId = wait_event_info & WAIT_EVENT_ID_MASK;
407 
408  switch (classId)
409  {
410  case PG_WAIT_LWLOCK:
411  event_name = GetLWLockIdentifier(classId, eventId);
412  break;
413  case PG_WAIT_LOCK:
414  event_name = GetLockNameFromTagType(eventId);
415  break;
416  case PG_WAIT_EXTENSION:
417  event_name = GetWaitEventExtensionIdentifier(eventId);
418  break;
419  case PG_WAIT_BUFFERPIN:
420  {
421  WaitEventBufferPin w = (WaitEventBufferPin) wait_event_info;
422 
423  event_name = pgstat_get_wait_bufferpin(w);
424  break;
425  }
426  case PG_WAIT_ACTIVITY:
427  {
428  WaitEventActivity w = (WaitEventActivity) wait_event_info;
429 
430  event_name = pgstat_get_wait_activity(w);
431  break;
432  }
433  case PG_WAIT_CLIENT:
434  {
435  WaitEventClient w = (WaitEventClient) wait_event_info;
436 
437  event_name = pgstat_get_wait_client(w);
438  break;
439  }
440  case PG_WAIT_IPC:
441  {
442  WaitEventIPC w = (WaitEventIPC) wait_event_info;
443 
444  event_name = pgstat_get_wait_ipc(w);
445  break;
446  }
447  case PG_WAIT_TIMEOUT:
448  {
449  WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
450 
451  event_name = pgstat_get_wait_timeout(w);
452  break;
453  }
454  case PG_WAIT_IO:
455  {
456  WaitEventIO w = (WaitEventIO) wait_event_info;
457 
458  event_name = pgstat_get_wait_io(w);
459  break;
460  }
461  default:
462  event_name = "unknown wait event";
463  break;
464  }
465 
466  return event_name;
467 }
unsigned short uint16
Definition: c.h:494
unsigned int uint32
Definition: c.h:495
const char * GetLockNameFromTagType(uint16 locktag_type)
Definition: lmgr.c:1303
const char * GetLWLockIdentifier(uint32 classId, uint16 eventId)
Definition: lwlock.c:794
static const char * pgstat_get_wait_ipc(WaitEventIPC w)
static const char * pgstat_get_wait_io(WaitEventIO w)
static const char * pgstat_get_wait_bufferpin(WaitEventBufferPin w)
static const char * pgstat_get_wait_timeout(WaitEventTimeout w)
static const char * pgstat_get_wait_client(WaitEventClient w)
#define WAIT_EVENT_ID_MASK
Definition: wait_event.c:46
#define WAIT_EVENT_CLASS_MASK
Definition: wait_event.c:45
static const char * GetWaitEventExtensionIdentifier(uint16 eventId)
Definition: wait_event.c:243
static const char * pgstat_get_wait_activity(WaitEventActivity w)
#define PG_WAIT_TIMEOUT
Definition: wait_event.h:25
#define PG_WAIT_LWLOCK
Definition: wait_event.h:18
#define PG_WAIT_BUFFERPIN
Definition: wait_event.h:20
#define PG_WAIT_IPC
Definition: wait_event.h:24
#define PG_WAIT_CLIENT
Definition: wait_event.h:22
#define PG_WAIT_ACTIVITY
Definition: wait_event.h:21
#define PG_WAIT_LOCK
Definition: wait_event.h:19
#define PG_WAIT_IO
Definition: wait_event.h:26

References GetLockNameFromTagType(), GetLWLockIdentifier(), GetWaitEventExtensionIdentifier(), PG_WAIT_ACTIVITY, PG_WAIT_BUFFERPIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, pgstat_get_wait_activity(), pgstat_get_wait_bufferpin(), pgstat_get_wait_client(), pgstat_get_wait_io(), pgstat_get_wait_ipc(), pgstat_get_wait_timeout(), WAIT_EVENT_CLASS_MASK, and WAIT_EVENT_ID_MASK.

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event().

◆ pgstat_get_wait_event_type()

const char* pgstat_get_wait_event_type ( uint32  wait_event_info)

Definition at line 340 of file wait_event.c.

341 {
342  uint32 classId;
343  const char *event_type;
344 
345  /* report process as not waiting. */
346  if (wait_event_info == 0)
347  return NULL;
348 
349  classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
350 
351  switch (classId)
352  {
353  case PG_WAIT_LWLOCK:
354  event_type = "LWLock";
355  break;
356  case PG_WAIT_LOCK:
357  event_type = "Lock";
358  break;
359  case PG_WAIT_BUFFERPIN:
360  event_type = "BufferPin";
361  break;
362  case PG_WAIT_ACTIVITY:
363  event_type = "Activity";
364  break;
365  case PG_WAIT_CLIENT:
366  event_type = "Client";
367  break;
368  case PG_WAIT_EXTENSION:
369  event_type = "Extension";
370  break;
371  case PG_WAIT_IPC:
372  event_type = "IPC";
373  break;
374  case PG_WAIT_TIMEOUT:
375  event_type = "Timeout";
376  break;
377  case PG_WAIT_IO:
378  event_type = "IO";
379  break;
380  default:
381  event_type = "???";
382  break;
383  }
384 
385  return event_type;
386 }

References PG_WAIT_ACTIVITY, PG_WAIT_BUFFERPIN, PG_WAIT_CLIENT, PG_WAIT_EXTENSION, PG_WAIT_IO, PG_WAIT_IPC, PG_WAIT_LOCK, PG_WAIT_LWLOCK, PG_WAIT_TIMEOUT, and WAIT_EVENT_CLASS_MASK.

Referenced by pg_stat_get_activity(), and pg_stat_get_backend_wait_event_type().

◆ pgstat_report_wait_end()

static void pgstat_report_wait_end ( void  )
inlinestatic

Definition at line 104 of file wait_event.h.

105 {
106  /* see pgstat_report_wait_start() */
107  *(volatile uint32 *) my_wait_event_info = 0;
108 }
PGDLLIMPORT uint32 * my_wait_event_info
Definition: wait_event.c:43

References my_wait_event_info.

Referenced by AbortSubTransaction(), AbortTransaction(), AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_wal_sync_method(), AutoVacLauncherMain(), BackgroundWriterMain(), basebackup_read_file(), BootStrapXLOG(), CheckpointerMain(), CheckPointLogicalRewriteHeap(), copy_file(), CreateCheckPoint(), CreateDirAndVersionFile(), CreateLockFile(), dsm_impl_mmap(), dsm_impl_posix_resize(), ExecuteRecoveryCommand(), FileFallocate(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), FileZero(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), LWLockReportWaitEnd(), perform_spin_delay(), ProcArrayGroupClearXid(), read_relmap_file(), ReadControlFile(), readTimeLineHistory(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferSerializeChange(), RestoreArchivedFile(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), shell_archive_file(), ShutdownAuxiliaryProcess(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SlruSyncFileTag(), SnapBuildRestoreContents(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), update_controlfile(), vacuum_delay_point(), WaitEventSetWait(), WaitExceedsMaxStandbyDelay(), WALRead(), WalSndErrorCleanup(), WalWriterMain(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInitInternal(), XLogPageRead(), and XLogWrite().

◆ pgstat_report_wait_start()

static void pgstat_report_wait_start ( uint32  wait_event_info)
inlinestatic

Definition at line 88 of file wait_event.h.

89 {
90  /*
91  * Since this is a four-byte field which is always read and written as
92  * four-bytes, updates are atomic.
93  */
94  *(volatile uint32 *) my_wait_event_info = wait_event_info;
95 }

References my_wait_event_info.

Referenced by AddToDataDirLockFile(), ApplyLogicalMappingFile(), assign_wal_sync_method(), basebackup_read_file(), BootStrapXLOG(), CheckPointLogicalRewriteHeap(), copy_file(), CreateCheckPoint(), CreateDirAndVersionFile(), CreateLockFile(), dsm_impl_mmap(), dsm_impl_posix_resize(), ExecuteRecoveryCommand(), FileFallocate(), FilePrefetch(), FileRead(), FileSync(), FileTruncate(), FileWrite(), FileWriteback(), FileZero(), heap_xlog_logical_rewrite(), issue_xlog_fsync(), LWLockReportWaitStart(), perform_spin_delay(), ProcArrayGroupClearXid(), read_relmap_file(), ReadControlFile(), readTimeLineHistory(), ReadTwoPhaseFile(), RecheckDataDirLockFile(), RecreateTwoPhaseFile(), ReorderBufferSerializeChange(), RestoreArchivedFile(), RestoreSlotFromDisk(), SaveSlotToPath(), SendTimeLineHistory(), shell_archive_file(), SlruPhysicalReadPage(), SlruPhysicalWritePage(), SlruSyncFileTag(), SnapBuildRestoreContents(), SnapBuildSerialize(), TransactionGroupUpdateXidStatus(), update_controlfile(), vacuum_delay_point(), WaitEventSetWait(), WaitExceedsMaxStandbyDelay(), WALRead(), write_relmap_file(), WriteControlFile(), writeTimeLineHistory(), writeTimeLineHistoryFile(), XLogFileCopy(), XLogFileInitInternal(), XLogPageRead(), and XLogWrite().

◆ pgstat_reset_wait_event_storage()

void pgstat_reset_wait_event_storage ( void  )

Definition at line 328 of file wait_event.c.

329 {
331 }
static uint32 local_my_wait_event_info
Definition: wait_event.c:42
uint32 * my_wait_event_info
Definition: wait_event.c:43

References local_my_wait_event_info, and my_wait_event_info.

Referenced by AuxiliaryProcKill(), and ProcKill().

◆ pgstat_set_wait_event_storage()

void pgstat_set_wait_event_storage ( uint32 wait_event_info)

Definition at line 316 of file wait_event.c.

317 {
318  my_wait_event_info = wait_event_info;
319 }

References my_wait_event_info.

Referenced by InitAuxiliaryProcess(), and InitProcess().

◆ WaitEventExtensionNew()

uint32 WaitEventExtensionNew ( const char *  wait_event_name)

Definition at line 164 of file wait_event.c.

165 {
166  uint16 eventId;
167  bool found;
168  WaitEventExtensionEntryByName *entry_by_name;
169  WaitEventExtensionEntryById *entry_by_id;
170 
171  /* Check the limit of the length of the event name */
172  if (strlen(wait_event_name) >= NAMEDATALEN)
173  elog(ERROR,
174  "cannot use custom wait event string longer than %u characters",
175  NAMEDATALEN - 1);
176 
177  /*
178  * Check if the wait event info associated to the name is already defined,
179  * and return it if so.
180  */
181  LWLockAcquire(WaitEventExtensionLock, LW_SHARED);
182  entry_by_name = (WaitEventExtensionEntryByName *)
183  hash_search(WaitEventExtensionHashByName, wait_event_name,
184  HASH_FIND, &found);
185  LWLockRelease(WaitEventExtensionLock);
186  if (found)
187  return WAIT_EVENT_EXTENSION_INFO(entry_by_name->event_id);
188 
189  /*
190  * Allocate and register a new wait event. Recheck if the event name
191  * exists, as it could be possible that a concurrent process has inserted
192  * one with the same name since the LWLock acquired again here was
193  * previously released.
194  */
195  LWLockAcquire(WaitEventExtensionLock, LW_EXCLUSIVE);
196  entry_by_name = (WaitEventExtensionEntryByName *)
197  hash_search(WaitEventExtensionHashByName, wait_event_name,
198  HASH_FIND, &found);
199  if (found)
200  {
201  LWLockRelease(WaitEventExtensionLock);
202  return WAIT_EVENT_EXTENSION_INFO(entry_by_name->event_id);
203  }
204 
205  /* Allocate a new event Id */
207 
209  {
211  ereport(ERROR,
212  errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
213  errmsg("too many wait events for extensions"));
214  }
215 
216  eventId = WaitEventExtensionCounter->nextId++;
217 
219 
220  /* Register the new wait event */
221  entry_by_id = (WaitEventExtensionEntryById *)
223  HASH_ENTER, &found);
224  Assert(!found);
225  strlcpy(entry_by_id->wait_event_name, wait_event_name,
226  sizeof(entry_by_id->wait_event_name));
227 
228  entry_by_name = (WaitEventExtensionEntryByName *)
229  hash_search(WaitEventExtensionHashByName, wait_event_name,
230  HASH_ENTER, &found);
231  Assert(!found);
232  entry_by_name->event_id = eventId;
233 
234  LWLockRelease(WaitEventExtensionLock);
235 
236  return WAIT_EVENT_EXTENSION_INFO(eventId);
237 }
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:953
int errcode(int sqlerrcode)
Definition: elog.c:858
int errmsg(const char *fmt,...)
Definition: elog.c:1069
#define ERROR
Definition: elog.h:39
#define ereport(elevel,...)
Definition: elog.h:149
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_ENTER
Definition: hsearch.h:114
@ LW_EXCLUSIVE
Definition: lwlock.h:116
#define NAMEDATALEN
size_t strlcpy(char *dst, const char *src, size_t siz)
Definition: strlcpy.c:45
#define SpinLockRelease(lock)
Definition: spin.h:64
#define SpinLockAcquire(lock)
Definition: spin.h:62
char wait_event_name[NAMEDATALEN]
Definition: wait_event.c:73
static WaitEventExtensionCounterData * WaitEventExtensionCounter
Definition: wait_event.c:91
#define WAIT_EVENT_EXTENSION_INFO(eventId)
Definition: wait_event.c:98
static HTAB * WaitEventExtensionHashById
Definition: wait_event.c:63
#define WAIT_EVENT_EXTENSION_HASH_MAX_SIZE
Definition: wait_event.c:67

References Assert(), elog(), ereport, errcode(), errmsg(), ERROR, WaitEventExtensionEntryByName::event_id, HASH_ENTER, HASH_FIND, hash_search(), LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), WaitEventExtensionCounterData::mutex, NAMEDATALEN, WaitEventExtensionCounterData::nextId, SpinLockAcquire, SpinLockRelease, strlcpy(), WAIT_EVENT_EXTENSION_HASH_MAX_SIZE, WAIT_EVENT_EXTENSION_INFO, WaitEventExtensionEntryById::wait_event_name, WaitEventExtensionCounter, WaitEventExtensionHashById, and WaitEventExtensionHashByName.

Referenced by connect_pg_server(), dblink_connect(), dblink_get_conn(), pgfdw_get_cleanup_result(), pgfdw_get_result(), test_shm_mq_pipelined(), wait_for_workers_to_become_ready(), and worker_spi_main().

◆ WaitEventExtensionShmemInit()

void WaitEventExtensionShmemInit ( void  )

Definition at line 122 of file wait_event.c.

123 {
124  bool found;
125  HASHCTL info;
126 
128  ShmemInitStruct("WaitEventExtensionCounterData",
129  sizeof(WaitEventExtensionCounterData), &found);
130 
131  if (!found)
132  {
133  /* initialize the allocation counter and its spinlock. */
136  }
137 
138  /* initialize or attach the hash tables to store custom wait events */
139  info.keysize = sizeof(uint16);
140  info.entrysize = sizeof(WaitEventExtensionEntryById);
141  WaitEventExtensionHashById = ShmemInitHash("WaitEventExtension hash by id",
144  &info,
146 
147  /* key is a NULL-terminated string */
148  info.keysize = sizeof(char[NAMEDATALEN]);
150  WaitEventExtensionHashByName = ShmemInitHash("WaitEventExtension hash by name",
153  &info,
155 }
#define HASH_STRINGS
Definition: hsearch.h:96
#define HASH_ELEM
Definition: hsearch.h:95
#define HASH_BLOBS
Definition: hsearch.h:97
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:396
HTAB * ShmemInitHash(const char *name, long init_size, long max_size, HASHCTL *infoP, int hash_flags)
Definition: shmem.c:341
#define SpinLockInit(lock)
Definition: spin.h:60
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
#define NUM_BUILTIN_WAIT_EVENT_EXTENSION
Definition: wait_event.c:94
struct WaitEventExtensionEntryByName WaitEventExtensionEntryByName
#define WAIT_EVENT_EXTENSION_HASH_INIT_SIZE
Definition: wait_event.c:66
struct WaitEventExtensionEntryById WaitEventExtensionEntryById

References HASHCTL::entrysize, HASH_BLOBS, HASH_ELEM, HASH_STRINGS, HASHCTL::keysize, WaitEventExtensionCounterData::mutex, NAMEDATALEN, WaitEventExtensionCounterData::nextId, NUM_BUILTIN_WAIT_EVENT_EXTENSION, ShmemInitHash(), ShmemInitStruct(), SpinLockInit, WAIT_EVENT_EXTENSION_HASH_INIT_SIZE, WAIT_EVENT_EXTENSION_HASH_MAX_SIZE, WaitEventExtensionCounter, WaitEventExtensionHashById, and WaitEventExtensionHashByName.

Referenced by CreateOrAttachShmemStructs().

◆ WaitEventExtensionShmemSize()

Size WaitEventExtensionShmemSize ( void  )

Definition at line 106 of file wait_event.c.

107 {
108  Size sz;
109 
112  sizeof(WaitEventExtensionEntryById)));
115  return sz;
116 }
#define MAXALIGN(LEN)
Definition: c.h:800
size_t Size
Definition: c.h:594
Size hash_estimate_size(long num_entries, Size entrysize)
Definition: dynahash.c:781
Size add_size(Size s1, Size s2)
Definition: shmem.c:502

References add_size(), hash_estimate_size(), MAXALIGN, and WAIT_EVENT_EXTENSION_HASH_MAX_SIZE.

Referenced by CalculateShmemSize().

Variable Documentation

◆ my_wait_event_info