aio_init.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "storage/aio.h"
#include "storage/aio_internal.h"
#include "storage/aio_subsys.h"
#include "storage/bufmgr.h"
#include "storage/io_worker.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/shmem.h"
#include "utils/guc.h"

Include dependency graph for aio_init.c:

Go to the source code of this file.

Functions
static Size	AioCtlShmemSize (void)
static uint32	AioProcs (void)
static Size	AioBackendShmemSize (void)
static Size	AioHandleShmemSize (void)
static Size	AioHandleIOVShmemSize (void)
static Size	AioHandleDataShmemSize (void)
static int	AioChooseMaxConcurrency (void)
Size	AioShmemSize (void)
void	AioShmemInit (void)
void	pgaio_init_backend (void)

Function Documentation

AioBackendShmemSize()

static Size AioBackendShmemSize ( void  )

static

Definition at line 49 of file aio_init.c.

{
    return mul_size(AioProcs(), sizeof(PgAioBackend));
}

References AioProcs(), and mul_size().

Referenced by AioShmemInit(), and AioShmemSize().

AioChooseMaxConcurrency()

static int AioChooseMaxConcurrency ( void  )

static

Definition at line 97 of file aio_init.c.

{
    uint32      max_backends;
    int         max_proportional_pins;
 
    /* Similar logic to LimitAdditionalPins() */
    max_backends = MaxBackends + NUM_AUXILIARY_PROCS;
    max_proportional_pins = NBuffers / max_backends;
 
    max_proportional_pins = Max(max_proportional_pins, 1);
 
    /* apply upper limit */
    return Min(max_proportional_pins, 64);
}

References fb(), Max, MaxBackends, Min, NBuffers, and NUM_AUXILIARY_PROCS.

Referenced by AioShmemSize().

AioCtlShmemSize()

static Size AioCtlShmemSize ( void  )

static

Definition at line 31 of file aio_init.c.

{
    /* pgaio_ctl itself */
    return sizeof(PgAioCtl);
}

Referenced by AioShmemInit(), and AioShmemSize().

AioHandleDataShmemSize()

static Size AioHandleDataShmemSize ( void  )

static

Definition at line 79 of file aio_init.c.

{
    /* each buffer referenced by an iovec can have associated data */
    return mul_size(sizeof(uint64),
                    mul_size(mul_size(io_max_combine_limit, AioProcs()),
                             io_max_concurrency));
}

References AioProcs(), io_max_combine_limit, io_max_concurrency, and mul_size().

Referenced by AioShmemInit(), and AioShmemSize().

AioHandleIOVShmemSize()

static Size AioHandleIOVShmemSize ( void  )

static

Definition at line 70 of file aio_init.c.

{
    /* each IO handle can have up to io_max_combine_limit iovec objects */
    return mul_size(sizeof(struct iovec),
                    mul_size(mul_size(io_max_combine_limit, AioProcs()),
                             io_max_concurrency));
}

References AioProcs(), fb(), io_max_combine_limit, io_max_concurrency, and mul_size().

Referenced by AioShmemInit(), and AioShmemSize().

AioHandleShmemSize()

static Size AioHandleShmemSize ( void  )

static

Definition at line 55 of file aio_init.c.

{
    Size        sz;
 
    /* verify AioChooseMaxConcurrency() did its thing */
    Assert(io_max_concurrency > 0);
 
    /* io handles */
    sz = mul_size(AioProcs(),
                  mul_size(io_max_concurrency, sizeof(PgAioHandle)));
 
    return sz;
}

References AioProcs(), Assert, fb(), io_max_concurrency, and mul_size().

Referenced by AioShmemInit(), and AioShmemSize().

AioProcs()

static uint32 AioProcs ( void  )

static

Definition at line 38 of file aio_init.c.

{
    /*
     * While AIO workers don't need their own AIO context, we can't currently
     * guarantee that nothing gets assigned to an IO worker's ProcNumber if we
     * just subtracted MAX_IO_WORKERS.
     */
    return MaxBackends + NUM_AUXILIARY_PROCS;
}

References MaxBackends, and NUM_AUXILIARY_PROCS.

Referenced by AioBackendShmemSize(), AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), AioShmemInit(), and pgaio_init_backend().

AioShmemInit()

void AioShmemInit

(

void

)

Definition at line 149 of file aio_init.c.

