#include "postgres.h"
#include "storage/barrier.h"

Include dependency graph for barrier.c:

Functions
static bool	BarrierDetachImpl (Barrier *barrier, bool arrive)

void	BarrierInit (Barrier *barrier, int participants)

bool	BarrierArriveAndWait (Barrier *barrier, uint32 wait_event_info)

bool	BarrierArriveAndDetach (Barrier *barrier)

bool	BarrierArriveAndDetachExceptLast (Barrier *barrier)

int	BarrierAttach (Barrier *barrier)

bool	BarrierDetach (Barrier *barrier)

int	BarrierPhase (Barrier *barrier)

int	BarrierParticipants (Barrier *barrier)

Function Documentation

◆ BarrierArriveAndDetach()

bool BarrierArriveAndDetach ( Barrier * barrier )

Definition at line 203 of file barrier.c.

 {
     return BarrierDetachImpl(barrier, true);
 }

References barrier, and BarrierDetachImpl().

Referenced by ExecHashTableDetach(), and ExecHashTableDetachBatch().

◆ BarrierArriveAndDetachExceptLast()

bool BarrierArriveAndDetachExceptLast ( Barrier * barrier )

Definition at line 213 of file barrier.c.

 {
     SpinLockAcquire(&barrier->mutex);
     if (barrier->participants > 1)
     {
         --barrier->participants;
         SpinLockRelease(&barrier->mutex);
  
         return false;
     }
     Assert(barrier->participants == 1);
     ++barrier->phase;
     SpinLockRelease(&barrier->mutex);
  
     return true;
 }

References Assert, barrier, SpinLockAcquire, and SpinLockRelease.

Referenced by ExecHashTableDetachBatch(), and ExecParallelPrepHashTableForUnmatched().

◆ BarrierArriveAndWait()

bool BarrierArriveAndWait	(	Barrier *	barrier,
		uint32	wait_event_info
	)

Definition at line 125 of file barrier.c.

 {
     bool        release = false;
     bool        elected;
     int         start_phase;
     int         next_phase;
  
     SpinLockAcquire(&barrier->mutex);
     start_phase = barrier->phase;
     next_phase = start_phase + 1;
     ++barrier->arrived;
     if (barrier->arrived == barrier->participants)
     {
         release = true;
         barrier->arrived = 0;
         barrier->phase = next_phase;
         barrier->elected = next_phase;
     }
     SpinLockRelease(&barrier->mutex);
  
     /*
      * If we were the last expected participant to arrive, we can release our
      * peers and return true to indicate that this backend has been elected to
      * perform any serial work.
      */
     if (release)
     {
         ConditionVariableBroadcast(&barrier->condition_variable);
  
         return true;
     }
  
     /*
      * Otherwise we have to wait for the last participant to arrive and
      * advance the phase.
      */
     elected = false;
     ConditionVariablePrepareToSleep(&barrier->condition_variable);
     for (;;)
     {
         /*
          * We know that phase must either be start_phase, indicating that we
          * need to keep waiting, or next_phase, indicating that the last
          * participant that we were waiting for has either arrived or detached
          * so that the next phase has begun.  The phase cannot advance any
          * further than that without this backend's participation, because
          * this backend is attached.
          */
         SpinLockAcquire(&barrier->mutex);
         Assert(barrier->phase == start_phase || barrier->phase == next_phase);
         release = barrier->phase == next_phase;
         if (release && barrier->elected != next_phase)
         {
             /*
              * Usually the backend that arrives last and releases the other
              * backends is elected to return true (see above), so that it can
              * begin processing serial work while it has a CPU timeslice.
              * However, if the barrier advanced because someone detached, then
              * one of the backends that is awoken will need to be elected.
              */
             barrier->elected = barrier->phase;
             elected = true;
         }
         SpinLockRelease(&barrier->mutex);
         if (release)
             break;
         ConditionVariableSleep(&barrier->condition_variable, wait_event_info);
     }
     ConditionVariableCancelSleep();
  
     return elected;
 }

References Assert, barrier, ConditionVariableBroadcast(), ConditionVariableCancelSleep(), ConditionVariablePrepareToSleep(), ConditionVariableSleep(), SpinLockAcquire, and SpinLockRelease.

