/*
* Arrive at this barrier, wait for all other attached participants to arrive
* too and then return. Increments the current phase. The caller must be
* attached.
*
* While waiting, pg_stat_activity shows a wait_event_class and wait_event
* controlled by the wait_event_info passed in, which should be a value from
* one of the WaitEventXXX enums defined in pgstat.h.
*
* Return true in one arbitrarily chosen participant. Return false in all
* others. The return code can be used to elect one participant to execute a
* phase of work that must be done serially while other participants wait.
*/
bool
BarrierArriveAndWait(Barrier *barrier, uint32 wait_event_info)
{
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;
}
/*
* Find a previously created slot and mark it as used by this backend.
*/
void
ReplicationSlotAcquire(const char *name, bool nowait)
{
ReplicationSlot *slot;
int active_pid;
int i;
retry:
Assert(MyReplicationSlot == NULL);
/*
* Search for the named slot and mark it active if we find it. If the
* slot is already active, we exit the loop with active_pid set to the PID
* of the backend that owns it.
*/
active_pid = 0;
slot = NULL;
LWLockAcquire(ReplicationSlotControlLock, LW_SHARED);
for (i = 0; i < max_replication_slots; i++)
{
ReplicationSlot *s = &ReplicationSlotCtl->replication_slots[i];
if (s->in_use && strcmp(name, NameStr(s->data.name)) == 0)
{
/*
* This is the slot we want. We don't know yet if it's active, so
* get ready to sleep on it in case it is. (We may end up not
* sleeping, but we don't want to do this while holding the
* spinlock.)
*/
ConditionVariablePrepareToSleep(&s->active_cv);
SpinLockAcquire(&s->mutex);
active_pid = s->active_pid;
if (active_pid == 0)
active_pid = s->active_pid = MyProcPid;
SpinLockRelease(&s->mutex);
slot = s;
break;
}
}
LWLockRelease(ReplicationSlotControlLock);
/* If we did not find the slot, error out. */
if (slot == NULL)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("replication slot \"%s\" does not exist", name)));
/*
* If we found the slot but it's already active in another backend, we
* either error out or retry after a short wait, as caller specified.
*/
if (active_pid != MyProcPid)
{
if (nowait)
ereport(ERROR,
(errcode(ERRCODE_OBJECT_IN_USE),
errmsg("replication slot \"%s\" is active for PID %d",
name, active_pid)));
/* Wait here until we get signaled, and then restart */
ConditionVariableSleep(&slot->active_cv,
WAIT_EVENT_REPLICATION_SLOT_DROP);
ConditionVariableCancelSleep();
goto retry;
}
else
ConditionVariableCancelSleep(); /* no sleep needed after all */
/* Let everybody know we've modified this slot */
ConditionVariableBroadcast(&slot->active_cv);
/* We made this slot active, so it's ours now. */
MyReplicationSlot = slot;
}
/*
* Wait for the given condition variable to be signaled.
*
* This should be called in a predicate loop that tests for a specific exit
* condition and otherwise sleeps, like so:
*
* ConditionVariablePrepareToSleep(cv); // optional
* while (condition for which we are waiting is not true)
* ConditionVariableSleep(cv, wait_event_info);
* ConditionVariableCancelSleep();
*
* wait_event_info should be a value from one of the WaitEventXXX enums
* defined in pgstat.h. This controls the contents of pg_stat_activity's
* wait_event_type and wait_event columns while waiting.
*/
void
ConditionVariableSleep(ConditionVariable *cv, uint32 wait_event_info)
{
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 will result in
* the exit condition being tested twice before we first sleep. The extra
* test can be prevented by calling ConditionVariablePrepareToSleep(cv)
* first. Whether it's worth doing that depends on whether you expect the
* exit condition to be met initially, in which case skipping the prepare
* is recommended because it avoids manipulations of the wait list, or not
* met initially, in which case preparing first is better because it
* avoids one extra test of the exit condition.
*
* If we are currently prepared to sleep on some other CV, we just cancel
* that and prepare this one; see ConditionVariablePrepareToSleep.
*/
if (cv_sleep_target != cv)
{
ConditionVariablePrepareToSleep(cv);
return;
}
do
{
CHECK_FOR_INTERRUPTS();
/*
* Wait for latch to be set. (If we're awakened for some other
* reason, the code below will cope anyway.)
*/
(void) WaitEventSetWait(cv_wait_event_set, -1, &event, 1,
wait_event_info);
/* Reset latch before examining the state of the wait list. */
ResetLatch(MyLatch);
/*
* If this process has been taken out of the wait list, then we know
* that it has been signaled by ConditionVariableSignal (or
* ConditionVariableBroadcast), so we should return to the caller. But
* that doesn't guarantee that the exit condition is met, only that we
* ought to check it. So we must put the process back into the wait
* list, to ensure we don't miss any additional wakeup occurring while
* the caller checks its exit condition. We can take ourselves out of
* the wait list only when the caller calls
* ConditionVariableCancelSleep.
*
* If we're still in 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 this obvious case.
*/
SpinLockAcquire(&cv->mutex);
if (!proclist_contains(&cv->wakeup, MyProc->pgprocno, cvWaitLink))
{
done = true;
proclist_push_tail(&cv->wakeup, MyProc->pgprocno, cvWaitLink);
}
SpinLockRelease(&cv->mutex);
} while (!done);
}