{
    bool        found;
    uint32      io_handle_off = 0;
    uint32      iovec_off = 0;
    uint32      per_backend_iovecs = io_max_concurrency * io_max_combine_limit;
 
    pgaio_ctl = (PgAioCtl *)
        ShmemInitStruct("AioCtl", AioCtlShmemSize(), &found);
 
    if (found)
        goto out;
 
    memset(pgaio_ctl, 0, AioCtlShmemSize());
 
    pgaio_ctl->io_handle_count = AioProcs() * io_max_concurrency;
    pgaio_ctl->iovec_count = AioProcs() * per_backend_iovecs;
 
    pgaio_ctl->backend_state = (PgAioBackend *)
        ShmemInitStruct("AioBackend", AioBackendShmemSize(), &found);
 
    pgaio_ctl->io_handles = (PgAioHandle *)
        ShmemInitStruct("AioHandle", AioHandleShmemSize(), &found);
 
    pgaio_ctl->iovecs = (struct iovec *)
        ShmemInitStruct("AioHandleIOV", AioHandleIOVShmemSize(), &found);
    pgaio_ctl->handle_data = (uint64 *)
        ShmemInitStruct("AioHandleData", AioHandleDataShmemSize(), &found);
 
    for (int procno = 0; procno < AioProcs(); procno++)
    {
        PgAioBackend *bs = &pgaio_ctl->backend_state[procno];
 
        bs->io_handle_off = io_handle_off;
        io_handle_off += io_max_concurrency;
 
        dclist_init(&bs->idle_ios);
        memset(bs->staged_ios, 0, sizeof(PgAioHandle *) * PGAIO_SUBMIT_BATCH_SIZE);
        dclist_init(&bs->in_flight_ios);
 
        /* initialize per-backend IOs */
        for (int i = 0; i < io_max_concurrency; i++)
        {
            PgAioHandle *ioh = &pgaio_ctl->io_handles[bs->io_handle_off + i];
 
            ioh->generation = 1;
            ioh->owner_procno = procno;
            ioh->iovec_off = iovec_off;
            ioh->handle_data_len = 0;
            ioh->report_return = NULL;
            ioh->resowner = NULL;
            ioh->num_callbacks = 0;
            ioh->distilled_result.status = PGAIO_RS_UNKNOWN;
            ioh->flags = 0;
 
            ConditionVariableInit(&ioh->cv);
 
            dclist_push_tail(&bs->idle_ios, &ioh->node);
            iovec_off += io_max_combine_limit;
        }
    }
 
out:
    /* Initialize IO method specific resources. */
    if (pgaio_method_ops->shmem_init)
        pgaio_method_ops->shmem_init(!found);
}

References AioBackendShmemSize(), AioCtlShmemSize(), AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), AioProcs(), PgAioCtl::backend_state, ConditionVariableInit(), dclist_init(), dclist_push_tail(), fb(), PgAioHandle::generation, PgAioCtl::handle_data, i, PgAioCtl::io_handle_count, PgAioBackend::io_handle_off, PgAioCtl::io_handles, io_max_combine_limit, io_max_concurrency, PgAioCtl::iovec_count, PgAioCtl::iovecs, pgaio_ctl, pgaio_method_ops, PGAIO_RS_UNKNOWN, PGAIO_SUBMIT_BATCH_SIZE, IoMethodOps::shmem_init, and ShmemInitStruct().

Referenced by CreateOrAttachShmemStructs().

AioShmemSize()

Size AioShmemSize

(

void

)

Definition at line 113 of file aio_init.c.

{
    Size        sz = 0;
 
    /*
     * We prefer to report this value's source as PGC_S_DYNAMIC_DEFAULT.
     * However, if the DBA explicitly set io_max_concurrency = -1 in the
     * config file, then PGC_S_DYNAMIC_DEFAULT will fail to override that and
     * we must force the matter with PGC_S_OVERRIDE.
     */
    if (io_max_concurrency == -1)
    {
        char        buf[32];
 
        snprintf(buf, sizeof(buf), "%d", AioChooseMaxConcurrency());
        SetConfigOption("io_max_concurrency", buf, PGC_POSTMASTER,
                        PGC_S_DYNAMIC_DEFAULT);
        if (io_max_concurrency == -1)   /* failed to apply it? */
            SetConfigOption("io_max_concurrency", buf, PGC_POSTMASTER,
                            PGC_S_OVERRIDE);
    }
 
    sz = add_size(sz, AioCtlShmemSize());
    sz = add_size(sz, AioBackendShmemSize());
    sz = add_size(sz, AioHandleShmemSize());
    sz = add_size(sz, AioHandleIOVShmemSize());
    sz = add_size(sz, AioHandleDataShmemSize());
 
    /* Reserve space for method specific resources. */
    if (pgaio_method_ops->shmem_size)
        sz = add_size(sz, pgaio_method_ops->shmem_size());
 
    return sz;
}

References add_size(), AioBackendShmemSize(), AioChooseMaxConcurrency(), AioCtlShmemSize(), AioHandleDataShmemSize(), AioHandleIOVShmemSize(), AioHandleShmemSize(), buf, fb(), io_max_concurrency, pgaio_method_ops, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, SetConfigOption(), IoMethodOps::shmem_size, and snprintf.

Referenced by CalculateShmemSize().

pgaio_init_backend()

void pgaio_init_backend

(

void

)

Definition at line 218 of file aio_init.c.

{
    /* shouldn't be initialized twice */
    Assert(!pgaio_my_backend);
 
    if (MyBackendType == B_IO_WORKER)
        return;
 
    if (MyProc == NULL || MyProcNumber >= AioProcs())
        elog(ERROR, "aio requires a normal PGPROC");
 
    pgaio_my_backend = &pgaio_ctl->backend_state[MyProcNumber];
 
    if (pgaio_method_ops->init_backend)
        pgaio_method_ops->init_backend();
 
    before_shmem_exit(pgaio_shutdown, 0);
}

References AioProcs(), Assert, B_IO_WORKER, PgAioCtl::backend_state, before_shmem_exit(), elog, ERROR, fb(), IoMethodOps::init_backend, MyBackendType, MyProc, MyProcNumber, pgaio_ctl, pgaio_method_ops, pgaio_my_backend, and pgaio_shutdown().

Referenced by BaseInit().