Line data    Source code

       1             : /*-------------------------------------------------------------------------
       2             :  * wait_event.h
       3             :  *    Definitions related to wait event reporting
       4             :  *
       5             :  * Copyright (c) 2001-2025, PostgreSQL Global Development Group
       6             :  *
       7             :  * src/include/utils/wait_event.h
       8             :  * ----------
       9             :  */
      10             : #ifndef WAIT_EVENT_H
      11             : #define WAIT_EVENT_H
      12             : 
      13             : /* enums for wait events */
      14             : #include "utils/wait_event_types.h"
      15             : 
      16             : extern const char *pgstat_get_wait_event(uint32 wait_event_info);
      17             : extern const char *pgstat_get_wait_event_type(uint32 wait_event_info);
      18             : static inline void pgstat_report_wait_start(uint32 wait_event_info);
      19             : static inline void pgstat_report_wait_end(void);
      20             : extern void pgstat_set_wait_event_storage(uint32 *wait_event_info);
      21             : extern void pgstat_reset_wait_event_storage(void);
      22             : 
      23             : extern PGDLLIMPORT uint32 *my_wait_event_info;
      24             : 
      25             : 
      26             : /*
      27             :  * Wait Events - Extension, InjectionPoint
      28             :  *
      29             :  * Use InjectionPoint when the server process is waiting in an injection
      30             :  * point.  Use Extension for other cases of the server process waiting for
      31             :  * some condition defined by an extension module.
      32             :  *
      33             :  * Extensions can define their own wait events in these categories.  They
      34             :  * should call one of these functions with a wait event string.  If the wait
      35             :  * event associated to a string is already allocated, it returns the wait
      36             :  * event information to use.  If not, it gets one wait event ID allocated from
      37             :  * a shared counter, associates the string to the ID in the shared dynamic
      38             :  * hash and returns the wait event information.
      39             :  *
      40             :  * The ID retrieved can be used with pgstat_report_wait_start() or equivalent.
      41             :  */
      42             : extern uint32 WaitEventExtensionNew(const char *wait_event_name);
      43             : extern uint32 WaitEventInjectionPointNew(const char *wait_event_name);
      44             : 
      45             : extern void WaitEventCustomShmemInit(void);
      46             : extern Size WaitEventCustomShmemSize(void);
      47             : extern char **GetWaitEventCustomNames(uint32 classId, int *nwaitevents);
      48             : 
      49             : /* ----------
      50             :  * pgstat_report_wait_start() -
      51             :  *
      52             :  *  Called from places where server process needs to wait.  This is called
      53             :  *  to report wait event information.  The wait information is stored
      54             :  *  as 4-bytes where first byte represents the wait event class (type of
      55             :  *  wait, for different types of wait, refer WaitClass) and the next
      56             :  *  3-bytes represent the actual wait event.  Currently 2-bytes are used
      57             :  *  for wait event which is sufficient for current usage, 1-byte is
      58             :  *  reserved for future usage.
      59             :  *
      60             :  *  Historically we used to make this reporting conditional on
      61             :  *  pgstat_track_activities, but the check for that seems to add more cost
      62             :  *  than it saves.
      63             :  *
      64             :  *  my_wait_event_info initially points to local memory, making it safe to
      65             :  *  call this before MyProc has been initialized.
      66             :  * ----------
      67             :  */
      68             : static inline void
      69    38183406 : pgstat_report_wait_start(uint32 wait_event_info)
      70             : {
      71             :     /*
      72             :      * Since this is a four-byte field which is always read and written as
      73             :      * four-bytes, updates are atomic.
      74             :      */
      75    38183406 :     *(volatile uint32 *) my_wait_event_info = wait_event_info;
      76    38183406 : }
      77             : 
      78             : /* ----------
      79             :  * pgstat_report_wait_end() -
      80             :  *
      81             :  *  Called to report end of a wait.
      82             :  * ----------
      83             :  */
      84             : static inline void
      85    38249856 : pgstat_report_wait_end(void)
      86             : {
      87             :     /* see pgstat_report_wait_start() */
      88    38249856 :     *(volatile uint32 *) my_wait_event_info = 0;
      89    38249856 : }
      90             : 
      91             : 
      92             : #endif                          /* WAIT_EVENT_H */