pgstat_backend.c File Reference

#include "postgres.h"
#include "access/xlog.h"
#include "executor/instrument.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"
#include "storage/procarray.h"
#include "utils/memutils.h"
#include "utils/pgstat_internal.h"

Include dependency graph for pgstat_backend.c:

Go to the source code of this file.

Macros
#define	WALSTAT_ACC(fld, var_to_add)    (bktype_shstats->fld += var_to_add.fld)
#define	LOCKSTAT_ACC(fld)    (bktype_shstats->stats[i].fld += PendingBackendStats.pending_lock.stats[i].fld)

Functions
void	pgstat_count_backend_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time io_time)
void	pgstat_count_backend_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)
void	pgstat_count_backend_lock_waits (uint8 locktag_type, PgStat_Counter usecs)
void	pgstat_count_backend_lock_fastpath_exceeded (uint8 locktag_type)
PgStat_Backend *	pgstat_fetch_stat_backend (ProcNumber procNumber)
PgStat_Backend *	pgstat_fetch_stat_backend_by_pid (int pid, BackendType *bktype)
static void	pgstat_flush_backend_entry_io (PgStat_EntryRef *entry_ref)
static bool	pgstat_backend_wal_have_pending (void)
static void	pgstat_flush_backend_entry_wal (PgStat_EntryRef *entry_ref)
static void	pgstat_flush_backend_entry_lock (PgStat_EntryRef *entry_ref)
bool	pgstat_flush_backend (bool nowait, uint32 flags)
bool	pgstat_backend_flush_cb (bool nowait)
void	pgstat_create_backend (ProcNumber procnum)
bool	pgstat_tracks_backend_bktype (BackendType bktype)
void	pgstat_backend_reset_timestamp_cb (PgStatShared_Common *header, TimestampTz ts)

Variables
static PgStat_BackendPending	PendingBackendStats
static bool	backend_has_iostats = false
static bool	backend_has_lockstats = false
static WalUsage	prevBackendWalUsage

Macro Definition Documentation

LOCKSTAT_ACC

#define LOCKSTAT_ACC

(

fld

)

(bktype_shstats->stats[i].fld += PendingBackendStats.pending_lock.stats[i].fld)

WALSTAT_ACC

#define WALSTAT_ACC	(		fld,
			var_to_add
	)		(bktype_shstats->fld += var_to_add.fld)

Function Documentation

pgstat_backend_flush_cb()

bool pgstat_backend_flush_cb

(

bool

nowait

)

Definition at line 386 of file pgstat_backend.c.

{
    return pgstat_flush_backend(nowait, PGSTAT_BACKEND_FLUSH_ALL);
}

References PGSTAT_BACKEND_FLUSH_ALL, and pgstat_flush_backend().

pgstat_backend_reset_timestamp_cb()

void pgstat_backend_reset_timestamp_cb	(	PgStatShared_Common *	header,
		TimestampTz	ts
	)

Definition at line 476 of file pgstat_backend.c.

{
    ((PgStatShared_Backend *) header)->stats.stat_reset_timestamp = ts;
}

pgstat_backend_wal_have_pending()

static bool pgstat_backend_wal_have_pending ( void  )

inlinestatic

Definition at line 251 of file pgstat_backend.c.

{
    return (pgWalUsage.wal_records != prevBackendWalUsage.wal_records);
}

References pgWalUsage, prevBackendWalUsage, and WalUsage::wal_records.

Referenced by pgstat_flush_backend(), and pgstat_flush_backend_entry_wal().

pgstat_count_backend_io_op()

void pgstat_count_backend_io_op	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		uint32	cnt,
		uint64	bytes
	)

Definition at line 75 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingBackendStats.pending_io.counts[io_object][io_context][io_op] += cnt;
    PendingBackendStats.pending_io.bytes[io_object][io_context][io_op] += bytes;
 
    backend_has_iostats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_iostats, PgStat_PendingIO::bytes, PgStat_PendingIO::counts, fb(), MyBackendType, PgStat_BackendPending::pending_io, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), and pgstat_tracks_io_op().

Referenced by pgstat_count_io_op().

pgstat_count_backend_io_op_time()

