From 4f6f260ff706c769d5e4f40e5fc23c2c3105afa2 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Wed, 28 Aug 2024 14:28:36 -0400 Subject: [PATCH v2.0 08/17] aio: Skeleton IO worker infrastructure This doesn't do anything useful on its own, but the code that needs to be touched is independent of other changes. Remarks: - should completely get rid of ID assignment logic in postmaster.c - postmaster.c badly needs a refactoring. - dynamic increase / decrease of workers based on IO load Author: Reviewed-by: Discussion: https://postgr.es/m/ Backpatch: --- src/include/miscadmin.h | 2 + src/include/postmaster/postmaster.h | 1 + src/include/storage/aio_init.h | 2 + src/include/storage/io_worker.h | 22 +++ src/include/storage/proc.h | 4 +- src/backend/postmaster/launch_backend.c | 2 + src/backend/postmaster/postmaster.c | 186 ++++++++++++++++-- src/backend/storage/aio/Makefile | 1 + src/backend/storage/aio/meson.build | 1 + src/backend/storage/aio/method_worker.c | 84 ++++++++ src/backend/tcop/postgres.c | 2 + src/backend/utils/activity/pgstat_io.c | 1 + .../utils/activity/wait_event_names.txt | 1 + src/backend/utils/init/miscinit.c | 3 + src/backend/utils/misc/guc_tables.c | 13 ++ src/backend/utils/misc/postgresql.conf.sample | 3 +- 16 files changed, 312 insertions(+), 16 deletions(-) create mode 100644 src/include/storage/io_worker.h create mode 100644 src/backend/storage/aio/method_worker.c diff --git a/src/include/miscadmin.h b/src/include/miscadmin.h index 25348e71eb9..d043445b544 100644 --- a/src/include/miscadmin.h +++ b/src/include/miscadmin.h @@ -352,6 +352,7 @@ typedef enum BackendType B_ARCHIVER, B_BG_WRITER, B_CHECKPOINTER, + B_IO_WORKER, B_STARTUP, B_WAL_RECEIVER, B_WAL_SUMMARIZER, @@ -380,6 +381,7 @@ extern PGDLLIMPORT BackendType MyBackendType; #define AmWalReceiverProcess() (MyBackendType == B_WAL_RECEIVER) #define AmWalSummarizerProcess() (MyBackendType == B_WAL_SUMMARIZER) #define AmWalWriterProcess() (MyBackendType == B_WAL_WRITER) +#define AmIoWorkerProcess() (MyBackendType == B_IO_WORKER) extern const char *GetBackendTypeDesc(BackendType backendType); diff --git a/src/include/postmaster/postmaster.h b/src/include/postmaster/postmaster.h index 63c12917cfe..4cc000df79e 100644 --- a/src/include/postmaster/postmaster.h +++ b/src/include/postmaster/postmaster.h @@ -62,6 +62,7 @@ extern void InitProcessGlobals(void); extern int MaxLivePostmasterChildren(void); extern bool PostmasterMarkPIDForWorkerNotify(int); +extern void assign_io_workers(int newval, void *extra); #ifdef WIN32 extern void pgwin32_register_deadchild_callback(HANDLE procHandle, DWORD procId); diff --git a/src/include/storage/aio_init.h b/src/include/storage/aio_init.h index 5bcfb8a9d58..a38dd982fbe 100644 --- a/src/include/storage/aio_init.h +++ b/src/include/storage/aio_init.h @@ -23,4 +23,6 @@ extern void pgaio_postmaster_init(void); extern void pgaio_postmaster_child_init_local(void); extern void pgaio_postmaster_child_init(void); +extern bool pgaio_workers_enabled(void); + #endif /* AIO_INIT_H */ diff --git a/src/include/storage/io_worker.h b/src/include/storage/io_worker.h new file mode 100644 index 00000000000..ba5dcb9e6e4 --- /dev/null +++ b/src/include/storage/io_worker.h @@ -0,0 +1,22 @@ +/*------------------------------------------------------------------------- + * + * io_worker.h + * IO worker for implementing AIO "ourselves" + * + * + * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/storage/io.h + * + *------------------------------------------------------------------------- + */ +#ifndef IO_WORKER_H +#define IO_WORKER_H + + +extern void IoWorkerMain(char *startup_data, size_t startup_data_len) pg_attribute_noreturn(); + +extern int io_workers; + +#endif /* IO_WORKER_H */ diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h index deeb06c9e01..b466ba843d6 100644 --- a/src/include/storage/proc.h +++ b/src/include/storage/proc.h @@ -442,7 +442,9 @@ extern PGDLLIMPORT PGPROC *PreparedXactProcs; * 2 slots, but WAL writer is launched only after startup has exited, so we * only need 6 slots. */ -#define NUM_AUXILIARY_PROCS 6 +#define MAX_IO_WORKERS 32 +#define NUM_AUXILIARY_PROCS (6 + MAX_IO_WORKERS) + /* configurable options */ extern PGDLLIMPORT int DeadlockTimeout; diff --git a/src/backend/postmaster/launch_backend.c b/src/backend/postmaster/launch_backend.c index 0ae23fdf55e..78429b2af2f 100644 --- a/src/backend/postmaster/launch_backend.c +++ b/src/backend/postmaster/launch_backend.c @@ -55,6 +55,7 @@ #include "replication/walreceiver.h" #include "storage/dsm.h" #include "storage/fd.h" +#include "storage/io_worker.h" #include "storage/ipc.h" #include "storage/pg_shmem.h" #include "storage/pmsignal.h" @@ -199,6 +200,7 @@ static child_process_kind child_process_kinds[] = { [B_ARCHIVER] = {"archiver", PgArchiverMain, true}, [B_BG_WRITER] = {"bgwriter", BackgroundWriterMain, true}, [B_CHECKPOINTER] = {"checkpointer", CheckpointerMain, true}, + [B_IO_WORKER] = {"io_worker", IoWorkerMain, true}, [B_STARTUP] = {"startup", StartupProcessMain, true}, [B_WAL_RECEIVER] = {"wal_receiver", WalReceiverMain, true}, [B_WAL_SUMMARIZER] = {"wal_summarizer", WalSummarizerMain, true}, diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index 921073a2ca4..fc3901d5347 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -113,6 +113,7 @@ #include "replication/walsender.h" #include "storage/aio_init.h" #include "storage/fd.h" +#include "storage/io_worker.h" #include "storage/ipc.h" #include "storage/pmsignal.h" #include "storage/proc.h" @@ -321,6 +322,7 @@ typedef enum * ckpt */ PM_SHUTDOWN_2, /* waiting for archiver and walsenders to * finish */ + PM_SHUTDOWN_IO, /* waiting for io workers to exit */ PM_WAIT_DEAD_END, /* waiting for dead_end children to exit */ PM_NO_CHILDREN, /* all important children have exited */ } PMState; @@ -382,6 +384,10 @@ bool LoadedSSL = false; static DNSServiceRef bonjour_sdref = NULL; #endif +/* State for IO worker management. */ +static int io_worker_count = 0; +static pid_t io_worker_pids[MAX_IO_WORKERS]; + /* * postmaster.c - function prototypes */ @@ -420,6 +426,9 @@ static int CountChildren(int target); static Backend *assign_backendlist_entry(void); static void LaunchMissingBackgroundProcesses(void); static void maybe_start_bgworkers(void); +static bool maybe_reap_io_worker(int pid); +static void maybe_adjust_io_workers(void); +static void signal_io_workers(int signal); static bool CreateOptsFile(int argc, char *argv[], char *fullprogname); static pid_t StartChildProcess(BackendType type); static void StartAutovacuumWorker(void); @@ -1334,6 +1343,11 @@ PostmasterMain(int argc, char *argv[]) */ AddToDataDirLockFile(LOCK_FILE_LINE_PM_STATUS, PM_STATUS_STARTING); + pmState = PM_STARTUP; + + /* Make sure we can perform I/O while starting up. */ + maybe_adjust_io_workers(); + /* Start bgwriter and checkpointer so they can help with recovery */ if (CheckpointerPID == 0) CheckpointerPID = StartChildProcess(B_CHECKPOINTER); @@ -1346,7 +1360,6 @@ PostmasterMain(int argc, char *argv[]) StartupPID = StartChildProcess(B_STARTUP); Assert(StartupPID != 0); StartupStatus = STARTUP_RUNNING; - pmState = PM_STARTUP; /* Some workers may be scheduled to start now */ maybe_start_bgworkers(); @@ -1995,6 +2008,7 @@ process_pm_reload_request(void) signal_child(SysLoggerPID, SIGHUP); if (SlotSyncWorkerPID != 0) signal_child(SlotSyncWorkerPID, SIGHUP); + signal_io_workers(SIGHUP); /* Reload authentication config files too */ if (!load_hba()) @@ -2527,6 +2541,22 @@ process_pm_child_exit(void) } } + /* Was it an IO worker? */ + if (maybe_reap_io_worker(pid)) + { + if (!EXIT_STATUS_0(exitstatus) && !EXIT_STATUS_1(exitstatus)) + HandleChildCrash(pid, exitstatus, _("io worker")); + + maybe_adjust_io_workers(); + + if (io_worker_count == 0 && + pmState >= PM_SHUTDOWN_IO) + { + pmState = PM_WAIT_DEAD_END; + } + continue; + } + /* * We don't know anything about this child process. That's highly * unexpected, as we do track all the child processes that we fork. @@ -2763,6 +2793,9 @@ HandleChildCrash(int pid, int exitstatus, const char *procname) if (SlotSyncWorkerPID != 0) sigquit_child(SlotSyncWorkerPID); + /* Take care of io workers too */ + signal_io_workers(SIGQUIT); + /* We do NOT restart the syslogger */ } @@ -2986,10 +3019,11 @@ PostmasterStateMachine(void) FatalError = true; pmState = PM_WAIT_DEAD_END; - /* Kill the walsenders and archiver too */ + /* Kill walsenders, archiver and aio workers too */ SignalChildren(SIGQUIT); if (PgArchPID != 0) signal_child(PgArchPID, SIGQUIT); + signal_io_workers(SIGQUIT); } } } @@ -2999,16 +3033,26 @@ PostmasterStateMachine(void) { /* * PM_SHUTDOWN_2 state ends when there's no other children than - * dead_end children left. There shouldn't be any regular backends - * left by now anyway; what we're really waiting for is walsenders and - * archiver. + * dead_end children and aio workers left. There shouldn't be any + * regular backends left by now anyway; what we're really waiting for + * is walsenders and archiver. */ if (PgArchPID == 0 && CountChildren(BACKEND_TYPE_ALL) == 0) { - pmState = PM_WAIT_DEAD_END; + pmState = PM_SHUTDOWN_IO; + signal_io_workers(SIGUSR2); } } + if (pmState == PM_SHUTDOWN_IO) + { + /* + * PM_SHUTDOWN_IO state ends when there's only dead_end children left. + */ + if (io_worker_count == 0) + pmState = PM_WAIT_DEAD_END; + } + if (pmState == PM_WAIT_DEAD_END) { /* Don't allow any new socket connection events. */ @@ -3016,17 +3060,22 @@ PostmasterStateMachine(void) /* * PM_WAIT_DEAD_END state ends when the BackendList is entirely empty - * (ie, no dead_end children remain), and the archiver is gone too. + * (ie, no dead_end children remain), and the archiver and aio workers + * are all gone too. * - * The reason we wait for those two is to protect them against a new + * We need to wait for those because we might have transitioned + * directly to PM_WAIT_DEAD_END due to immediate shutdown or fatal + * error. Note that they have already been sent appropriate shutdown + * signals, either during a normal state transition leading up to + * PM_WAIT_DEAD_END, or during FatalError processing. + * + * The reason we wait for those is to protect them against a new * postmaster starting conflicting subprocesses; this isn't an * ironclad protection, but it at least helps in the - * shutdown-and-immediately-restart scenario. Note that they have - * already been sent appropriate shutdown signals, either during a - * normal state transition leading up to PM_WAIT_DEAD_END, or during - * FatalError processing. + * shutdown-and-immediately-restart scenario. */ - if (dlist_is_empty(&BackendList) && PgArchPID == 0) + if (dlist_is_empty(&BackendList) && io_worker_count == 0 + && PgArchPID == 0) { /* These other guys should be dead already */ Assert(StartupPID == 0); @@ -3119,10 +3168,14 @@ PostmasterStateMachine(void) /* re-create shared memory and semaphores */ CreateSharedMemoryAndSemaphores(); + pmState = PM_STARTUP; + + /* Make sure we can perform I/O while starting up. */ + maybe_adjust_io_workers(); + StartupPID = StartChildProcess(B_STARTUP); Assert(StartupPID != 0); StartupStatus = STARTUP_RUNNING; - pmState = PM_STARTUP; /* crash recovery started, reset SIGKILL flag */ AbortStartTime = 0; @@ -3374,6 +3427,7 @@ TerminateChildren(int signal) signal_child(PgArchPID, signal); if (SlotSyncWorkerPID != 0) signal_child(SlotSyncWorkerPID, signal); + signal_io_workers(signal); } /* @@ -3955,6 +4009,7 @@ bgworker_should_start_now(BgWorkerStartTime start_time) { case PM_NO_CHILDREN: case PM_WAIT_DEAD_END: + case PM_SHUTDOWN_IO: case PM_SHUTDOWN_2: case PM_SHUTDOWN: case PM_WAIT_BACKENDS: @@ -4148,6 +4203,109 @@ maybe_start_bgworkers(void) } } +static bool +maybe_reap_io_worker(int pid) +{ + for (int id = 0; id < MAX_IO_WORKERS; ++id) + { + if (io_worker_pids[id] == pid) + { + --io_worker_count; + io_worker_pids[id] = 0; + return true; + } + } + return false; +} + +static void +maybe_adjust_io_workers(void) +{ + /* ATODO: This will need to check if io_method == worker */ + + /* + * If we're in final shutting down state, then we're just waiting for all + * processes to exit. + */ + if (pmState >= PM_SHUTDOWN_IO) + return; + + /* Don't start new workers during an immediate shutdown either. */ + if (Shutdown >= ImmediateShutdown) + return; + + /* + * Don't start new workers if we're in the shutdown phase of a crash + * restart. But we *do* need to start if we're already starting up again. + */ + if (FatalError && pmState >= PM_STOP_BACKENDS) + return; + + /* Not enough running? */ + while (io_worker_count < io_workers) + { + int pid; + int id; + + /* Find the lowest unused IO worker ID. */ + + /* + * AFIXME: This logic doesn't work right now, the ids aren't + * transported to workers anymore. + */ + for (id = 0; id < MAX_IO_WORKERS; ++id) + { + if (io_worker_pids[id] == 0) + break; + } + if (id == MAX_IO_WORKERS) + elog(ERROR, "could not find a free IO worker ID"); + + Assert(pmState < PM_SHUTDOWN_IO); + + /* Try to launch one. */ + pid = StartChildProcess(B_IO_WORKER); + if (pid > 0) + { + io_worker_pids[id] = pid; + ++io_worker_count; + } + else + break; /* XXX try again soon? */ + } + + /* Too many running? */ + if (io_worker_count > io_workers) + { + /* Ask the highest used IO worker ID to exit. */ + for (int id = MAX_IO_WORKERS - 1; id >= 0; --id) + { + if (io_worker_pids[id] != 0) + { + kill(io_worker_pids[id], SIGUSR2); + break; + } + } + } +} + +static void +signal_io_workers(int signal) +{ + for (int i = 0; i < MAX_IO_WORKERS; ++i) + if (io_worker_pids[i] != 0) + signal_child(io_worker_pids[i], signal); +} + +void +assign_io_workers(int newval, void *extra) +{ + io_workers = newval; + if (!IsUnderPostmaster && pmState > PM_INIT) + maybe_adjust_io_workers(); +} + + /* * When a backend asks to be notified about worker state changes, we * set a flag in its backend entry. The background worker machinery needs diff --git a/src/backend/storage/aio/Makefile b/src/backend/storage/aio/Makefile index eaeaeeee8e3..824682e7354 100644 --- a/src/backend/storage/aio/Makefile +++ b/src/backend/storage/aio/Makefile @@ -11,6 +11,7 @@ include $(top_builddir)/src/Makefile.global OBJS = \ aio.o \ aio_init.o \ + method_worker.o \ read_stream.o include $(top_srcdir)/src/backend/common.mk diff --git a/src/backend/storage/aio/meson.build b/src/backend/storage/aio/meson.build index 8d20759ebf8..e13728b73da 100644 --- a/src/backend/storage/aio/meson.build +++ b/src/backend/storage/aio/meson.build @@ -3,5 +3,6 @@ backend_sources += files( 'aio.c', 'aio_init.c', + 'method_worker.c', 'read_stream.c', ) diff --git a/src/backend/storage/aio/method_worker.c b/src/backend/storage/aio/method_worker.c new file mode 100644 index 00000000000..5df2eea4a03 --- /dev/null +++ b/src/backend/storage/aio/method_worker.c @@ -0,0 +1,84 @@ +/*------------------------------------------------------------------------- + * + * method_worker.c + * AIO implementation using workers + * + * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * IDENTIFICATION + * src/backend/storage/aio/method_worker.c + * + *------------------------------------------------------------------------- + */ + +#include "postgres.h" + +#include "libpq/pqsignal.h" +#include "miscadmin.h" +#include "postmaster/interrupt.h" +#include "storage/io_worker.h" +#include "storage/ipc.h" +#include "storage/latch.h" +#include "storage/proc.h" +#include "tcop/tcopprot.h" +#include "utils/wait_event.h" + + +int io_workers = 3; + + +void +IoWorkerMain(char *startup_data, size_t startup_data_len) +{ + sigjmp_buf local_sigjmp_buf; + + MyBackendType = B_IO_WORKER; + + /* TODO review all signals */ + pqsignal(SIGHUP, SignalHandlerForConfigReload); + pqsignal(SIGINT, die); /* to allow manually triggering worker restart */ + + /* + * Ignore SIGTERM, will get explicit shutdown via SIGUSR2 later in the + * shutdown sequence, similar to checkpointer. + */ + pqsignal(SIGTERM, SIG_IGN); + /* SIGQUIT handler was already set up by InitPostmasterChild */ + pqsignal(SIGALRM, SIG_IGN); + pqsignal(SIGPIPE, SIG_IGN); + pqsignal(SIGUSR1, procsignal_sigusr1_handler); + pqsignal(SIGUSR2, SignalHandlerForShutdownRequest); + sigprocmask(SIG_SETMASK, &UnBlockSig, NULL); + + /* see PostgresMain() */ + if (sigsetjmp(local_sigjmp_buf, 1) != 0) + { + error_context_stack = NULL; + HOLD_INTERRUPTS(); + + /* + * We normally shouldn't get errors here. Need to do just enough error + * recovery so that we can mark the IO as failed and then exit. + */ + LWLockReleaseAll(); + + /* TODO: recover from IO errors */ + + EmitErrorReport(); + proc_exit(1); + } + + /* We can now handle ereport(ERROR) */ + PG_exception_stack = &local_sigjmp_buf; + + while (!ShutdownRequestPending) + { + WaitLatch(MyLatch, WL_LATCH_SET | WL_EXIT_ON_PM_DEATH, -1, + WAIT_EVENT_IO_WORKER_MAIN); + ResetLatch(MyLatch); + CHECK_FOR_INTERRUPTS(); + } + + proc_exit(0); +} diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 4dc46b17b41..d42546db195 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -3294,6 +3294,8 @@ ProcessInterrupts(void) (errcode(ERRCODE_ADMIN_SHUTDOWN), errmsg("terminating background worker \"%s\" due to administrator command", MyBgworkerEntry->bgw_type))); + else if (AmIoWorkerProcess()) + proc_exit(0); else ereport(FATAL, (errcode(ERRCODE_ADMIN_SHUTDOWN), diff --git a/src/backend/utils/activity/pgstat_io.c b/src/backend/utils/activity/pgstat_io.c index 8af55989eed..a750caa9b2a 100644 --- a/src/backend/utils/activity/pgstat_io.c +++ b/src/backend/utils/activity/pgstat_io.c @@ -335,6 +335,7 @@ pgstat_tracks_io_bktype(BackendType bktype) { case B_INVALID: case B_ARCHIVER: + case B_IO_WORKER: case B_LOGGER: case B_WAL_RECEIVER: case B_WAL_WRITER: diff --git a/src/backend/utils/activity/wait_event_names.txt b/src/backend/utils/activity/wait_event_names.txt index 8efb4044d6f..47a2c4d126b 100644 --- a/src/backend/utils/activity/wait_event_names.txt +++ b/src/backend/utils/activity/wait_event_names.txt @@ -56,6 +56,7 @@ AUTOVACUUM_MAIN "Waiting in main loop of autovacuum launcher process." BGWRITER_HIBERNATE "Waiting in background writer process, hibernating." BGWRITER_MAIN "Waiting in main loop of background writer process." CHECKPOINTER_MAIN "Waiting in main loop of checkpointer process." +IO_WORKER_MAIN "Waiting in main loop of IO Worker process." LOGICAL_APPLY_MAIN "Waiting in main loop of logical replication apply process." LOGICAL_LAUNCHER_MAIN "Waiting in main loop of logical replication launcher process." LOGICAL_PARALLEL_APPLY_MAIN "Waiting in main loop of logical replication parallel apply process." diff --git a/src/backend/utils/init/miscinit.c b/src/backend/utils/init/miscinit.c index b8fa2e64ffe..bedeed588d3 100644 --- a/src/backend/utils/init/miscinit.c +++ b/src/backend/utils/init/miscinit.c @@ -293,6 +293,9 @@ GetBackendTypeDesc(BackendType backendType) case B_CHECKPOINTER: backendDesc = "checkpointer"; break; + case B_IO_WORKER: + backendDesc = "io worker"; + break; case B_LOGGER: backendDesc = "logger"; break; diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c index 4961a5f4b16..5670f40478a 100644 --- a/src/backend/utils/misc/guc_tables.c +++ b/src/backend/utils/misc/guc_tables.c @@ -74,6 +74,7 @@ #include "storage/aio.h" #include "storage/bufmgr.h" #include "storage/bufpage.h" +#include "storage/io_worker.h" #include "storage/large_object.h" #include "storage/pg_shmem.h" #include "storage/predicate.h" @@ -3201,6 +3202,18 @@ struct config_int ConfigureNamesInt[] = NULL, NULL, NULL }, + { + {"io_workers", + PGC_SIGHUP, + RESOURCES_ASYNCHRONOUS, + gettext_noop("Number of IO worker processes, for io_method=worker."), + NULL, + }, + &io_workers, + 3, 1, MAX_IO_WORKERS, + NULL, assign_io_workers, NULL + }, + { {"backend_flush_after", PGC_USERSET, RESOURCES_ASYNCHRONOUS, gettext_noop("Number of pages after which previously performed writes are flushed to disk."), diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample index e904c3fea30..90430381efa 100644 --- a/src/backend/utils/misc/postgresql.conf.sample +++ b/src/backend/utils/misc/postgresql.conf.sample @@ -839,7 +839,8 @@ # WIP AIO GUC docs #------------------------------------------------------------------------------ -#io_method = worker +#io_method = worker # (change requires restart) +#io_workers = 3 # 1-32; #------------------------------------------------------------------------------ -- 2.45.2.827.g557ae147e6