pgstat_io.c File Reference

#include "postgres.h"
#include "executor/instrument.h"
#include "storage/bufmgr.h"
#include "utils/pgstat_internal.h"

Include dependency graph for pgstat_io.c:

Go to the source code of this file.

Functions
bool	pgstat_bktype_io_stats_valid (PgStat_BktypeIO *backend_io, BackendType bktype)
void	pgstat_count_io_op (IOObject io_object, IOContext io_context, IOOp io_op, uint32 cnt, uint64 bytes)
instr_time	pgstat_prepare_io_time (bool track_io_guc)
void	pgstat_count_io_op_time (IOObject io_object, IOContext io_context, IOOp io_op, instr_time start_time, uint32 cnt, uint64 bytes)
PgStat_IO *	pgstat_fetch_stat_io (void)
bool	pgstat_io_have_pending_cb (void)
void	pgstat_flush_io (bool nowait)
bool	pgstat_io_flush_cb (bool nowait)
const char *	pgstat_get_io_context_name (IOContext io_context)
const char *	pgstat_get_io_object_name (IOObject io_object)
void	pgstat_io_init_shmem_cb (void *stats)
void	pgstat_io_reset_all_cb (TimestampTz ts)
void	pgstat_io_snapshot_cb (void)
bool	pgstat_tracks_io_bktype (BackendType bktype)
bool	pgstat_tracks_io_object (BackendType bktype, IOObject io_object, IOContext io_context)
bool	pgstat_tracks_io_op (BackendType bktype, IOObject io_object, IOContext io_context, IOOp io_op)

Variables
static PgStat_PendingIO	PendingIOStats
static bool	have_iostats = false

Function Documentation

pgstat_bktype_io_stats_valid()

bool pgstat_bktype_io_stats_valid	(	PgStat_BktypeIO *	backend_io,
		BackendType	bktype
	)

Definition at line 37 of file pgstat_io.c.

{
    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++)
            {
                /* we do track it */
                if (pgstat_tracks_io_op(bktype, io_object, io_context, io_op))
                {
                    /* ensure that if IO times are non-zero, counts are > 0 */
                    if (backend_io->times[io_object][io_context][io_op] != 0 &&
                        backend_io->counts[io_object][io_context][io_op] <= 0)
                        return false;
 
                    continue;
                }
 
                /* we don't track it, and it is not 0 */
                if (backend_io->counts[io_object][io_context][io_op] != 0)
                    return false;
            }
        }
    }
 
    return true;
}

References PgStat_BktypeIO::counts, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, pgstat_tracks_io_op(), and PgStat_BktypeIO::times.

Referenced by pg_stat_get_backend_io(), pg_stat_get_io(), and pgstat_io_flush_cb().

pgstat_count_io_op()

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

Definition at line 68 of file pgstat_io.c.

{
    Assert((unsigned int) io_object < IOOBJECT_NUM_TYPES);
    Assert((unsigned int) io_context < IOCONTEXT_NUM_TYPES);
    Assert(pgstat_is_ioop_tracked_in_bytes(io_op) || bytes == 0);
    Assert(pgstat_tracks_io_op(MyBackendType, io_object, io_context, io_op));
 
    PendingIOStats.counts[io_object][io_context][io_op] += cnt;
    PendingIOStats.bytes[io_object][io_context][io_op] += bytes;
 
    /* Add the per-backend counts */
    pgstat_count_backend_io_op(io_object, io_context, io_op, cnt, bytes);
 
    have_iostats = true;
}

References Assert(), PgStat_PendingIO::bytes, PgStat_PendingIO::counts, have_iostats, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, MyBackendType, PendingIOStats, pgstat_count_backend_io_op(), pgstat_is_ioop_tracked_in_bytes, and pgstat_tracks_io_op().

Referenced by GetLocalVictimBuffer(), GetVictimBuffer(), pgstat_count_io_op_time(), PinBufferForBlock(), and WaitReadBuffers().

pgstat_count_io_op_time()

void pgstat_count_io_op_time	(	IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op,
		instr_time	start_time,
		uint32	cnt,
		uint64	bytes
	)

Definition at line 121 of file pgstat_io.c.

