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 "storage/subsystems.h"
#include "utils/guc.h"

Include dependency graph for aio_init.c:

Go to the source code of this file.

Functions
static void	AioShmemRequest (void *arg)
static void	AioShmemInit (void *arg)
static void	AioShmemAttach (void *arg)
static uint32	AioProcs (void)
static Size	AioBackendShmemSize (void)
static Size	AioHandleShmemSize (void)
static Size	AioHandleIOVShmemSize (void)
static Size	AioHandleDataShmemSize (void)
static int	AioChooseMaxConcurrency (void)
void	pgaio_init_backend (void)

Variables
const ShmemCallbacks	AioShmemCallbacks
static PgAioBackend *	AioBackendShmemPtr
static PgAioHandle *	AioHandleShmemPtr
static struct iovec *	AioHandleIOVShmemPtr
static uint64 *	AioHandleDataShmemPtr

Function Documentation

AioBackendShmemSize()

static Size AioBackendShmemSize ( void  )

static

Definition at line 57 of file aio_init.c.

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

References AioProcs(), and mul_size().

Referenced by AioShmemRequest().

AioChooseMaxConcurrency()

static int AioChooseMaxConcurrency ( void  )

static

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

AioHandleDataShmemSize()

static Size AioHandleDataShmemSize ( void  )

static

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

AioHandleIOVShmemSize()

static Size AioHandleIOVShmemSize ( void  )

static

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

AioHandleShmemSize()

static Size AioHandleShmemSize ( void  )

static

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

AioProcs()

static uint32 AioProcs ( void  )

static

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

AioShmemAttach()

static void AioShmemAttach ( void *  arg )

static

Definition at line 231 of file aio_init.c.

{
    if (pgaio_method_ops->shmem_callbacks.attach_fn)
        pgaio_method_ops->shmem_callbacks.attach_fn(pgaio_method_ops->shmem_callbacks.opaque_arg);
}

References ShmemCallbacks::attach_fn, ShmemCallbacks::opaque_arg, pgaio_method_ops, and IoMethodOps::shmem_callbacks.

AioShmemInit()

static void AioShmemInit ( void *  arg )

static

Definition at line 179 of file aio_init.c.

{
    uint32      io_handle_off = 0;
    uint32      iovec_off = 0;
    uint32      per_backend_iovecs = io_max_concurrency * io_max_combine_limit;
 
    pgaio_ctl->io_handle_count = AioProcs() * io_max_concurrency;
    pgaio_ctl->iovec_count = AioProcs() * per_backend_iovecs;
 
    pgaio_ctl->backend_state = AioBackendShmemPtr;
    pgaio_ctl->io_handles = AioHandleShmemPtr;
    pgaio_ctl->iovecs = AioHandleIOVShmemPtr;
    pgaio_ctl->handle_data = AioHandleDataShmemPtr;
 
    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;
        }
    }
 
    if (pgaio_method_ops->shmem_callbacks.init_fn)
        pgaio_method_ops->shmem_callbacks.init_fn(pgaio_method_ops->shmem_callbacks.opaque_arg);
}

References AioBackendShmemPtr, AioHandleDataShmemPtr, AioHandleIOVShmemPtr, AioHandleShmemPtr, AioProcs(), PgAioCtl::backend_state, ConditionVariableInit(), dclist_init(), dclist_push_tail(), fb(), PgAioHandle::generation, PgAioCtl::handle_data, i, ShmemCallbacks::init_fn, PgAioCtl::io_handle_count, PgAioBackend::io_handle_off, PgAioCtl::io_handles, io_max_combine_limit, io_max_concurrency, PgAioCtl::iovec_count, PgAioCtl::iovecs, ShmemCallbacks::opaque_arg, pgaio_ctl, pgaio_method_ops, PGAIO_RS_UNKNOWN, PGAIO_SUBMIT_BATCH_SIZE, and IoMethodOps::shmem_callbacks.

AioShmemRequest()

static void AioShmemRequest ( void *  arg )

static

Definition at line 124 of file aio_init.c.

{
    /*
     * Resolve io_max_concurrency if not already done
     *
     * 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);
    }
 
    ShmemRequestStruct(.name = "AioCtl",
                       .size = sizeof(PgAioCtl),
                       .ptr = (void **) &pgaio_ctl,
        );
 
    ShmemRequestStruct(.name = "AioBackend",
                       .size = AioBackendShmemSize(),
                       .ptr = (void **) &AioBackendShmemPtr,
        );
 
    ShmemRequestStruct(.name = "AioHandle",
                       .size = AioHandleShmemSize(),
                       .ptr = (void **) &AioHandleShmemPtr,
        );
 
    ShmemRequestStruct(.name = "AioHandleIOV",
                       .size = AioHandleIOVShmemSize(),
                       .ptr = (void **) &AioHandleIOVShmemPtr,
        );
 
    ShmemRequestStruct(.name = "AioHandleData",
                       .size = AioHandleDataShmemSize(),
                       .ptr = (void **) &AioHandleDataShmemPtr,
        );
 
    if (pgaio_method_ops->shmem_callbacks.request_fn)
        pgaio_method_ops->shmem_callbacks.request_fn(pgaio_method_ops->shmem_callbacks.opaque_arg);
}

References AioBackendShmemPtr, AioBackendShmemSize(), AioChooseMaxConcurrency(), AioHandleDataShmemPtr, AioHandleDataShmemSize(), AioHandleIOVShmemPtr, AioHandleIOVShmemSize(), AioHandleShmemPtr, AioHandleShmemSize(), buf, io_max_concurrency, name, ShmemCallbacks::opaque_arg, pgaio_ctl, pgaio_method_ops, PGC_POSTMASTER, PGC_S_DYNAMIC_DEFAULT, PGC_S_OVERRIDE, ShmemCallbacks::request_fn, SetConfigOption(), IoMethodOps::shmem_callbacks, ShmemRequestStruct, and snprintf.

pgaio_init_backend()

void pgaio_init_backend

(

void

)

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

Variable Documentation

AioBackendShmemPtr

PgAioBackend* AioBackendShmemPtr

static

Definition at line 40 of file aio_init.c.

Referenced by AioShmemInit(), and AioShmemRequest().

AioHandleDataShmemPtr

uint64* AioHandleDataShmemPtr

static

Definition at line 43 of file aio_init.c.

Referenced by AioShmemInit(), and AioShmemRequest().

AioHandleIOVShmemPtr

struct iovec* AioHandleIOVShmemPtr

static

Definition at line 42 of file aio_init.c.

Referenced by AioShmemInit(), and AioShmemRequest().

AioHandleShmemPtr

PgAioHandle* AioHandleShmemPtr

static

Definition at line 41 of file aio_init.c.

Referenced by AioShmemInit(), and AioShmemRequest().

AioShmemCallbacks

const ShmemCallbacks AioShmemCallbacks

Initial value:

= {
    .request_fn = AioShmemRequest,
    .init_fn = AioShmemInit,
    .attach_fn = AioShmemAttach,
}

Definition at line 34 of file aio_init.c.

                                         {
    .request_fn = AioShmemRequest,
    .init_fn = AioShmemInit,
    .attach_fn = AioShmemAttach,
};