/*
* Atomically decrements the pincount on a given entry.
* Returns the value of the pincount after the decrement.
*/
static int32
SyncHTDecRef(SyncHT *syncHT, void *entry)
{
int32 *pinCountPtr = (int32 *) ((char *) entry + syncHT->pinCountOffset);
pg_atomic_sub_fetch_u32((pg_atomic_uint32 *)pinCountPtr,1);
return *pinCountPtr;
}
/**
* This method is used by a backend to switch the group leader. It is unique
* in that it modifies the numFollowers field in its current group leader and new leader index.
* The increments and decrements are done using atomic operations (else we may have race conditions
* across processes). However, this code is not thread safe. We do not call these code in multi-threaded
* situations.
*/
static inline void
SwitchGroupLeader(int newLeaderIndex)
{
BackoffBackendSharedEntry *myEntry = myBackoffSharedEntry();
BackoffBackendSharedEntry *oldLeaderEntry = NULL;
BackoffBackendSharedEntry *newLeaderEntry = NULL;
if (backoffSingleton->sweeperInProgress == true)
return;
Assert(newLeaderIndex < myEntry->groupLeaderIndex);
Assert(newLeaderIndex >= 0 && newLeaderIndex < backoffSingleton->numEntries);
oldLeaderEntry = &backoffSingleton->backendEntries[myEntry->groupLeaderIndex];
newLeaderEntry = &backoffSingleton->backendEntries[newLeaderIndex];
pg_atomic_sub_fetch_u32((pg_atomic_uint32 *) &oldLeaderEntry->numFollowers, 1);
pg_atomic_add_fetch_u32((pg_atomic_uint32 *) &newLeaderEntry->numFollowers, 1);
myEntry->groupLeaderIndex = newLeaderIndex;
}
static void
test_atomic_uint32(void)
{
pg_atomic_uint32 var;
uint32 expected;
int i;
pg_atomic_init_u32(&var, 0);
if (pg_atomic_read_u32(&var) != 0)
elog(ERROR, "atomic_read_u32() #1 wrong");
pg_atomic_write_u32(&var, 3);
if (pg_atomic_read_u32(&var) != 3)
elog(ERROR, "atomic_read_u32() #2 wrong");
if (pg_atomic_fetch_add_u32(&var, 1) != 3)
elog(ERROR, "atomic_fetch_add_u32() #1 wrong");
if (pg_atomic_fetch_sub_u32(&var, 1) != 4)
elog(ERROR, "atomic_fetch_sub_u32() #1 wrong");
if (pg_atomic_sub_fetch_u32(&var, 3) != 0)
elog(ERROR, "atomic_sub_fetch_u32() #1 wrong");
if (pg_atomic_add_fetch_u32(&var, 10) != 10)
elog(ERROR, "atomic_add_fetch_u32() #1 wrong");
if (pg_atomic_exchange_u32(&var, 5) != 10)
elog(ERROR, "pg_atomic_exchange_u32() #1 wrong");
if (pg_atomic_exchange_u32(&var, 0) != 5)
elog(ERROR, "pg_atomic_exchange_u32() #0 wrong");
/* test around numerical limits */
if (pg_atomic_fetch_add_u32(&var, INT_MAX) != 0)
elog(ERROR, "pg_atomic_fetch_add_u32() #2 wrong");
if (pg_atomic_fetch_add_u32(&var, INT_MAX) != INT_MAX)
elog(ERROR, "pg_atomic_add_fetch_u32() #3 wrong");
pg_atomic_fetch_add_u32(&var, 1); /* top up to UINT_MAX */
if (pg_atomic_read_u32(&var) != UINT_MAX)
elog(ERROR, "atomic_read_u32() #2 wrong");
if (pg_atomic_fetch_sub_u32(&var, INT_MAX) != UINT_MAX)
elog(ERROR, "pg_atomic_fetch_sub_u32() #2 wrong");
if (pg_atomic_read_u32(&var) != (uint32) INT_MAX + 1)
elog(ERROR, "atomic_read_u32() #3 wrong: %u", pg_atomic_read_u32(&var));
expected = pg_atomic_sub_fetch_u32(&var, INT_MAX);
if (expected != 1)
elog(ERROR, "pg_atomic_sub_fetch_u32() #3 wrong: %u", expected);
pg_atomic_sub_fetch_u32(&var, 1);
/* fail exchange because of old expected */
expected = 10;
if (pg_atomic_compare_exchange_u32(&var, &expected, 1))
elog(ERROR, "atomic_compare_exchange_u32() changed value spuriously");
/* CAS is allowed to fail due to interrupts, try a couple of times */
for (i = 0; i < 1000; i++)
{
expected = 0;
if (!pg_atomic_compare_exchange_u32(&var, &expected, 1))
break;
}
if (i == 1000)
elog(ERROR, "atomic_compare_exchange_u32() never succeeded");
if (pg_atomic_read_u32(&var) != 1)
elog(ERROR, "atomic_compare_exchange_u32() didn't set value properly");
pg_atomic_write_u32(&var, 0);
/* try setting flagbits */
if (pg_atomic_fetch_or_u32(&var, 1) & 1)
elog(ERROR, "pg_atomic_fetch_or_u32() #1 wrong");
if (!(pg_atomic_fetch_or_u32(&var, 2) & 1))
elog(ERROR, "pg_atomic_fetch_or_u32() #2 wrong");
if (pg_atomic_read_u32(&var) != 3)
elog(ERROR, "invalid result after pg_atomic_fetch_or_u32()");
/* try clearing flagbits */
if ((pg_atomic_fetch_and_u32(&var, ~2) & 3) != 3)
elog(ERROR, "pg_atomic_fetch_and_u32() #1 wrong");
if (pg_atomic_fetch_and_u32(&var, ~1) != 1)
elog(ERROR, "pg_atomic_fetch_and_u32() #2 wrong: is %u",
pg_atomic_read_u32(&var));
/* no bits set anymore */
if (pg_atomic_fetch_and_u32(&var, ~0) != 0)
elog(ERROR, "pg_atomic_fetch_and_u32() #3 wrong");
}
/*
* Cleanup routine for the dispatching thread. This will indicate the thread
* is not running any longer.
*/
static void
DecrementRunningCount(void *arg)
{
pg_atomic_sub_fetch_u32((pg_atomic_uint32 *) &RunningThreadCount, 1);
}
/*
* Atomically decrements the performance counter
*
* delta must be positive
*/
void
Cache_DecPerfCounter(uint32 *counter, int delta)
{
Assert(counter - delta >= 0);
pg_atomic_sub_fetch_u32((pg_atomic_uint32 *) counter,delta);
}
/*
* Releases the pinCount of a SessionState entry. If the pinCount
* drops to 0, it puts the entry back to the freeList for reuse.
*/
static void
SessionState_Release(SessionState *acquired)
{
if (!sessionStateInited)
{
Assert(NULL == acquired);
return;
}
Assert(NULL != acquired);
Assert(0 < acquired->pinCount);
Assert(acquired->sessionId == gp_session_id || acquired->isModifiedSessionId);
LWLockAcquire(SessionStateLock, LW_EXCLUSIVE);
Assert(!isProcessActive);
Assert(acquired->activeProcessCount < acquired->pinCount);
int pinCount = pg_atomic_sub_fetch_u32((pg_atomic_uint32 *) &acquired->pinCount, 1);
ereport(gp_sessionstate_loglevel, (errmsg("SessionState_Release: pinCount: %d, activeProcessCount: %d",
pinCount, acquired->activeProcessCount), errprintstack(true)));
/* Before this point the process should have been deactivated */
Assert(acquired->activeProcessCount <= acquired->pinCount);
Assert(0 <= acquired->pinCount);
if (0 == acquired->pinCount)
{
RunawayCleaner_RunawayCleanupDoneForSession();
acquired->sessionId = INVALID_SESSION_ID;
Assert(acquired->runawayStatus == RunawayStatus_NotRunaway);
Assert(CLEANUP_COUNTDOWN_BEFORE_RUNAWAY == acquired->cleanupCountdown);
Assert(0 == acquired->activeProcessCount);
acquired->sessionVmem = 0;
acquired->runawayStatus = RunawayStatus_NotRunaway;
acquired->sessionVmemRunaway = 0;
acquired->commandCountRunaway = 0;
acquired->cleanupCountdown = CLEANUP_COUNTDOWN_BEFORE_RUNAWAY;
acquired->activeProcessCount = 0;
acquired->idle_start = 0;
acquired->resGroupSlot = NULL;
#ifdef USE_ASSERT_CHECKING
acquired->isModifiedSessionId = false;
#endif
SessionState *cur = AllSessionStateEntries->usedList;
SessionState *prev = NULL;
while (cur != acquired && cur != NULL)
{
prev = cur;
cur = cur->next;
}
Assert(cur == acquired);
/* grabbed is at the head of used list */
if (NULL == prev)
{
Assert(AllSessionStateEntries->usedList == acquired);
AllSessionStateEntries->usedList = acquired->next;
}
else
{
prev->next = cur->next;
}
acquired->next = AllSessionStateEntries->freeList;
AllSessionStateEntries->freeList = acquired;
AllSessionStateEntries->numSession--;
Assert(AllSessionStateEntries->numSession >= 0);
}
LWLockRelease(SessionStateLock);
}