{
    if (!INSTR_TIME_IS_ZERO(start_time))
    {
        instr_time  io_time;
 
        INSTR_TIME_SET_CURRENT(io_time);
        INSTR_TIME_SUBTRACT(io_time, start_time);
 
        if (io_object != IOOBJECT_WAL)
        {
            if (io_op == IOOP_WRITE || io_op == IOOP_EXTEND)
            {
                pgstat_count_buffer_write_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_write_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_write_time, io_time);
            }
            else if (io_op == IOOP_READ)
            {
                pgstat_count_buffer_read_time(INSTR_TIME_GET_MICROSEC(io_time));
                if (io_object == IOOBJECT_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.shared_blk_read_time, io_time);
                else if (io_object == IOOBJECT_TEMP_RELATION)
                    INSTR_TIME_ADD(pgBufferUsage.local_blk_read_time, io_time);
            }
        }
 
        INSTR_TIME_ADD(PendingIOStats.pending_times[io_object][io_context][io_op],
                       io_time);
 
        /* Add the per-backend count */
        pgstat_count_backend_io_op_time(io_object, io_context, io_op,
                                        io_time);
    }
 
    pgstat_count_io_op(io_object, io_context, io_op, cnt, bytes);
}

References INSTR_TIME_ADD, INSTR_TIME_GET_MICROSEC, INSTR_TIME_IS_ZERO, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EXTEND, IOOP_READ, IOOP_WRITE, BufferUsage::local_blk_read_time, BufferUsage::local_blk_write_time, PgStat_PendingIO::pending_times, PendingIOStats, pgBufferUsage, pgstat_count_backend_io_op_time(), pgstat_count_buffer_read_time, pgstat_count_buffer_write_time, pgstat_count_io_op(), BufferUsage::shared_blk_read_time, BufferUsage::shared_blk_write_time, and start_time.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

pgstat_fetch_stat_io()

PgStat_IO * pgstat_fetch_stat_io

(

void

)

Definition at line 163 of file pgstat_io.c.

{
    pgstat_snapshot_fixed(PGSTAT_KIND_IO);
 
    return &pgStatLocal.snapshot.io;
}

References PgStat_Snapshot::io, PGSTAT_KIND_IO, pgstat_snapshot_fixed(), pgStatLocal, and PgStat_LocalState::snapshot.

Referenced by pg_stat_get_io().

pgstat_flush_io()

void pgstat_flush_io

(

bool

nowait

)

Definition at line 183 of file pgstat_io.c.

{
    (void) pgstat_io_flush_cb(nowait);
}

References pgstat_io_flush_cb().

Referenced by pgstat_report_analyze(), pgstat_report_bgwriter(), pgstat_report_checkpointer(), pgstat_report_vacuum(), and pgstat_report_wal().

pgstat_get_io_context_name()

const char * pgstat_get_io_context_name

(

IOContext

io_context

)

Definition at line 248 of file pgstat_io.c.

{
    switch (io_context)
    {
        case IOCONTEXT_BULKREAD:
            return "bulkread";
        case IOCONTEXT_BULKWRITE:
            return "bulkwrite";
        case IOCONTEXT_INIT:
            return "init";
        case IOCONTEXT_NORMAL:
            return "normal";
        case IOCONTEXT_VACUUM:
            return "vacuum";
    }
 
    elog(ERROR, "unrecognized IOContext value: %d", io_context);
    pg_unreachable();
}

References elog, ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

pgstat_get_io_object_name()

const char * pgstat_get_io_object_name

(

IOObject

io_object

)

Definition at line 269 of file pgstat_io.c.

{
    switch (io_object)
    {
        case IOOBJECT_RELATION:
            return "relation";
        case IOOBJECT_TEMP_RELATION:
            return "temp relation";
        case IOOBJECT_WAL:
            return "wal";
    }
 
    elog(ERROR, "unrecognized IOObject value: %d", io_object);
    pg_unreachable();
}

References elog, ERROR, IOOBJECT_RELATION, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, and pg_unreachable.

Referenced by pg_stat_io_build_tuples().

pgstat_io_flush_cb()

bool pgstat_io_flush_cb

(

bool

nowait

)

Definition at line 197 of file pgstat_io.c.

{
    LWLock     *bktype_lock;
    PgStat_BktypeIO *bktype_shstats;
 
    if (!have_iostats)
        return false;
 
    bktype_lock = &pgStatLocal.shmem->io.locks[MyBackendType];
    bktype_shstats =
        &pgStatLocal.shmem->io.stats.stats[MyBackendType];
 
    if (!nowait)
        LWLockAcquire(bktype_lock, LW_EXCLUSIVE);
    else if (!LWLockConditionalAcquire(bktype_lock, LW_EXCLUSIVE))
        return true;
 
    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] +=
                    PendingIOStats.counts[io_object][io_context][io_op];
 
                bktype_shstats->bytes[io_object][io_context][io_op] +=
                    PendingIOStats.bytes[io_object][io_context][io_op];
 
                time = PendingIOStats.pending_times[io_object][io_context][io_op];
 
                bktype_shstats->times[io_object][io_context][io_op] +=
                    INSTR_TIME_GET_MICROSEC(time);
            }
        }
    }
 
    Assert(pgstat_bktype_io_stats_valid(bktype_shstats, MyBackendType));
 
    LWLockRelease(bktype_lock);
 
    memset(&PendingIOStats, 0, sizeof(PendingIOStats));
 
    have_iostats = false;
 
    return false;
}

