From b64d5782e2c3a2e34274a3bf9df4449afaee94dc Mon Sep 17 00:00:00 2001 From: Thomas Munro Date: Wed, 26 Oct 2022 15:51:45 +1300 Subject: [PATCH 1/8] Provide SetLatches() for batched deferred latches. If we have a way to buffer a set of wakeup targets and process them at a later time, we can: * move SetLatch() system calls out from under LWLocks, so that locks can be released faster; this is especially interesting in cases where the target backends will immediately try to acquire the same lock, or generally when the lock is heavily contended * possibly gain some micro-opimization from issuing only two memory barriers for the whole batch of latches, not two for each latch to be set * provide the opportunity for potential future latch implementation mechanisms to deliver wakeups in a single system call Individual users of this facility will follow in separate patches. --- src/backend/storage/ipc/latch.c | 187 ++++++++++++++++++------------- src/include/storage/latch.h | 13 +++ src/tools/pgindent/typedefs.list | 1 + 3 files changed, 123 insertions(+), 78 deletions(-) diff --git a/src/backend/storage/ipc/latch.c b/src/backend/storage/ipc/latch.c index eb3a569aae..71fdc388c8 100644 --- a/src/backend/storage/ipc/latch.c +++ b/src/backend/storage/ipc/latch.c @@ -576,105 +576,136 @@ WaitLatchOrSocket(Latch *latch, int wakeEvents, pgsocket sock, } /* - * Sets a latch and wakes up anyone waiting on it. - * - * This is cheap if the latch is already set, otherwise not so much. - * - * NB: when calling this in a signal handler, be sure to save and restore - * errno around it. (That's standard practice in most signal handlers, of - * course, but we used to omit it in handlers that only set a flag.) - * - * NB: this function is called from critical sections and signal handlers so - * throwing an error is not a good idea. + * Set multiple latches at the same time. + * Note: modifies input array. */ -void -SetLatch(Latch *latch) +static void +SetLatchV(Latch **latches, int nlatches) { -#ifndef WIN32 - pid_t owner_pid; -#else - HANDLE handle; -#endif - - /* - * The memory barrier has to be placed here to ensure that any flag - * variables possibly changed by this process have been flushed to main - * memory, before we check/set is_set. - */ + /* Flush any other changes out to main memory just once. */ pg_memory_barrier(); - /* Quick exit if already set */ - if (latch->is_set) - return; + /* Keep only latches that are not already set, and set them. */ + for (int i = 0; i < nlatches; ++i) + { + Latch *latch = latches[i]; - latch->is_set = true; + if (!latch->is_set) + latch->is_set = true; + else + latches[i] = NULL; + } pg_memory_barrier(); - if (!latch->maybe_sleeping) - return; + /* Wake the remaining latches that might be sleeping. */ #ifndef WIN32 - - /* - * See if anyone's waiting for the latch. It can be the current process if - * we're in a signal handler. We use the self-pipe or SIGURG to ourselves - * to wake up WaitEventSetWaitBlock() without races in that case. If it's - * another process, send a signal. - * - * Fetch owner_pid only once, in case the latch is concurrently getting - * owned or disowned. XXX: This assumes that pid_t is atomic, which isn't - * guaranteed to be true! In practice, the effective range of pid_t fits - * in a 32 bit integer, and so should be atomic. In the worst case, we - * might end up signaling the wrong process. Even then, you're very - * unlucky if a process with that bogus pid exists and belongs to - * Postgres; and PG database processes should handle excess SIGUSR1 - * interrupts without a problem anyhow. - * - * Another sort of race condition that's possible here is for a new - * process to own the latch immediately after we look, so we don't signal - * it. This is okay so long as all callers of ResetLatch/WaitLatch follow - * the standard coding convention of waiting at the bottom of their loops, - * not the top, so that they'll correctly process latch-setting events - * that happen before they enter the loop. - */ - owner_pid = latch->owner_pid; - if (owner_pid == 0) - return; - else if (owner_pid == MyProcPid) + for (int i = 0; i < nlatches; ++i) { + Latch *latch = latches[i]; + pid_t owner_pid; + + if (!latch || !latch->maybe_sleeping) + continue; + + /* + * See if anyone's waiting for the latch. It can be the current process + * if we're in a signal handler. We use the self-pipe or SIGURG to + * ourselves to wake up WaitEventSetWaitBlock() without races in that + * case. If it's another process, send a signal. + * + * Fetch owner_pid only once, in case the latch is concurrently getting + * owned or disowned. XXX: This assumes that pid_t is atomic, which + * isn't guaranteed to be true! In practice, the effective range of + * pid_t fits in a 32 bit integer, and so should be atomic. In the + * worst case, we might end up signaling the wrong process. Even then, + * you're very unlucky if a process with that bogus pid exists and + * belongs to Postgres; and PG database processes should handle excess + * SIGURG interrupts without a problem anyhow. + * + * Another sort of race condition that's possible here is for a new + * process to own the latch immediately after we look, so we don't + * signal it. This is okay so long as all callers of + * ResetLatch/WaitLatch follow the standard coding convention of + * waiting at the bottom of their loops, not the top, so that they'll + * correctly process latch-setting events that happen before they enter + * the loop. + */ + owner_pid = latch->owner_pid; + + if (owner_pid == MyProcPid) + { + if (waiting) + { #if defined(WAIT_USE_SELF_PIPE) - if (waiting) - sendSelfPipeByte(); + sendSelfPipeByte(); #else - if (waiting) - kill(MyProcPid, SIGURG); + kill(MyProcPid, SIGURG); #endif + } + } + else + kill(owner_pid, SIGURG); } - else - kill(owner_pid, SIGURG); - #else - - /* - * See if anyone's waiting for the latch. It can be the current process if - * we're in a signal handler. - * - * Use a local variable here just in case somebody changes the event field - * concurrently (which really should not happen). - */ - handle = latch->event; - if (handle) + for (int i = 0; i < nlatches; ++i) { - SetEvent(handle); + Latch *latch = latches[i]; - /* - * Note that we silently ignore any errors. We might be in a signal - * handler or other critical path where it's not safe to call elog(). - */ + if (latch && latch->maybe_sleeping) + { + HANDLE event = latch->event; + + if (event) + SetEvent(event); + } } #endif } +/* + * Sets a latch and wakes up anyone waiting on it. + * + * This is cheap if the latch is already set, otherwise not so much. + * + * NB: when calling this in a signal handler, be sure to save and restore + * errno around it. (That's standard practice in most signal handlers, of + * course, but we used to omit it in handlers that only set a flag.) + * + * NB: this function is called from critical sections and signal handlers so + * throwing an error is not a good idea. + */ +void +SetLatch(Latch *latch) +{ + SetLatchV(&latch, 1); +} + +/* + * Add a latch to a batch, to be set later as a group. + */ +void +AddLatch(LatchBatch *batch, Latch *latch) +{ + if (batch->size == lengthof(batch->latches)) + SetLatches(batch); + + batch->latches[batch->size++] = latch; +} + +/* + * Set all the latches accumulated in 'batch'. + */ +void +SetLatches(LatchBatch *batch) +{ + if (batch->size > 0) + { + SetLatchV(batch->latches, batch->size); + batch->size = 0; + } +} + /* * Clear the latch. Calling WaitLatch after this will sleep, unless * the latch is set again before the WaitLatch call. diff --git a/src/include/storage/latch.h b/src/include/storage/latch.h index 68ab740f16..0edf364637 100644 --- a/src/include/storage/latch.h +++ b/src/include/storage/latch.h @@ -118,6 +118,17 @@ typedef struct Latch #endif } Latch; +#define LATCH_BATCH_SIZE 64 + +/* + * Container for setting multiple latches at a time. + */ +typedef struct LatchBatch +{ + int size; + Latch *latches[LATCH_BATCH_SIZE]; +} LatchBatch; + /* * Bitmasks for events that may wake-up WaitLatch(), WaitLatchOrSocket(), or * WaitEventSetWait(). @@ -163,6 +174,8 @@ extern void InitSharedLatch(Latch *latch); extern void OwnLatch(Latch *latch); extern void DisownLatch(Latch *latch); extern void SetLatch(Latch *latch); +extern void AddLatch(LatchBatch * batch, Latch *latch); +extern void SetLatches(LatchBatch * batch); extern void ResetLatch(Latch *latch); extern void ShutdownLatchSupport(void); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 2f02cc8f42..f05c41043d 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -1389,6 +1389,7 @@ LagTracker LargeObjectDesc LastAttnumInfo Latch +LatchBatch LerpFunc LexDescr LexemeEntry -- 2.35.1