void pgstat_count_backend_io_op_time	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		instr_time	io_time
	)

Definition at line 57 of file pgstat_backend.c.

{
    Assert(track_io_timing || track_wal_io_timing);
 
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    INSTR_TIME_ADD(PendingBackendStats.pending_io.pending_times[io_object][io_context][io_op],
                   io_time);
 
    backend_has_iostats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_iostats, fb(), INSTR_TIME_ADD, MyBackendType, PgStat_BackendPending::pending_io, PgStat_PendingIO::pending_times, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), pgstat_tracks_io_op(), track_io_timing, and track_wal_io_timing.

Referenced by pgstat_count_io_op_time().

pgstat_count_backend_lock_fastpath_exceeded()

void pgstat_count_backend_lock_fastpath_exceeded

(

uint8

locktag_type

)

Definition at line 110 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(locktag_type <= LOCKTAG_LAST_TYPE);
 
    PendingBackendStats.pending_lock.stats[locktag_type].fastpath_exceeded++;
 
    backend_has_lockstats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_lockstats, PgStat_LockEntry::fastpath_exceeded, LOCKTAG_LAST_TYPE, MyBackendType, PgStat_BackendPending::pending_lock, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), and PgStat_PendingLock::stats.

Referenced by pgstat_count_lock_fastpath_exceeded().

pgstat_count_backend_lock_waits()

void pgstat_count_backend_lock_waits	(	uint8	locktag_type,
		PgStat_Counter	usecs
	)

Definition at line 95 of file pgstat_backend.c.

{
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return;
 
    Assert(locktag_type <= LOCKTAG_LAST_TYPE);
 
    PendingBackendStats.pending_lock.stats[locktag_type].waits++;
    PendingBackendStats.pending_lock.stats[locktag_type].wait_time += usecs;
 
    backend_has_lockstats = true;
    pgstat_report_fixed = true;
}

References Assert, backend_has_lockstats, fb(), LOCKTAG_LAST_TYPE, MyBackendType, PgStat_BackendPending::pending_lock, PendingBackendStats, pgstat_report_fixed, pgstat_tracks_backend_bktype(), PgStat_PendingLock::stats, PgStat_LockEntry::wait_time, and PgStat_LockEntry::waits.

Referenced by pgstat_count_lock_waits().

pgstat_create_backend()

void pgstat_create_backend

(

ProcNumber

procnum

)

Definition at line 395 of file pgstat_backend.c.

{
    PgStat_EntryRef *entry_ref;
    PgStatShared_Backend *shstatent;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
                                            procnum, false);
    shstatent = (PgStatShared_Backend *) entry_ref->shared_stats;
 
    /*
     * NB: need to accept that there might be stats from an older backend,
     * e.g. if we previously used this proc number.
     */
    memset(&shstatent->stats, 0, sizeof(shstatent->stats));
    pgstat_unlock_entry(entry_ref);
 
    MemSet(&PendingBackendStats, 0, sizeof(PgStat_BackendPending));
    backend_has_iostats = false;
    backend_has_lockstats = false;
 
    /*
     * Initialize prevBackendWalUsage with pgWalUsage so that
     * pgstat_backend_flush_cb() can calculate how much pgWalUsage counters
     * are increased by subtracting prevBackendWalUsage from pgWalUsage.
     */
    prevBackendWalUsage = pgWalUsage;
}

References backend_has_iostats, backend_has_lockstats, fb(), InvalidOid, MemSet, PendingBackendStats, pgstat_get_entry_ref_locked(), PGSTAT_KIND_BACKEND, pgstat_unlock_entry(), pgWalUsage, prevBackendWalUsage, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_bestart_final().

pgstat_fetch_stat_backend()

PgStat_Backend * pgstat_fetch_stat_backend

(

ProcNumber

procNumber

)

Definition at line 127 of file pgstat_backend.c.

{
    PgStat_Backend *backend_entry;
 
    backend_entry = (PgStat_Backend *) pgstat_fetch_entry(PGSTAT_KIND_BACKEND,
                                                          InvalidOid, procNumber,
                                                          NULL);
 
    return backend_entry;
}

References fb(), InvalidOid, pgstat_fetch_entry(), and PGSTAT_KIND_BACKEND.