References Assert(), PgStat_BktypeIO::bytes, PgStat_PendingIO::bytes, PgStat_BktypeIO::counts, PgStat_PendingIO::counts, have_iostats, INSTR_TIME_GET_MICROSEC, PgStat_ShmemControl::io, IOCONTEXT_NUM_TYPES, IOOBJECT_NUM_TYPES, IOOP_NUM_TYPES, PgStatShared_IO::locks, LW_EXCLUSIVE, LWLockAcquire(), LWLockConditionalAcquire(), LWLockRelease(), MyBackendType, PgStat_PendingIO::pending_times, PendingIOStats, pgstat_bktype_io_stats_valid(), pgStatLocal, PgStat_LocalState::shmem, PgStat_IO::stats, PgStatShared_IO::stats, and PgStat_BktypeIO::times.

Referenced by pgstat_flush_io().

pgstat_io_have_pending_cb()

bool pgstat_io_have_pending_cb

(

void

)

Definition at line 174 of file pgstat_io.c.

{
    return have_iostats;
}

References have_iostats.

pgstat_io_init_shmem_cb()

void pgstat_io_init_shmem_cb

(

void *

stats

)

Definition at line 286 of file pgstat_io.c.

{
    PgStatShared_IO *stat_shmem = (PgStatShared_IO *) stats;
 
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
        LWLockInitialize(&stat_shmem->locks[i], LWTRANCHE_PGSTATS_DATA);
}

References BACKEND_NUM_TYPES, i, PgStatShared_IO::locks, LWLockInitialize(), and LWTRANCHE_PGSTATS_DATA.

pgstat_io_reset_all_cb()

void pgstat_io_reset_all_cb

(

TimestampTz

ts

)

Definition at line 295 of file pgstat_io.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        LWLock     *bktype_lock = &pgStatLocal.shmem->io.locks[i];
        PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i];
 
        LWLockAcquire(bktype_lock, LW_EXCLUSIVE);
 
        /*
         * Use the lock in the first BackendType's PgStat_BktypeIO to protect
         * the reset timestamp as well.
         */
        if (i == 0)
            pgStatLocal.shmem->io.stats.stat_reset_timestamp = ts;
 
        memset(bktype_shstats, 0, sizeof(*bktype_shstats));
        LWLockRelease(bktype_lock);
    }
}

References BACKEND_NUM_TYPES, i, PgStat_ShmemControl::io, PgStatShared_IO::locks, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_IO::stat_reset_timestamp, PgStat_IO::stats, and PgStatShared_IO::stats.

pgstat_io_snapshot_cb()

void pgstat_io_snapshot_cb

(

void

)

Definition at line 317 of file pgstat_io.c.

{
    for (int i = 0; i < BACKEND_NUM_TYPES; i++)
    {
        LWLock     *bktype_lock = &pgStatLocal.shmem->io.locks[i];
        PgStat_BktypeIO *bktype_shstats = &pgStatLocal.shmem->io.stats.stats[i];
        PgStat_BktypeIO *bktype_snap = &pgStatLocal.snapshot.io.stats[i];
 
        LWLockAcquire(bktype_lock, LW_SHARED);
 
        /*
         * Use the lock in the first BackendType's PgStat_BktypeIO to protect
         * the reset timestamp as well.
         */
        if (i == 0)
            pgStatLocal.snapshot.io.stat_reset_timestamp =
                pgStatLocal.shmem->io.stats.stat_reset_timestamp;
 
        /* using struct assignment due to better type safety */
        *bktype_snap = *bktype_shstats;
        LWLockRelease(bktype_lock);
    }
}

References BACKEND_NUM_TYPES, i, PgStat_ShmemControl::io, PgStat_Snapshot::io, PgStatShared_IO::locks, LW_SHARED, LWLockAcquire(), LWLockRelease(), pgStatLocal, PgStat_LocalState::shmem, PgStat_LocalState::snapshot, PgStat_IO::stat_reset_timestamp, PgStat_IO::stats, and PgStatShared_IO::stats.

pgstat_prepare_io_time()

instr_time pgstat_prepare_io_time

(

bool

track_io_guc

)

Definition at line 90 of file pgstat_io.c.