Referenced by ExecHashJoinImpl(), ExecHashTableCreate(), ExecParallelHashIncreaseNumBatches(), ExecParallelHashIncreaseNumBuckets(), ExecParallelHashJoinNewBatch(), ExecParallelHashJoinSetUpBatches(), and MultiExecParallelHash().

◆ BarrierAttach()

int BarrierAttach ( Barrier * barrier )

Definition at line 236 of file barrier.c.

 {
     int         phase;
  
     Assert(!barrier->static_party);
  
     SpinLockAcquire(&barrier->mutex);
     ++barrier->participants;
     phase = barrier->phase;
     SpinLockRelease(&barrier->mutex);
  
     return phase;
 }

References Assert, barrier, SpinLockAcquire, and SpinLockRelease.

Referenced by ExecHashTableCreate(), ExecParallelHashJoinNewBatch(), ExecParallelHashJoinSetUpBatches(), and MultiExecParallelHash().

◆ BarrierDetach()

bool BarrierDetach ( Barrier * barrier )

Definition at line 256 of file barrier.c.

 {
     return BarrierDetachImpl(barrier, false);
 }

References barrier, and BarrierDetachImpl().

Referenced by ExecParallelHashJoinNewBatch(), ExecParallelHashJoinSetUpBatches(), and MultiExecParallelHash().

◆ BarrierDetachImpl()

static bool BarrierDetachImpl	(	Barrier *	barrier,
		bool	arrive
	)

inlinestatic

Definition at line 300 of file barrier.c.

 {
     bool        release;
     bool        last;
  
     Assert(!barrier->static_party);
  
     SpinLockAcquire(&barrier->mutex);
     Assert(barrier->participants > 0);
     --barrier->participants;
  
     /*
      * If any other participants are waiting and we were the last participant
      * waited for, release them.  If no other participants are waiting, but
      * this is a BarrierArriveAndDetach() call, then advance the phase too.
      */
     if ((arrive || barrier->participants > 0) &&
         barrier->arrived == barrier->participants)
     {
         release = true;
         barrier->arrived = 0;
         ++barrier->phase;
     }
     else
         release = false;
  
     last = barrier->participants == 0;
     SpinLockRelease(&barrier->mutex);
  
     if (release)
         ConditionVariableBroadcast(&barrier->condition_variable);
  
     return last;
 }

References Assert, barrier, ConditionVariableBroadcast(), SpinLockAcquire, and SpinLockRelease.

Referenced by BarrierArriveAndDetach(), and BarrierDetach().

◆ BarrierInit()

void BarrierInit	(	Barrier *	barrier,
		int	participants
	)

Definition at line 100 of file barrier.c.

 {
     SpinLockInit(&barrier->mutex);
     barrier->participants = participants;
     barrier->arrived = 0;
     barrier->phase = 0;
     barrier->elected = 0;
     barrier->static_party = participants > 0;
     ConditionVariableInit(&barrier->condition_variable);
 }

References barrier, ConditionVariableInit(), and SpinLockInit.

Referenced by ExecHashJoinInitializeDSM(), ExecHashJoinReInitializeDSM(), and ExecParallelHashJoinSetUpBatches().

◆ BarrierParticipants()

int BarrierParticipants ( Barrier * barrier )

Definition at line 281 of file barrier.c.

 {
     int         participants;
  
     SpinLockAcquire(&barrier->mutex);
     participants = barrier->participants;
     SpinLockRelease(&barrier->mutex);
  
     return participants;
 }

References barrier, SpinLockAcquire, and SpinLockRelease.

◆ BarrierPhase()

int BarrierPhase ( Barrier * barrier )

Definition at line 265 of file barrier.c.

 {
     /*
      * It is OK to read barrier->phase without locking, because it can't
      * change without us (we are attached to it), and we executed a memory
      * barrier when we either attached or participated in changing it last
      * time.
      */
     return barrier->phase;
 }

References barrier.

Referenced by ExecHashJoinImpl(), ExecHashTableCreate(), ExecHashTableDetach(), ExecHashTableDetachBatch(), ExecParallelHashIncreaseNumBatches(), ExecParallelHashIncreaseNumBuckets(), ExecParallelHashJoinNewBatch(), ExecParallelHashJoinSetUpBatches(), ExecParallelHashTableInsert(), ExecParallelHashTupleAlloc(), ExecParallelPrepHashTableForUnmatched(), and MultiExecParallelHash().

Functions