PostgreSQL Source Code  git master
condition_variable.h File Reference
Include dependency graph for condition_variable.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  ConditionVariable
 
union  ConditionVariableMinimallyPadded
 

Macros

#define CV_MINIMAL_SIZE   (sizeof(ConditionVariable) <= 16 ? 16 : 32)
 

Typedefs

typedef union ConditionVariableMinimallyPadded ConditionVariableMinimallyPadded
 

Functions

void ConditionVariableInit (ConditionVariable *cv)
 
void ConditionVariableSleep (ConditionVariable *cv, uint32 wait_event_info)
 
bool ConditionVariableTimedSleep (ConditionVariable *cv, long timeout, uint32 wait_event_info)
 
void ConditionVariableCancelSleep (void)
 
void ConditionVariablePrepareToSleep (ConditionVariable *cv)
 
void ConditionVariableSignal (ConditionVariable *cv)
 
void ConditionVariableBroadcast (ConditionVariable *cv)
 

Macro Definition Documentation

◆ CV_MINIMAL_SIZE

#define CV_MINIMAL_SIZE   (sizeof(ConditionVariable) <= 16 ? 16 : 32)

Definition at line 38 of file condition_variable.h.

Typedef Documentation

◆ ConditionVariableMinimallyPadded

Function Documentation

◆ ConditionVariableBroadcast()

void ConditionVariableBroadcast ( ConditionVariable cv)

Definition at line 286 of file condition_variable.c.

References Assert, ConditionVariableCancelSleep(), ConditionVariable::mutex, MyProc, PGPROC::pgprocno, PGPROC::procLatch, proclist_contains, proclist_is_empty(), proclist_pop_head_node, proclist_push_tail, SetLatch(), SpinLockAcquire, SpinLockRelease, and ConditionVariable::wakeup.

Referenced by _bt_parallel_done(), BarrierArriveAndWait(), BarrierDetachImpl(), BitmapDoneInitializingSharedState(), CheckpointerMain(), CleanupProcSignalState(), ProcessProcSignalBarrier(), ReplicationOriginExitCleanup(), ReplicationSlotAcquireInternal(), ReplicationSlotCleanup(), ReplicationSlotCreate(), ReplicationSlotDropPtr(), ReplicationSlotRelease(), replorigin_session_reset(), replorigin_session_setup(), SetRecoveryPause(), ShutdownWalRcv(), TerminateBufferIO(), WalRcvDie(), WalRcvRunning(), WalRcvStreaming(), and WalReceiverMain().