Referenced by pgstat_fetch_stat_backend_by_pid().

pgstat_fetch_stat_backend_by_pid()

PgStat_Backend * pgstat_fetch_stat_backend_by_pid	(	int	pid,
		BackendType *	bktype
	)

Definition at line 146 of file pgstat_backend.c.

{
    PGPROC     *proc;
    PgBackendStatus *beentry;
    ProcNumber  procNumber;
    PgStat_Backend *backend_stats;
 
    proc = BackendPidGetProc(pid);
    if (bktype)
        *bktype = B_INVALID;
 
    /* this could be an auxiliary process */
    if (!proc)
        proc = AuxiliaryPidGetProc(pid);
 
    if (!proc)
        return NULL;
 
    procNumber = GetNumberFromPGProc(proc);
 
    beentry = pgstat_get_beentry_by_proc_number(procNumber);
    if (!beentry)
        return NULL;
 
    /* check if the backend type tracks statistics */
    if (!pgstat_tracks_backend_bktype(beentry->st_backendType))
        return NULL;
 
    /* if PID does not match, leave */
    if (beentry->st_procpid != pid)
        return NULL;
 
    if (bktype)
        *bktype = beentry->st_backendType;
 
    /*
     * Retrieve the entry.  Note that "beentry" may be freed depending on the
     * value of stats_fetch_consistency, so do not access it from this point.
     */
    backend_stats = pgstat_fetch_stat_backend(procNumber);
    if (!backend_stats)
    {
        if (bktype)
            *bktype = B_INVALID;
        return NULL;
    }
 
    return backend_stats;
}

References AuxiliaryPidGetProc(), B_INVALID, BackendPidGetProc(), fb(), GetNumberFromPGProc, pgstat_fetch_stat_backend(), pgstat_get_beentry_by_proc_number(), and pgstat_tracks_backend_bktype().

Referenced by pg_stat_get_backend_io(), pg_stat_get_backend_lock(), and pg_stat_get_backend_wal().

pgstat_flush_backend()

bool pgstat_flush_backend	(	bool	nowait,
		uint32	flags
	)

Definition at line 336 of file pgstat_backend.c.

{
    PgStat_EntryRef *entry_ref;
    bool        has_pending_data = false;
 
    if (!pgstat_tracks_backend_bktype(MyBackendType))
        return false;
 
    /* Some IO data pending? */
    if ((flags & PGSTAT_BACKEND_FLUSH_IO) && backend_has_iostats)
        has_pending_data = true;
 
    /* Some WAL data pending? */
    if ((flags & PGSTAT_BACKEND_FLUSH_WAL) &&
        pgstat_backend_wal_have_pending())
        has_pending_data = true;
 
    /* Some lock data pending? */
    if ((flags & PGSTAT_BACKEND_FLUSH_LOCK) && backend_has_lockstats)
        has_pending_data = true;
 
    if (!has_pending_data)
        return false;
 
    entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_BACKEND, InvalidOid,
                                            MyProcNumber, nowait);
    if (!entry_ref)
        return true;
 
    /* Flush requested statistics */
    if (flags & PGSTAT_BACKEND_FLUSH_IO)
        pgstat_flush_backend_entry_io(entry_ref);
 
    if (flags & PGSTAT_BACKEND_FLUSH_WAL)
        pgstat_flush_backend_entry_wal(entry_ref);
 
    if (flags & PGSTAT_BACKEND_FLUSH_LOCK)
        pgstat_flush_backend_entry_lock(entry_ref);
 
    pgstat_unlock_entry(entry_ref);
 
    return false;
}

References backend_has_iostats, backend_has_lockstats, fb(), InvalidOid, MyBackendType, MyProcNumber, PGSTAT_BACKEND_FLUSH_IO, PGSTAT_BACKEND_FLUSH_LOCK, PGSTAT_BACKEND_FLUSH_WAL, pgstat_backend_wal_have_pending(), pgstat_flush_backend_entry_io(), pgstat_flush_backend_entry_lock(), pgstat_flush_backend_entry_wal(), pgstat_get_entry_ref_locked(), PGSTAT_KIND_BACKEND, pgstat_tracks_backend_bktype(), and pgstat_unlock_entry().

