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 uint32 *	my_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

enum WaitEventExtension

Enumerator
WAIT_EVENT_EXTENSION
WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED

Definition at line 56 of file wait_event.h.

{
    WAIT_EVENT_EXTENSION = PG_WAIT_EXTENSION,
    WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED,
} WaitEventExtension;

Function Documentation

GetWaitEventExtensionNames()

char** GetWaitEventExtensionNames

(

int *

nwaitevents

)

Definition at line 273 of file wait_event.c.

{
    char      **waiteventnames;
    WaitEventExtensionEntryByName *hentry;
    HASH_SEQ_STATUS hash_seq;
    int         index;
    int         els;
 
    LWLockAcquire(WaitEventExtensionLock, LW_SHARED);
 
    /* Now we can safely count the number of entries */
    els = hash_get_num_entries(WaitEventExtensionHashByName);
 
    /* Allocate enough space for all entries */
    waiteventnames = palloc(els * sizeof(char *));
 
    /* Now scan the hash table to copy the data */
    hash_seq_init(&hash_seq, WaitEventExtensionHashByName);
 
    index = 0;
    while ((hentry = (WaitEventExtensionEntryByName *) hash_seq_search(&hash_seq)) != NULL)
    {
        waiteventnames[index] = pstrdup(hentry->wait_event_name);
        index++;
    }
 
    LWLockRelease(WaitEventExtensionLock);
 
    Assert(index == els);
 
    *nwaitevents = index;
    return waiteventnames;
}

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.

{
    uint32      classId;
    uint16      eventId;
    const char *event_name;
 
    /* report process as not waiting. */
    if (wait_event_info == 0)
        return NULL;
 
    classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
    eventId = wait_event_info & WAIT_EVENT_ID_MASK;
 
    switch (classId)
    {
        case PG_WAIT_LWLOCK:
            event_name = GetLWLockIdentifier(classId, eventId);
            break;
        case PG_WAIT_LOCK:
            event_name = GetLockNameFromTagType(eventId);
            break;
        case PG_WAIT_EXTENSION:
            event_name = GetWaitEventExtensionIdentifier(eventId);
            break;
        case PG_WAIT_BUFFERPIN:
            {
                WaitEventBufferPin w = (WaitEventBufferPin) wait_event_info;
 
                event_name = pgstat_get_wait_bufferpin(w);
                break;
            }
        case PG_WAIT_ACTIVITY:
            {
                WaitEventActivity w = (WaitEventActivity) wait_event_info;
 
                event_name = pgstat_get_wait_activity(w);
                break;
            }
        case PG_WAIT_CLIENT:
            {
                WaitEventClient w = (WaitEventClient) wait_event_info;
 
                event_name = pgstat_get_wait_client(w);
                break;
            }
        case PG_WAIT_IPC:
            {
                WaitEventIPC w = (WaitEventIPC) wait_event_info;
 
                event_name = pgstat_get_wait_ipc(w);
                break;
            }
        case PG_WAIT_TIMEOUT:
            {
                WaitEventTimeout w = (WaitEventTimeout) wait_event_info;
 
                event_name = pgstat_get_wait_timeout(w);
                break;
            }
        case PG_WAIT_IO:
            {
                WaitEventIO w = (WaitEventIO) wait_event_info;
 
                event_name = pgstat_get_wait_io(w);
                break;
            }
        default:
            event_name = "unknown wait event";
            break;
    }
 
    return event_name;
}

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.

{
    uint32      classId;
    const char *event_type;
 
    /* report process as not waiting. */
    if (wait_event_info == 0)
        return NULL;
 
    classId = wait_event_info & WAIT_EVENT_CLASS_MASK;
 
    switch (classId)
    {
        case PG_WAIT_LWLOCK:
            event_type = "LWLock";
            break;
        case PG_WAIT_LOCK:
            event_type = "Lock";
            break;
        case PG_WAIT_BUFFERPIN:
            event_type = "BufferPin";
            break;
        case PG_WAIT_ACTIVITY:
            event_type = "Activity";
            break;
        case PG_WAIT_CLIENT:
            event_type = "Client";
            break;
        case PG_WAIT_EXTENSION:
            event_type = "Extension";
            break;
        case PG_WAIT_IPC:
            event_type = "IPC";
            break;
        case PG_WAIT_TIMEOUT:
            event_type = "Timeout";
            break;
        case PG_WAIT_IO:
            event_type = "IO";
            break;
        default:
            event_type = "???";
            break;
    }
 
    return event_type;
}

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.

{
    /* see pgstat_report_wait_start() */
    *(volatile uint32 *) my_wait_event_info = 0;
}

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.

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

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.

{
    my_wait_event_info = &local_my_wait_event_info;
}

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.

{
    my_wait_event_info = wait_event_info;
}

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.