287 {
288  int pgprocno = MyProc->pgprocno;
289  PGPROC *proc = NULL;
290  bool have_sentinel = false;
291 
292  /*
293  * In some use-cases, it is common for awakened processes to immediately
294  * re-queue themselves. If we just naively try to reduce the wakeup list
295  * to empty, we'll get into a potentially-indefinite loop against such a
296  * process. The semantics we really want are just to be sure that we have
297  * wakened all processes that were in the list at entry. We can use our
298  * own cvWaitLink as a sentinel to detect when we've finished.
299  *
300  * A seeming flaw in this approach is that someone else might signal the
301  * CV and in doing so remove our sentinel entry. But that's fine: since
302  * CV waiters are always added and removed in order, that must mean that
303  * every previous waiter has been wakened, so we're done. We'll get an
304  * extra "set" on our latch from the someone else's signal, which is
305  * slightly inefficient but harmless.
306  *
307  * We can't insert our cvWaitLink as a sentinel if it's already in use in
308  * some other proclist. While that's not expected to be true for typical
309  * uses of this function, we can deal with it by simply canceling any
310  * prepared CV sleep. The next call to ConditionVariableSleep will take
311  * care of re-establishing the lost state.
312  */
313  if (cv_sleep_target != NULL)
315 
316  /*
317  * Inspect the state of the queue. If it's empty, we have nothing to do.
318  * If there's exactly one entry, we need only remove and signal that
319  * entry. Otherwise, remove the first entry and insert our sentinel.
320  */
321  SpinLockAcquire(&cv->mutex);
322  /* While we're here, let's assert we're not in the list. */
323  Assert(!proclist_contains(&cv->wakeup, pgprocno, cvWaitLink));
324 
325  if (!proclist_is_empty(&cv->wakeup))
326  {
327  proc = proclist_pop_head_node(&cv->wakeup, cvWaitLink);
328  if (!proclist_is_empty(&cv->wakeup))
329  {
330  proclist_push_tail(&cv->wakeup, pgprocno, cvWaitLink);
331  have_sentinel = true;
332  }
333  }
334  SpinLockRelease(&cv->mutex);
335 
336  /* Awaken first waiter, if there was one. */
337  if (proc != NULL)
338  SetLatch(&proc->procLatch);
339 
340  while (have_sentinel)
341  {
342  /*
343  * Each time through the loop, remove the first wakeup list entry, and
344  * signal it unless it's our sentinel. Repeat as long as the sentinel
345  * remains in the list.
346  *
347  * Notice that if someone else removes our sentinel, we will waken one
348  * additional process before exiting. That's intentional, because if
349  * someone else signals the CV, they may be intending to waken some
350  * third process that added itself to the list after we added the
351  * sentinel. Better to give a spurious wakeup (which should be
352  * harmless beyond wasting some cycles) than to lose a wakeup.
353  */
354  proc = NULL;
355  SpinLockAcquire(&cv->mutex);
356  if (!proclist_is_empty(&cv->wakeup))
357  proc = proclist_pop_head_node(&cv->wakeup, cvWaitLink);
358  have_sentinel = proclist_contains(&cv->wakeup, pgprocno, cvWaitLink);
359  SpinLockRelease(&cv->mutex);
360 
361  if (proc != NULL && proc != MyProc)
362  SetLatch(&proc->procLatch);
363  }
364 }
proclist_head wakeup
PGPROC * MyProc
Definition: proc.c:68
void SetLatch(Latch *latch)
Definition: latch.c:567
Latch procLatch
Definition: proc.h:130
#define SpinLockAcquire(lock)
Definition: spin.h:62
void ConditionVariableCancelSleep(void)
#define SpinLockRelease(lock)
Definition: spin.h:64
static ConditionVariable * cv_sleep_target
#define proclist_pop_head_node(list, link_member)
Definition: proclist.h:193
#define Assert(condition)
Definition: c.h:804
static bool proclist_is_empty(proclist_head *list)
Definition: proclist.h:38
#define proclist_push_tail(list, procno, link_member)
Definition: proclist.h:191
int pgprocno
Definition: proc.h:150
Definition: proc.h:121
#define proclist_contains(list, procno, link_member)
Definition: proclist.h:195

◆ ConditionVariableCancelSleep()

void ConditionVariableCancelSleep ( void  )

Definition at line 228 of file condition_variable.c.

References ConditionVariableSignal(), cv_sleep_target, ConditionVariable::mutex, MyProc, PGPROC::pgprocno, proclist_contains, proclist_delete, SpinLockAcquire, SpinLockRelease, and ConditionVariable::wakeup.

Referenced by _bt_parallel_heapscan(), _bt_parallel_seize(), AbortSubTransaction(), AbortTransaction(), AuxiliaryProcKill(), BackgroundWriterMain(), BarrierArriveAndWait(), BitmapShouldInitializeSharedState(), CheckpointerMain(), ConditionVariableBroadcast(), ConditionVariablePrepareToSleep(), InvalidateObsoleteReplicationSlots(), ProcKill(), recoveryPausesHere(), RecoveryRequiresIntParameter(), ReplicationSlotAcquireInternal(), replorigin_drop_guts(), RequestCheckpoint(), ShutdownAuxiliaryProcess(), ShutdownWalRcv(), WaitForProcSignalBarrier(), WaitIO(), WalSndErrorCleanup(), and WalWriterMain().