{
    instr_time  io_start;
 
    if (track_io_guc)
        INSTR_TIME_SET_CURRENT(io_start);
    else
    {
        /*
         * There is no need to set io_start when an IO timing GUC is disabled.
         * Initialize it to zero to avoid compiler warnings and to let
         * pgstat_count_io_op_time() know that timings should be ignored.
         */
        INSTR_TIME_SET_ZERO(io_start);
    }
 
    return io_start;
}

References INSTR_TIME_SET_CURRENT, and INSTR_TIME_SET_ZERO.

Referenced by ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FlushBuffer(), FlushLocalBuffer(), issue_xlog_fsync(), IssuePendingWritebacks(), mdsyncfiletag(), register_dirty_segment(), WaitReadBuffers(), WALRead(), XLogFileInitInternal(), XLogPageRead(), XLogWalRcvWrite(), and XLogWrite().

pgstat_tracks_io_bktype()

bool pgstat_tracks_io_bktype

(

BackendType

bktype

)

Definition at line 359 of file pgstat_io.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_DEAD_END_BACKEND:
        case B_ARCHIVER:
        case B_LOGGER:
            return false;
 
        case B_AUTOVAC_LAUNCHER:
        case B_AUTOVAC_WORKER:
        case B_BACKEND:
        case B_BG_WORKER:
        case B_BG_WRITER:
        case B_CHECKPOINTER:
        case B_IO_WORKER:
        case B_SLOTSYNC_WORKER:
        case B_STANDALONE_BACKEND:
        case B_STARTUP:
        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_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, and B_WAL_WRITER.

Referenced by pg_stat_get_io(), and pgstat_tracks_io_object().

pgstat_tracks_io_object()

bool pgstat_tracks_io_object	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context
	)

Definition at line 401 of file pgstat_io.c.

