#include "postgres.h"
#include "miscadmin.h"
#include "storage/condition_variable.h"
#include "storage/ipc.h"
#include "storage/proc.h"
#include "storage/proclist.h"
#include "storage/spin.h"
#include "utils/memutils.h"

Include dependency graph for condition_variable.c:

Functions
void	ConditionVariableInit (ConditionVariable *cv)

void	ConditionVariablePrepareToSleep (ConditionVariable *cv)

void	ConditionVariableSleep (ConditionVariable *cv, uint32 wait_event_info)

void	ConditionVariableCancelSleep (void)

bool	ConditionVariableSignal (ConditionVariable *cv)

int	ConditionVariableBroadcast (ConditionVariable *cv)

Variables
static ConditionVariable *	cv_sleep_target = NULL

static WaitEventSet *	cv_wait_event_set = NULL

Function Documentation

int ConditionVariableBroadcast ( ConditionVariable * cv )

Definition at line 214 of file condition_variable.c.

References ConditionVariableSignal().

Referenced by _bt_parallel_done(), and BitmapDoneInitializingSharedState().

 {
     int         nwoken = 0;
 
     /*
      * Let's just do this the dumbest way possible.  We could try to dequeue
      * all the sleepers at once to save spinlock cycles, but it's a bit hard
      * to get that right in the face of possible sleep cancelations, and we
      * don't want to loop holding the mutex.
      */
     while (ConditionVariableSignal(cv))
         ++nwoken;
 
     return nwoken;
 }

void ConditionVariableCancelSleep ( void )

Definition at line 166 of file condition_variable.c.

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

Referenced by _bt_parallel_seize(), AbortTransaction(), AuxiliaryProcKill(), BackgroundWriterMain(), BitmapShouldInitializeSharedState(), CheckpointerMain(), ProcKill(), ShutdownAuxiliaryProcess(), WalSndErrorCleanup(), and WalWriterMain().

 {
     ConditionVariable *cv = cv_sleep_target;
 
     if (cv == NULL)
         return;
 
     SpinLockAcquire(&cv->mutex);
     if (proclist_contains(&cv->wakeup, MyProc->pgprocno, cvWaitLink))
         proclist_delete(&cv->wakeup, MyProc->pgprocno, cvWaitLink);
     SpinLockRelease(&cv->mutex);
 
     cv_sleep_target = NULL;
 }

void ConditionVariableInit ( ConditionVariable * cv )

Definition at line 39 of file condition_variable.c.

References ConditionVariable::mutex, proclist_init(), SpinLockInit, and ConditionVariable::wakeup.

Referenced by btinitparallelscan(), and ExecBitmapHeapInitializeDSM().

 {
     SpinLockInit(&cv->mutex);
     proclist_init(&cv->wakeup);
 }

void ConditionVariablePrepareToSleep ( ConditionVariable * cv )

Definition at line 53 of file condition_variable.c.

References AddWaitEventToSet(), Assert, CreateWaitEventSet(), ConditionVariable::mutex, MyLatch, MyProc, NULL, PGINVALID_SOCKET, PGPROC::pgprocno, proclist_contains, proclist_push_tail, ResetLatch(), SpinLockAcquire, SpinLockRelease, TopMemoryContext, ConditionVariable::wakeup, and WL_LATCH_SET.

Referenced by ConditionVariableSleep().

 {
     int         pgprocno = MyProc->pgprocno;
 
     /*
      * It's not legal to prepare a sleep until the previous sleep has been
      * completed or canceled.
      */
     Assert(cv_sleep_target == NULL);
 
     /* Record the condition variable on which we will sleep. */
     cv_sleep_target = cv;
 
     /* Create a reusable WaitEventSet. */
     if (cv_wait_event_set == NULL)
     {
         cv_wait_event_set = CreateWaitEventSet(TopMemoryContext, 1);
         AddWaitEventToSet(cv_wait_event_set, WL_LATCH_SET, PGINVALID_SOCKET,
                           MyLatch, NULL);
     }
 
     /*
      * Reset my latch before adding myself to the queue and before entering
      * the caller's predicate loop.
      */
     ResetLatch(MyLatch);
 
     /* Add myself to the wait queue. */
     SpinLockAcquire(&cv->mutex);
     if (!proclist_contains(&cv->wakeup, pgprocno, cvWaitLink))
         proclist_push_tail(&cv->wakeup, pgprocno, cvWaitLink);
     SpinLockRelease(&cv->mutex);
 }