229 {
231  bool signaled = false;
232 
233  if (cv == NULL)
234  return;
235 
236  SpinLockAcquire(&cv->mutex);
237  if (proclist_contains(&cv->wakeup, MyProc->pgprocno, cvWaitLink))
238  proclist_delete(&cv->wakeup, MyProc->pgprocno, cvWaitLink);
239  else
240  signaled = true;
241  SpinLockRelease(&cv->mutex);
242 
243  /*
244  * If we've received a signal, pass it on to another waiting process, if
245  * there is one. Otherwise a call to ConditionVariableSignal() might get
246  * lost, despite there being another process ready to handle it.
247  */
248  if (signaled)
250 
251  cv_sleep_target = NULL;
252 }
proclist_head wakeup
PGPROC * MyProc
Definition: proc.c:68
#define proclist_delete(list, procno, link_member)
Definition: proclist.h:187
#define SpinLockAcquire(lock)
Definition: spin.h:62
void ConditionVariableSignal(ConditionVariable *cv)
#define SpinLockRelease(lock)
Definition: spin.h:64
static ConditionVariable * cv_sleep_target
int pgprocno
Definition: proc.h:150
#define proclist_contains(list, procno, link_member)
Definition: proclist.h:195

◆ ConditionVariableInit()

◆ ConditionVariablePrepareToSleep()

void ConditionVariablePrepareToSleep ( ConditionVariable cv)

Definition at line 58 of file condition_variable.c.

References ConditionVariableCancelSleep(), ConditionVariable::mutex, MyProc, PGPROC::pgprocno, proclist_push_tail, SpinLockAcquire, SpinLockRelease, and ConditionVariable::wakeup.

Referenced by BarrierArriveAndWait(), ConditionVariableTimedSleep(), InvalidateObsoleteReplicationSlots(), ReplicationSlotAcquireInternal(), RequestCheckpoint(), ShutdownWalRcv(), and WaitIO().

59 {
60  int pgprocno = MyProc->pgprocno;
61 
62  /*
63  * If some other sleep is already prepared, cancel it; this is necessary
64  * because we have just one static variable tracking the prepared sleep,
65  * and also only one cvWaitLink in our PGPROC. It's okay to do this
66  * because whenever control does return to the other test-and-sleep loop,
67  * its ConditionVariableSleep call will just re-establish that sleep as
68  * the prepared one.
69  */
70  if (cv_sleep_target != NULL)
72 
73  /* Record the condition variable on which we will sleep. */
74  cv_sleep_target = cv;
75 
76  /* Add myself to the wait queue. */
77  SpinLockAcquire(&cv->mutex);
78  proclist_push_tail(&cv->wakeup, pgprocno, cvWaitLink);
79  SpinLockRelease(&cv->mutex);
80 }
proclist_head wakeup
PGPROC * MyProc
Definition: proc.c:68
#define SpinLockAcquire(lock)
Definition: spin.h:62
void ConditionVariableCancelSleep(void)
#define SpinLockRelease(lock)
Definition: spin.h:64
static ConditionVariable * cv_sleep_target
#define proclist_push_tail(list, procno, link_member)
Definition: proclist.h:191
int pgprocno
Definition: proc.h:150

◆ ConditionVariableSignal()

void ConditionVariableSignal ( ConditionVariable cv)

Definition at line 263 of file condition_variable.c.

References ConditionVariable::mutex, PGPROC::procLatch, proclist_is_empty(), proclist_pop_head_node, SetLatch(), SpinLockAcquire, SpinLockRelease, and ConditionVariable::wakeup.

Referenced by _bt_parallel_release(), _bt_parallel_scan_and_sort(), and ConditionVariableCancelSleep().