{
    bool        no_temp_rel;
 
    /*
     * Some BackendTypes should never track IO statistics.
     */
    if (!pgstat_tracks_io_bktype(bktype))
        return false;
 
    /*
     * Currently, IO on IOOBJECT_WAL objects can only occur in the
     * IOCONTEXT_NORMAL and IOCONTEXT_INIT IOContexts.
     */
    if (io_object == IOOBJECT_WAL &&
        (io_context != IOCONTEXT_NORMAL &&
         io_context != IOCONTEXT_INIT))
        return false;
 
    /*
     * Currently, IO on temporary relations can only occur in the
     * IOCONTEXT_NORMAL IOContext.
     */
    if (io_context != IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * In core Postgres, only regular backends and WAL Sender processes
     * executing queries will use local buffers and operate on temporary
     * relations. Parallel workers will not use local buffers (see
     * InitLocalBuffers()); however, extensions leveraging background workers
     * have no such limitation, so track IO on IOOBJECT_TEMP_RELATION for
     * BackendType B_BG_WORKER.
     */
    no_temp_rel = bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
        bktype == B_CHECKPOINTER || bktype == B_AUTOVAC_WORKER ||
        bktype == B_STANDALONE_BACKEND || bktype == B_STARTUP ||
        bktype == B_WAL_SUMMARIZER || bktype == B_WAL_WRITER ||
        bktype == B_WAL_RECEIVER;
 
    if (no_temp_rel && io_context == IOCONTEXT_NORMAL &&
        io_object == IOOBJECT_TEMP_RELATION)
        return false;
 
    /*
     * Some BackendTypes only perform IO under IOOBJECT_WAL, hence exclude all
     * rows for all the other objects for these.
     */
    if ((bktype == B_WAL_SUMMARIZER || bktype == B_WAL_RECEIVER ||
         bktype == B_WAL_WRITER) && io_object != IOOBJECT_WAL)
        return false;
 
    /*
     * Some BackendTypes do not currently perform any IO in certain
     * IOContexts, and, while it may not be inherently incorrect for them to
     * do so, excluding those rows from the view makes the view easier to use.
     */
    if ((bktype == B_CHECKPOINTER || bktype == B_BG_WRITER) &&
        (io_context == IOCONTEXT_BULKREAD ||
         io_context == IOCONTEXT_BULKWRITE ||
         io_context == IOCONTEXT_VACUUM))
        return false;
 
    if (bktype == B_AUTOVAC_LAUNCHER && io_context == IOCONTEXT_VACUUM)
        return false;
 
    if ((bktype == B_AUTOVAC_WORKER || bktype == B_AUTOVAC_LAUNCHER) &&
        io_context == IOCONTEXT_BULKWRITE)
        return false;
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_STANDALONE_BACKEND, B_STARTUP, B_WAL_RECEIVER, B_WAL_SUMMARIZER, B_WAL_WRITER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, and pgstat_tracks_io_bktype().

Referenced by pg_stat_io_build_tuples(), and pgstat_tracks_io_op().

pgstat_tracks_io_op()

bool pgstat_tracks_io_op	(	BackendType	bktype,
		IOObject	io_object,
		IOContext	io_context,
		IOOp	io_op
	)

Definition at line 485 of file pgstat_io.c.

{
    bool        strategy_io_context;
 
    /* if (io_context, io_object) will never collect stats, we're done */
    if (!pgstat_tracks_io_object(bktype, io_object, io_context))
        return false;
 
    /*
     * Some BackendTypes will not do certain IOOps.
     */
    if (bktype == B_BG_WRITER &&
        (io_op == IOOP_READ || io_op == IOOP_EVICT || io_op == IOOP_HIT))
        return false;
 
    if (bktype == B_CHECKPOINTER &&
        ((io_object != IOOBJECT_WAL && io_op == IOOP_READ) ||
         (io_op == IOOP_EVICT || io_op == IOOP_HIT)))
        return false;
 
    if ((bktype == B_AUTOVAC_LAUNCHER || bktype == B_BG_WRITER ||
         bktype == B_CHECKPOINTER) && io_op == IOOP_EXTEND)
        return false;
 
    /*
     * Some BackendTypes do not perform reads with IOOBJECT_WAL.
     */
    if (io_object == IOOBJECT_WAL && io_op == IOOP_READ &&
        (bktype == B_WAL_RECEIVER || bktype == B_BG_WRITER ||
         bktype == B_AUTOVAC_LAUNCHER || bktype == B_AUTOVAC_WORKER ||
         bktype == B_WAL_WRITER))
        return false;
 
    /*
     * Temporary tables are not logged and thus do not require fsync'ing.
     * Writeback is not requested for temporary tables.
     */
    if (io_object == IOOBJECT_TEMP_RELATION &&
        (io_op == IOOP_FSYNC || io_op == IOOP_WRITEBACK))
        return false;
 
    /*
     * Some IOOps are not valid in certain IOContexts and some IOOps are only
     * valid in certain contexts.
     */
    if (io_context == IOCONTEXT_BULKREAD && io_op == IOOP_EXTEND)
        return false;
 
    strategy_io_context = io_context == IOCONTEXT_BULKREAD ||
        io_context == IOCONTEXT_BULKWRITE || io_context == IOCONTEXT_VACUUM;
 
    /*
     * IOOP_REUSE is only relevant when a BufferAccessStrategy is in use.
     */
    if (!strategy_io_context && io_op == IOOP_REUSE)
        return false;
 
    /*
     * IOOBJECT_WAL IOObject will not do certain IOOps depending on IOContext.
     */
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_INIT &&
        !(io_op == IOOP_WRITE || io_op == IOOP_FSYNC))
        return false;
 
    if (io_object == IOOBJECT_WAL && io_context == IOCONTEXT_NORMAL &&
        !(io_op == IOOP_WRITE || io_op == IOOP_READ || io_op == IOOP_FSYNC))
        return false;
 
    /*
     * IOOP_FSYNC IOOps done by a backend using a BufferAccessStrategy are
     * counted in the IOCONTEXT_NORMAL IOContext. See comment in
     * register_dirty_segment() for more details.
     */
    if (strategy_io_context && io_op == IOOP_FSYNC)
        return false;
 
 
    return true;
}

References B_AUTOVAC_LAUNCHER, B_AUTOVAC_WORKER, B_BG_WRITER, B_CHECKPOINTER, B_WAL_RECEIVER, B_WAL_WRITER, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_INIT, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, IOOBJECT_TEMP_RELATION, IOOBJECT_WAL, IOOP_EVICT, IOOP_EXTEND, IOOP_FSYNC, IOOP_HIT, IOOP_READ, IOOP_REUSE, IOOP_WRITE, IOOP_WRITEBACK, and pgstat_tracks_io_object().

Referenced by pg_stat_io_build_tuples(), pgstat_bktype_io_stats_valid(), pgstat_count_backend_io_op(), pgstat_count_backend_io_op_time(), and pgstat_count_io_op().

Variable Documentation

have_iostats

bool have_iostats = false

static

Definition at line 24 of file pgstat_io.c.

Referenced by pgstat_count_io_op(), pgstat_io_flush_cb(), and pgstat_io_have_pending_cb().

PendingIOStats

PgStat_PendingIO PendingIOStats

static

Definition at line 23 of file pgstat_io.c.

Referenced by pgstat_count_io_op(), pgstat_count_io_op_time(), and pgstat_io_flush_cb().