bool ConditionVariableSignal ( ConditionVariable * cv )

Definition at line 187 of file condition_variable.c.

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

Referenced by _bt_parallel_release(), and ConditionVariableBroadcast().

 {
     PGPROC     *proc = NULL;
 
     /* Remove the first process from the wakeup queue (if any). */
     SpinLockAcquire(&cv->mutex);
     if (!proclist_is_empty(&cv->wakeup))
         proc = proclist_pop_head_node(&cv->wakeup, cvWaitLink);
     SpinLockRelease(&cv->mutex);
 
     /* If we found someone sleeping, set their latch to wake them up. */
     if (proc != NULL)
     {
         SetLatch(&proc->procLatch);
         return true;
     }
 
     /* No sleeping processes. */
     return false;
 }

void ConditionVariableSleep	(	ConditionVariable *	cv,
		uint32	wait_event_info
	)

Definition at line 102 of file condition_variable.c.

References Assert, CHECK_FOR_INTERRUPTS, ConditionVariablePrepareToSleep(), ConditionVariable::mutex, MyLatch, MyProc, NULL, PGPROC::pgprocno, proclist_contains, proclist_push_tail, ResetLatch(), SpinLockAcquire, SpinLockRelease, WaitEventSetWait(), and ConditionVariable::wakeup.

Referenced by _bt_parallel_seize(), and BitmapShouldInitializeSharedState().

 {
     WaitEvent   event;
     bool        done = false;
 
     /*
      * If the caller didn't prepare to sleep explicitly, then do so now and
      * return immediately.  The caller's predicate loop should immediately
      * call again if its exit condition is not yet met.  This initial spurious
      * return can be avoided by calling ConditionVariablePrepareToSleep(cv)
      * first.  Whether it's worth doing that depends on whether you expect the
      * condition to be met initially, in which case skipping the prepare
      * allows you to skip manipulation of the wait list, or not met initially,
      * in which case preparing first allows you to skip a spurious test of the
      * caller's exit condition.
      */
     if (cv_sleep_target == NULL)
     {
         ConditionVariablePrepareToSleep(cv);
         return;
     }
 
     /* Any earlier condition variable sleep must have been canceled. */
     Assert(cv_sleep_target == cv);
 
     while (!done)
     {
         CHECK_FOR_INTERRUPTS();
 
         /*
          * Wait for latch to be set.  We don't care about the result because
          * our contract permits spurious returns.
          */
         WaitEventSetWait(cv_wait_event_set, -1, &event, 1, wait_event_info);
 
         /* Reset latch before testing whether we can return. */
         ResetLatch(MyLatch);
 
         /*
          * If this process has been taken out of the wait list, then we know
          * that is has been signaled by ConditionVariableSignal.  We put it
          * back into the wait list, so we don't miss any further signals while
          * the caller's loop checks its condition.  If it hasn't been taken
          * out of the wait list, then the latch must have been set by
          * something other than ConditionVariableSignal; though we don't
          * guarantee not to return spuriously, we'll avoid these obvious
          * cases.
          */
         SpinLockAcquire(&cv->mutex);
         if (!proclist_contains(&cv->wakeup, MyProc->pgprocno, cvWaitLink))
         {
             done = true;
             proclist_push_tail(&cv->wakeup, MyProc->pgprocno, cvWaitLink);
         }
         SpinLockRelease(&cv->mutex);
     }
 }

Variable Documentation

ConditionVariable* cv_sleep_target = NULL

static

Definition at line 30 of file condition_variable.c.

Referenced by ConditionVariableCancelSleep().

WaitEventSet* cv_wait_event_set = NULL

static

Definition at line 33 of file condition_variable.c.

Functions

Variables

Function Documentation

Variable Documentation