264 {
265  PGPROC *proc = NULL;
266 
267  /* Remove the first process from the wakeup queue (if any). */
268  SpinLockAcquire(&cv->mutex);
269  if (!proclist_is_empty(&cv->wakeup))
270  proc = proclist_pop_head_node(&cv->wakeup, cvWaitLink);
271  SpinLockRelease(&cv->mutex);
272 
273  /* If we found someone sleeping, set their latch to wake them up. */
274  if (proc != NULL)
275  SetLatch(&proc->procLatch);
276 }
proclist_head wakeup
void SetLatch(Latch *latch)
Definition: latch.c:567
Latch procLatch
Definition: proc.h:130
#define SpinLockAcquire(lock)
Definition: spin.h:62
#define SpinLockRelease(lock)
Definition: spin.h:64
#define proclist_pop_head_node(list, link_member)
Definition: proclist.h:193
static bool proclist_is_empty(proclist_head *list)
Definition: proclist.h:38
Definition: proc.h:121

◆ ConditionVariableSleep()

void ConditionVariableSleep ( ConditionVariable cv,
uint32  wait_event_info 
)

Definition at line 98 of file condition_variable.c.

References ConditionVariableTimedSleep().

Referenced by _bt_parallel_heapscan(), _bt_parallel_seize(), BarrierArriveAndWait(), BitmapShouldInitializeSharedState(), ReplicationSlotAcquireInternal(), replorigin_drop_guts(), RequestCheckpoint(), ShutdownWalRcv(), WaitForProcSignalBarrier(), and WaitIO().

99 {
100  (void) ConditionVariableTimedSleep(cv, -1 /* no timeout */ ,
101  wait_event_info);
102 }
bool ConditionVariableTimedSleep(ConditionVariable *cv, long timeout, uint32 wait_event_info)

◆ ConditionVariableTimedSleep()

bool ConditionVariableTimedSleep ( ConditionVariable cv,
long  timeout,
uint32  wait_event_info 
)

Definition at line 112 of file condition_variable.c.

References Assert, CHECK_FOR_INTERRUPTS, ConditionVariablePrepareToSleep(), INSTR_TIME_GET_MILLISEC, INSTR_TIME_SET_CURRENT, INSTR_TIME_SUBTRACT, ConditionVariable::mutex, MyLatch, MyProc, PGPROC::pgprocno, proclist_contains, proclist_push_tail, ResetLatch(), SpinLockAcquire, SpinLockRelease, start_time, WaitLatch(), ConditionVariable::wakeup, WL_EXIT_ON_PM_DEATH, WL_LATCH_SET, and WL_TIMEOUT.

Referenced by ConditionVariableSleep(), InvalidateObsoleteReplicationSlots(), recoveryPausesHere(), and RecoveryRequiresIntParameter().