Referenced by pgstat_backend_flush_cb(), pgstat_report_analyze(), pgstat_report_vacuum(), pgstat_report_wal(), WalSndLoop(), and WalSndWaitForWal().

pgstat_flush_backend_entry_io()

static void pgstat_flush_backend_entry_io ( PgStat_EntryRef *  entry_ref )

static

Definition at line 201 of file pgstat_backend.c.

{
    PgStatShared_Backend *shbackendent;
    PgStat_BktypeIO *bktype_shstats;
    PgStat_PendingIO pending_io;
 
    /*
     * This function can be called even if nothing at all has happened for IO
     * statistics.  In this case, avoid unnecessarily modifying the stats
     * entry.
     */
    if (!backend_has_iostats)
        return;
 
    shbackendent = (PgStatShared_Backend *) entry_ref->shared_stats;
    bktype_shstats = &shbackendent->stats.io_stats;
    pending_io = PendingBackendStats.pending_io;
 
    for (int io_object = 0; io_object < IOOBJECT_NUM_TYPES; io_object++)
    {
        for (int io_context = 0; io_context < IOCONTEXT_NUM_TYPES; io_context++)
        {
            for (int io_op = 0; io_op < IOOP_NUM_TYPES; io_op++)
            {
                instr_time  time;
 
                bktype_shstats->counts[io_object][io_context][io_op] +=
                    pending_io.counts[io_object][io_context][io_op];
                bktype_shstats->bytes[io_object][io_context][io_op] +=
                    pending_io.bytes[io_object][io_context][io_op];
                time = pending_io.pending_times[io_object][io_context][io_op];
 
                bktype_shstats->times[io_object][io_context][io_op] +=
                    INSTR_TIME_GET_MICROSEC(time);
            }
        }
    }
 
    /*
     * Clear out the statistics buffer, so it can be re-used.
     */
    MemSet(&PendingBackendStats.pending_io, 0, sizeof(PgStat_PendingIO));
 
    backend_has_iostats = false;
}

References backend_has_iostats, PgStat_PendingIO::bytes, PgStat_PendingIO::counts, fb(), INSTR_TIME_GET_MICROSEC, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, MemSet, PgStat_BackendPending::pending_io, PgStat_PendingIO::pending_times, PendingBackendStats, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_flush_backend().

pgstat_flush_backend_entry_lock()

static void pgstat_flush_backend_entry_lock ( PgStat_EntryRef *  entry_ref )

static

Definition at line 304 of file pgstat_backend.c.

{
    PgStatShared_Backend *shbackendent;
    PgStat_PendingLock *bktype_shstats;
 
    if (!backend_has_lockstats)
        return;
 
    shbackendent = (PgStatShared_Backend *) entry_ref->shared_stats;
    bktype_shstats = &shbackendent->stats.lock_stats;
 
    for (int i = 0; i <= LOCKTAG_LAST_TYPE; i++)
    {
#define LOCKSTAT_ACC(fld) \
    (bktype_shstats->stats[i].fld += PendingBackendStats.pending_lock.stats[i].fld)
        LOCKSTAT_ACC(waits);
        LOCKSTAT_ACC(wait_time);
        LOCKSTAT_ACC(fastpath_exceeded);
#undef LOCKSTAT_ACC
    }
 
    MemSet(&PendingBackendStats.pending_lock, 0, sizeof(PgStat_PendingLock));
    backend_has_lockstats = false;
}

References backend_has_lockstats, fb(), i, LOCKSTAT_ACC, LOCKTAG_LAST_TYPE, MemSet, PgStat_BackendPending::pending_lock, PendingBackendStats, and PgStat_EntryRef::shared_stats.

Referenced by pgstat_flush_backend().

pgstat_flush_backend_entry_wal()

static void pgstat_flush_backend_entry_wal ( PgStat_EntryRef *  entry_ref )

static

Definition at line 261 of file pgstat_backend.c.

