barrier.h File Reference

#include "storage/condition_variable.h"
#include "storage/spin.h"

Include dependency graph for barrier.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	Barrier

Typedefs
typedef struct Barrier	Barrier

Functions
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)

Typedef Documentation

Barrier

typedef struct 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().

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().