114 {
115  long cur_timeout = -1;
117  instr_time cur_time;
118  int wait_events;
119 
120  /*
121  * If the caller didn't prepare to sleep explicitly, then do so now and
122  * return immediately. The caller's predicate loop should immediately
123  * call again if its exit condition is not yet met. This will result in
124  * the exit condition being tested twice before we first sleep. The extra
125  * test can be prevented by calling ConditionVariablePrepareToSleep(cv)
126  * first. Whether it's worth doing that depends on whether you expect the
127  * exit condition to be met initially, in which case skipping the prepare
128  * is recommended because it avoids manipulations of the wait list, or not
129  * met initially, in which case preparing first is better because it
130  * avoids one extra test of the exit condition.
131  *
132  * If we are currently prepared to sleep on some other CV, we just cancel
133  * that and prepare this one; see ConditionVariablePrepareToSleep.
134  */
135  if (cv_sleep_target != cv)
136  {
138  return false;
139  }
140 
141  /*
142  * Record the current time so that we can calculate the remaining timeout
143  * if we are woken up spuriously.
144  */
145  if (timeout >= 0)
146  {
147  INSTR_TIME_SET_CURRENT(start_time);
148  Assert(timeout >= 0 && timeout <= INT_MAX);
149  cur_timeout = timeout;
150  wait_events = WL_LATCH_SET | WL_TIMEOUT | WL_EXIT_ON_PM_DEATH;
151  }
152  else
153  wait_events = WL_LATCH_SET | WL_EXIT_ON_PM_DEATH;
154 
155  while (true)
156  {
157  bool done = false;
158 
159  /*
160  * Wait for latch to be set. (If we're awakened for some other
161  * reason, the code below will cope anyway.)
162  */
163  (void) WaitLatch(MyLatch, wait_events, cur_timeout, wait_event_info);
164 
165  /* Reset latch before examining the state of the wait list. */
167 
168  /*
169  * If this process has been taken out of the wait list, then we know
170  * that it has been signaled by ConditionVariableSignal (or
171  * ConditionVariableBroadcast), so we should return to the caller. But
172  * that doesn't guarantee that the exit condition is met, only that we
173  * ought to check it. So we must put the process back into the wait
174  * list, to ensure we don't miss any additional wakeup occurring while
175  * the caller checks its exit condition. We can take ourselves out of
176  * the wait list only when the caller calls
177  * ConditionVariableCancelSleep.
178  *
179  * If we're still in the wait list, then the latch must have been set
180  * by something other than ConditionVariableSignal; though we don't
181  * guarantee not to return spuriously, we'll avoid this obvious case.
182  */
183  SpinLockAcquire(&cv->mutex);
184  if (!proclist_contains(&cv->wakeup, MyProc->pgprocno, cvWaitLink))
185  {
186  done = true;
187  proclist_push_tail(&cv->wakeup, MyProc->pgprocno, cvWaitLink);
188  }
189  SpinLockRelease(&cv->mutex);
190 
191  /*
192  * Check for interrupts, and return spuriously if that caused the
193  * current sleep target to change (meaning that interrupt handler code
194  * waited for a different condition variable).
195  */
197  if (cv != cv_sleep_target)
198  done = true;
199 
200  /* We were signaled, so return */
201  if (done)
202  return false;
203 
204  /* If we're not done, update cur_timeout for next iteration */
205  if (timeout >= 0)
206  {
207  INSTR_TIME_SET_CURRENT(cur_time);
208  INSTR_TIME_SUBTRACT(cur_time, start_time);
209  cur_timeout = timeout - (long) INSTR_TIME_GET_MILLISEC(cur_time);
210 
211  /* Have we crossed the timeout threshold? */
212  if (cur_timeout <= 0)
213  return true;
214  }
215  }
216 }
#define WL_TIMEOUT
Definition: latch.h:128
proclist_head wakeup
PGPROC * MyProc
Definition: proc.c:68
#define INSTR_TIME_GET_MILLISEC(t)
Definition: instr_time.h:202
struct timeval instr_time
Definition: instr_time.h:150
void ResetLatch(Latch *latch)
Definition: latch.c:660
static time_t start_time
Definition: pg_ctl.c:99
int WaitLatch(Latch *latch, int wakeEvents, long timeout, uint32 wait_event_info)
Definition: latch.c:452
void ConditionVariablePrepareToSleep(ConditionVariable *cv)
#define SpinLockAcquire(lock)
Definition: spin.h:62
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:170
#define SpinLockRelease(lock)
Definition: spin.h:64
static ConditionVariable * cv_sleep_target
#define Assert(condition)
Definition: c.h:804
#define proclist_push_tail(list, procno, link_member)
Definition: proclist.h:191
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:156
int pgprocno
Definition: proc.h:150
struct Latch * MyLatch
Definition: globals.c:57
#define CHECK_FOR_INTERRUPTS()
Definition: miscadmin.h:102
#define WL_LATCH_SET
Definition: latch.h:125
#define WL_EXIT_ON_PM_DEATH
Definition: latch.h:130
#define proclist_contains(list, procno, link_member)
Definition: proclist.h:195