{
    PgStatShared_Backend *shbackendent;
    PgStat_WalCounters *bktype_shstats;
    WalUsage    wal_usage_diff = {0};
 
    /*
     * This function can be called even if nothing at all has happened for WAL
     * statistics.  In this case, avoid unnecessarily modifying the stats
     * entry.
     */
    if (!pgstat_backend_wal_have_pending())
        return;
 
    shbackendent = (PgStatShared_Backend *) entry_ref->shared_stats;
    bktype_shstats = &shbackendent->stats.wal_counters;
 
    /*
     * Calculate how much WAL usage counters were increased by subtracting the
     * previous counters from the current ones.
     */
    WalUsageAccumDiff(&wal_usage_diff, &pgWalUsage, &prevBackendWalUsage);
 
#define WALSTAT_ACC(fld, var_to_add) \
    (bktype_shstats->fld += var_to_add.fld)
    WALSTAT_ACC(wal_buffers_full, wal_usage_diff);
    WALSTAT_ACC(wal_records, wal_usage_diff);
    WALSTAT_ACC(wal_fpi, wal_usage_diff);
    WALSTAT_ACC(wal_bytes, wal_usage_diff);
    WALSTAT_ACC(wal_fpi_bytes, wal_usage_diff);
#undef WALSTAT_ACC
 
    /*
     * Save the current counters for the subsequent calculation of WAL usage.
     */
    prevBackendWalUsage = pgWalUsage;
}

References fb(), pgstat_backend_wal_have_pending(), pgWalUsage, prevBackendWalUsage, PgStat_EntryRef::shared_stats, WALSTAT_ACC, and WalUsageAccumDiff().

Referenced by pgstat_flush_backend().

pgstat_tracks_backend_bktype()

bool pgstat_tracks_backend_bktype

(

BackendType

bktype

)

Definition at line 439 of file pgstat_backend.c.

{
    /*
     * List every type so that new backend types trigger a warning about
     * needing to adjust this switch.
     */
    switch (bktype)
    {
        case B_INVALID:
        case B_AUTOVAC_LAUNCHER:
        case B_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_STARTUP:
        case B_DATACHECKSUMSWORKER_LAUNCHER:
        case B_DATACHECKSUMSWORKER_WORKER:
            return false;
 
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_STANDALONE_BACKEND:
        case B_SLOTSYNC_WORKER:
        case B_WAL_RECEIVER:
        case B_WAL_SENDER:
        case B_WAL_SUMMARIZER:
        case B_WAL_WRITER:
            return true;
    }
 
    return false;
}

References B_ARCHIVER, B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BACKEND, B_BG_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_DATACHECKSUMSWORKER_LAUNCHER, B_DATACHECKSUMSWORKER_WORKER, B_DEAD_END_BACKEND, B_INVALID, B_IO_WORKER, B_LOGGER, B_SLOTSYNC_WORKER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SENDER, B_WAL_SUMMARIZER, B_WAL_WRITER, and fb().

Referenced by pg_stat_reset_backend_stats(), pgstat_bestart_final(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_count_backend_lock_fastpath_exceeded(), pgstat_count_backend_lock_waits(), pgstat_fetch_stat_backend_by_pid(), and pgstat_flush_backend().

Variable Documentation

backend_has_iostats

bool backend_has_iostats = false

static

Definition at line 41 of file pgstat_backend.c.

Referenced by pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_create_backend(), pgstat_flush_backend(), and pgstat_flush_backend_entry_io().

backend_has_lockstats

bool backend_has_lockstats = false

static

Definition at line 42 of file pgstat_backend.c.

Referenced by pgstat_count_backend_lock_fastpath_exceeded(), pgstat_count_backend_lock_waits(), pgstat_create_backend(), pgstat_flush_backend(), and pgstat_flush_backend_entry_lock().

PendingBackendStats

PgStat_BackendPending PendingBackendStats

static

Definition at line 40 of file pgstat_backend.c.

Referenced by pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), pgstat_count_backend_lock_fastpath_exceeded(), pgstat_count_backend_lock_waits(), pgstat_create_backend(), pgstat_flush_backend_entry_io(), and pgstat_flush_backend_entry_lock().

prevBackendWalUsage

WalUsage prevBackendWalUsage

static

Definition at line 50 of file pgstat_backend.c.

Referenced by pgstat_backend_wal_have_pending(), pgstat_create_backend(), and pgstat_flush_backend_entry_wal().