wait_event.c File Reference

#include "postgres.h"
#include "port/pg_bitutils.h"
#include "storage/lmgr.h"
#include "storage/lwlock.h"
#include "storage/spin.h"
#include "utils/wait_event.h"
#include "pgstat_wait_event.c"

Include dependency graph for wait_event.c:

Go to the source code of this file.

Data Structures
struct	WaitEventExtensionEntryById
struct	WaitEventExtensionEntryByName
struct	WaitEventExtensionCounterData

Macros
#define	WAIT_EVENT_CLASS_MASK   0xFF000000
#define	WAIT_EVENT_ID_MASK   0x0000FFFF
#define	WAIT_EVENT_EXTENSION_HASH_INIT_SIZE   16
#define	WAIT_EVENT_EXTENSION_HASH_MAX_SIZE   128
#define	NUM_BUILTIN_WAIT_EVENT_EXTENSION    (WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED - WAIT_EVENT_EXTENSION)
#define	WAIT_EVENT_EXTENSION_INFO(eventId)   (PG_WAIT_EXTENSION | eventId)

Typedefs
typedef struct WaitEventExtensionEntryById	WaitEventExtensionEntryById
typedef struct WaitEventExtensionEntryByName	WaitEventExtensionEntryByName
typedef struct WaitEventExtensionCounterData	WaitEventExtensionCounterData

Functions
static const char *	pgstat_get_wait_activity (WaitEventActivity w)
static const char *	pgstat_get_wait_bufferpin (WaitEventBufferPin w)
static const char *	pgstat_get_wait_client (WaitEventClient w)
static const char *	pgstat_get_wait_ipc (WaitEventIPC w)
static const char *	pgstat_get_wait_timeout (WaitEventTimeout w)
static const char *	pgstat_get_wait_io (WaitEventIO w)
static const char *	GetWaitEventExtensionIdentifier (uint16 eventId)
Size	WaitEventExtensionShmemSize (void)
void	WaitEventExtensionShmemInit (void)
uint32	WaitEventExtensionNew (const char *wait_event_name)
char **	GetWaitEventExtensionNames (int *nwaitevents)
void	pgstat_set_wait_event_storage (uint32 *wait_event_info)
void	pgstat_reset_wait_event_storage (void)
const char *	pgstat_get_wait_event_type (uint32 wait_event_info)
const char *	pgstat_get_wait_event (uint32 wait_event_info)

Variables
static uint32	local_my_wait_event_info
uint32 *	my_wait_event_info = &local_my_wait_event_info
static HTAB *	WaitEventExtensionHashById
static HTAB *	WaitEventExtensionHashByName
static WaitEventExtensionCounterData *	WaitEventExtensionCounter

Macro Definition Documentation

NUM_BUILTIN_WAIT_EVENT_EXTENSION

#define NUM_BUILTIN_WAIT_EVENT_EXTENSION    (WAIT_EVENT_EXTENSION_FIRST_USER_DEFINED - WAIT_EVENT_EXTENSION)

Definition at line 92 of file wait_event.c.

WAIT_EVENT_CLASS_MASK

#define WAIT_EVENT_CLASS_MASK   0xFF000000

Definition at line 43 of file wait_event.c.

WAIT_EVENT_EXTENSION_HASH_INIT_SIZE

#define WAIT_EVENT_EXTENSION_HASH_INIT_SIZE   16

Definition at line 64 of file wait_event.c.

WAIT_EVENT_EXTENSION_HASH_MAX_SIZE

#define WAIT_EVENT_EXTENSION_HASH_MAX_SIZE   128

Definition at line 65 of file wait_event.c.

WAIT_EVENT_EXTENSION_INFO

#define WAIT_EVENT_EXTENSION_INFO

(

eventId

)

(PG_WAIT_EXTENSION | eventId)

Definition at line 96 of file wait_event.c.

WAIT_EVENT_ID_MASK

#define WAIT_EVENT_ID_MASK   0x0000FFFF

Definition at line 44 of file wait_event.c.

Typedef Documentation