{
    uint16      eventId;
    bool        found;
    WaitEventExtensionEntryByName *entry_by_name;
    WaitEventExtensionEntryById *entry_by_id;
 
    /* Check the limit of the length of the event name */
    if (strlen(wait_event_name) >= NAMEDATALEN)
        elog(ERROR,
             "cannot use custom wait event string longer than %u characters",
             NAMEDATALEN - 1);
 
    /*
     * Check if the wait event info associated to the name is already defined,
     * and return it if so.
     */
    LWLockAcquire(WaitEventExtensionLock, LW_SHARED);
    entry_by_name = (WaitEventExtensionEntryByName *)
        hash_search(WaitEventExtensionHashByName, wait_event_name,
                    HASH_FIND, &found);
    LWLockRelease(WaitEventExtensionLock);
    if (found)
        return WAIT_EVENT_EXTENSION_INFO(entry_by_name->event_id);
 
    /*
     * Allocate and register a new wait event.  Recheck if the event name
     * exists, as it could be possible that a concurrent process has inserted
     * one with the same name since the LWLock acquired again here was
     * previously released.
     */
    LWLockAcquire(WaitEventExtensionLock, LW_EXCLUSIVE);
    entry_by_name = (WaitEventExtensionEntryByName *)
        hash_search(WaitEventExtensionHashByName, wait_event_name,
                    HASH_FIND, &found);
    if (found)
    {
        LWLockRelease(WaitEventExtensionLock);
        return WAIT_EVENT_EXTENSION_INFO(entry_by_name->event_id);
    }
 
    /* Allocate a new event Id */
    SpinLockAcquire(&WaitEventExtensionCounter->mutex);
 
    if (WaitEventExtensionCounter->nextId >= WAIT_EVENT_EXTENSION_HASH_MAX_SIZE)
    {
        SpinLockRelease(&WaitEventExtensionCounter->mutex);
        ereport(ERROR,
                errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                errmsg("too many wait events for extensions"));
    }
 
    eventId = WaitEventExtensionCounter->nextId++;
 
    SpinLockRelease(&WaitEventExtensionCounter->mutex);
 
    /* Register the new wait event */
    entry_by_id = (WaitEventExtensionEntryById *)
        hash_search(WaitEventExtensionHashById, &eventId,
                    HASH_ENTER, &found);
    Assert(!found);
    strlcpy(entry_by_id->wait_event_name, wait_event_name,
            sizeof(entry_by_id->wait_event_name));
 
    entry_by_name = (WaitEventExtensionEntryByName *)
        hash_search(WaitEventExtensionHashByName, wait_event_name,
                    HASH_ENTER, &found);
    Assert(!found);
    entry_by_name->event_id = eventId;
 
    LWLockRelease(WaitEventExtensionLock);
 
    return WAIT_EVENT_EXTENSION_INFO(eventId);
}

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.

{
    bool        found;
    HASHCTL     info;
 
    WaitEventExtensionCounter = (WaitEventExtensionCounterData *)
        ShmemInitStruct("WaitEventExtensionCounterData",
                        sizeof(WaitEventExtensionCounterData), &found);
 
    if (!found)
    {
        /* initialize the allocation counter and its spinlock. */
        WaitEventExtensionCounter->nextId = NUM_BUILTIN_WAIT_EVENT_EXTENSION;
        SpinLockInit(&WaitEventExtensionCounter->mutex);
    }
 
    /* initialize or attach the hash tables to store custom wait events */
    info.keysize = sizeof(uint16);
    info.entrysize = sizeof(WaitEventExtensionEntryById);
    WaitEventExtensionHashById = ShmemInitHash("WaitEventExtension hash by id",
                                               WAIT_EVENT_EXTENSION_HASH_INIT_SIZE,
                                               WAIT_EVENT_EXTENSION_HASH_MAX_SIZE,
                                               &info,
                                               HASH_ELEM | HASH_BLOBS);
 
    /* key is a NULL-terminated string */
    info.keysize = sizeof(char[NAMEDATALEN]);
    info.entrysize = sizeof(WaitEventExtensionEntryByName);
    WaitEventExtensionHashByName = ShmemInitHash("WaitEventExtension hash by name",
                                                 WAIT_EVENT_EXTENSION_HASH_INIT_SIZE,
                                                 WAIT_EVENT_EXTENSION_HASH_MAX_SIZE,
                                                 &info,
                                                 HASH_ELEM | HASH_STRINGS);
}

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.

{
    Size        sz;
 
    sz = MAXALIGN(sizeof(WaitEventExtensionCounterData));
    sz = add_size(sz, hash_estimate_size(WAIT_EVENT_EXTENSION_HASH_MAX_SIZE,
                                         sizeof(WaitEventExtensionEntryById)));
    sz = add_size(sz, hash_estimate_size(WAIT_EVENT_EXTENSION_HASH_MAX_SIZE,
                                         sizeof(WaitEventExtensionEntryByName)));
    return sz;
}

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

Referenced by CalculateShmemSize().

Variable Documentation

my_wait_event_info

PGDLLIMPORT uint32* my_wait_event_info

extern

Definition at line 43 of file wait_event.c.

Referenced by pgstat_report_wait_end(), pgstat_report_wait_start(), pgstat_reset_wait_event_storage(), and pgstat_set_wait_event_storage().