WaitEventExtensionCounterData

typedef struct WaitEventExtensionCounterData WaitEventExtensionCounterData

WaitEventExtensionEntryById

typedef struct WaitEventExtensionEntryById WaitEventExtensionEntryById

WaitEventExtensionEntryByName

typedef struct WaitEventExtensionEntryByName WaitEventExtensionEntryByName

Function Documentation

GetWaitEventExtensionIdentifier()

static const char * GetWaitEventExtensionIdentifier ( uint16  eventId )

static

Definition at line 241 of file wait_event.c.

{
    bool        found;
    WaitEventExtensionEntryById *entry;
 
    /* Built-in event? */
    if (eventId < NUM_BUILTIN_WAIT_EVENT_EXTENSION)
        return "Extension";
 
    /* It is a user-defined wait event, so lookup hash table. */
    LWLockAcquire(WaitEventExtensionLock, LW_SHARED);
    entry = (WaitEventExtensionEntryById *)
        hash_search(WaitEventExtensionHashById, &eventId,
                    HASH_FIND, &found);
    LWLockRelease(WaitEventExtensionLock);
 
    if (!entry)
        elog(ERROR, "could not find custom wait event name for ID %u",
             eventId);
 
    return entry->wait_event_name;
}

References elog, ERROR, HASH_FIND, hash_search(), LW_SHARED, LWLockAcquire(), LWLockRelease(), NUM_BUILTIN_WAIT_EVENT_EXTENSION, WaitEventExtensionEntryById::wait_event_name, and WaitEventExtensionHashById.

Referenced by pgstat_get_wait_event().

GetWaitEventExtensionNames()

char** GetWaitEventExtensionNames

(

int *

nwaitevents

)

Definition at line 271 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_activity()

static const char* pgstat_get_wait_activity ( WaitEventActivity  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_bufferpin()

static const char* pgstat_get_wait_bufferpin ( WaitEventBufferPin  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_client()

static const char* pgstat_get_wait_client ( WaitEventClient  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_event()

const char* pgstat_get_wait_event

(

uint32

wait_event_info

)

Definition at line 393 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 338 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_get_wait_io()

static const char* pgstat_get_wait_io ( WaitEventIO  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_ipc()

static const char* pgstat_get_wait_ipc ( WaitEventIPC  w )

static

Referenced by pgstat_get_wait_event().

pgstat_get_wait_timeout()

static const char* pgstat_get_wait_timeout ( WaitEventTimeout  w )

static

Referenced by pgstat_get_wait_event().

pgstat_reset_wait_event_storage()

void pgstat_reset_wait_event_storage

(

void

)

Definition at line 326 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 314 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 162 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(), dblink_init(), GetConnection(), injection_wait(), pgfdw_get_cleanup_result(), test_shm_mq_pipelined(), wait_for_workers_to_become_ready(), and worker_spi_main().

WaitEventExtensionShmemInit()

void WaitEventExtensionShmemInit

(

void

)

Definition at line 120 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 104 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

local_my_wait_event_info

uint32 local_my_wait_event_info

static

Definition at line 40 of file wait_event.c.

Referenced by pgstat_reset_wait_event_storage().

my_wait_event_info

uint32* my_wait_event_info = &local_my_wait_event_info

Definition at line 41 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().

WaitEventExtensionCounter

WaitEventExtensionCounterData* WaitEventExtensionCounter

static

Definition at line 89 of file wait_event.c.

Referenced by WaitEventExtensionNew(), and WaitEventExtensionShmemInit().

WaitEventExtensionHashById

HTAB* WaitEventExtensionHashById

static

Definition at line 61 of file wait_event.c.

Referenced by GetWaitEventExtensionIdentifier(), WaitEventExtensionNew(), and WaitEventExtensionShmemInit().

WaitEventExtensionHashByName

HTAB* WaitEventExtensionHashByName

static

Definition at line 62 of file wait_event.c.

Referenced by GetWaitEventExtensionNames(), WaitEventExtensionNew(), and WaitEventExtensionShmemInit().