/*
* Acquires a SessionState entry for the specified sessionid. If an existing entry
* is found, this method reuses that entry
*/
static SessionState*
AcquireSessionState(int sessionId, int vmem, int activeProcessCount)
{
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, l, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, l, 1);
/* Keep the assertions happy */
gp_session_id = sessionId;
sessionStateInited = false;
MySessionState = NULL;
EXPECT_EREPORT(gp_sessionstate_loglevel);
SessionState_Init();
if (vmem >= 0)
{
MySessionState->sessionVmem = vmem;
}
if (activeProcessCount >= 0)
{
MySessionState->activeProcessCount = activeProcessCount;
}
return MySessionState;
}
/*
* Checks if RedZoneHandler_FlagTopConsumer() updates the CurrentVersion and
* latestRunawayVersion
*/
void
test__RedZoneHandler_FlagTopConsumer__UpdatesEventVersions(void **state)
{
/* Make sure the RedZoneHandler_FlagTopConsumer code is exercised */
vmemTrackerInited = true;
CreateSessionStateArray(1);
/* Make sure MySessionState is valid */
SessionState *one = AcquireSessionState(1 /* sessionId */, 100 /* vmem */, 1 /* activeProcessCount */);
/* Ensure we can detect runaway sessions */
*isRunawayDetector = 0;
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, l, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, l, 1);
static EventVersion fakeLatestRunawayVersion = 0;
static EventVersion fakeCurrentVersion = 1;
latestRunawayVersion = &fakeLatestRunawayVersion;
CurrentVersion = &fakeCurrentVersion;
RedZoneHandler_FlagTopConsumer();
assert_true(one->runawayStatus == RunawayStatus_PrimaryRunawaySession);
/* Verify that the event versions were properly updated */
assert_true(*CurrentVersion == 3 && *latestRunawayVersion == 2);
DestroySessionStateArray();
}
/*
* Acquires a SessionState entry for the specified sessionid. If an existing entry
* is found, this method reuses that entry
*/
static SessionState*
AcquireSessionState(int sessionId, int loglevel)
{
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, lockid, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, lockid, 1);
/* Keep the assertions happy */
gp_session_id = sessionId;
sessionStateInited = false;
MySessionState = NULL;
EXPECT_EREPORT(loglevel);
SessionState_Init();
return MySessionState;
}
/* Releases a SessionState entry for the specified sessionId */
static void
ReleaseSessionState(int sessionId)
{
/* We call shutdown twice */
will_be_called_count(LWLockAcquire, 2);
will_be_called_count(LWLockRelease, 2);
expect_any_count(LWLockAcquire, lockid, 2);
expect_any_count(LWLockAcquire, mode, 2);
expect_any_count(LWLockRelease, lockid, 2);
gp_session_id = sessionId;
/* First find the previously allocated session state */
SessionState *foundSessionState = AcquireSessionState(sessionId, gp_sessionstate_loglevel);
assert_true(foundSessionState->sessionId == sessionId);
/*
* It was pre-allocated and we incremented the pinCount
* for finding it
*/
assert_true(foundSessionState->pinCount > 1);
/* Satisfy assertion */
sessionStateInited = true;
EXPECT_EREPORT(gp_sessionstate_loglevel);
/* Undo for our search pinCount */
SessionState_Shutdown();
/* The pinCount should not drop to 0 as we just undid our own increment */
assert_true(foundSessionState->pinCount >= 1);
MySessionState = foundSessionState;
sessionStateInited = true;
/*
* If we are releasing this SessionState permanently, we need to ensure
* that RunawayCleaner_RunawayCleanupDoneForSession() will be called
*/
if (foundSessionState->pinCount == 1)
{
will_be_called(RunawayCleaner_RunawayCleanupDoneForSession);
}
EXPECT_EREPORT(gp_sessionstate_loglevel);
/* Undo one more to truly undo previously acquired one */
SessionState_Shutdown();
}
/*
* Checks if RedZoneHandler_FlagTopConsumer() reactivates the runaway detector
* if there is no active session
*/
void
test__RedZoneHandler_FlagTopConsumer__ReactivatesDetectorIfNoActiveSession(void **state)
{
/* Make sure the RedZoneHandler_FlagTopConsumer code is exercised */
vmemTrackerInited = true;
CreateSessionStateArray(4);
/* Make sure MySessionState is valid */
SessionState *one = AcquireSessionState(1 /* sessionId */, 100 /* vmem */, 0 /* activeProcessCount */);
SessionState *two = AcquireSessionState(2, 101, 0);
SessionState *three = AcquireSessionState(3, 100, 0);
SessionState *four = AcquireSessionState(4, 99, 0);
/* Ensure we can detect runaway sessions */
*isRunawayDetector = 0;
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, l, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, l, 1);
static EventVersion fakeLatestRunawayVersion = 0;
static EventVersion fakeCurrentVersion = 1;
latestRunawayVersion = &fakeLatestRunawayVersion;
CurrentVersion = &fakeCurrentVersion;
RedZoneHandler_FlagTopConsumer();
/* None of them could be detected as runaway as all of them are inactive sessions */
assert_true(one->runawayStatus == RunawayStatus_NotRunaway && two->runawayStatus == RunawayStatus_NotRunaway &&
three->runawayStatus == RunawayStatus_NotRunaway && four->runawayStatus == RunawayStatus_NotRunaway);
assert_true(*isRunawayDetector == 0);
DestroySessionStateArray();
}
/*
* Checks if RedZoneHandler_FlagTopConsumer() ignores the idle sessions
* even if they are the top consumer
*/
void
test__RedZoneHandler_FlagTopConsumer__IgnoresIdleSession(void **state)
{
/* Make sure the RedZoneHandler_FlagTopConsumer code is exercised */
vmemTrackerInited = true;
CreateSessionStateArray(4);
/* Make sure MySessionState is valid */
SessionState *one = AcquireSessionState(1 /* sessionId */, 100 /* vmem */, 1 /* activeProcessCount */);
SessionState *two = AcquireSessionState(2, 101, 0);
SessionState *three = AcquireSessionState(3, 100, 0);
SessionState *four = AcquireSessionState(4, 99, 1);
/* Ensure we can detect runaway sessions */
*isRunawayDetector = 0;
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, l, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, l, 1);
static EventVersion fakeLatestRunawayVersion = 0;
static EventVersion fakeCurrentVersion = 1;
latestRunawayVersion = &fakeLatestRunawayVersion;
CurrentVersion = &fakeCurrentVersion;
RedZoneHandler_FlagTopConsumer();
assert_true(one->runawayStatus == RunawayStatus_SecondaryRunawaySession &&
two->runawayStatus == RunawayStatus_NotRunaway &&
three->runawayStatus == RunawayStatus_NotRunaway /* We will encounter three first, but it
doesn't have active process. So, RDT will ignore it. */ &&
four->runawayStatus == RunawayStatus_NotRunaway);
DestroySessionStateArray();
}
/*
* Checks if RedZoneHandler_FlagTopConsumer() finds the top consumer
*/
void
test__RedZoneHandler_FlagTopConsumer__FindsTopConsumer(void **state)
{
/* Make sure the RedZoneHandler_FlagTopConsumer code is exercised */
vmemTrackerInited = true;
CreateSessionStateArray(4);
/* Make sure MySessionState is valid */
SessionState *one = AcquireSessionState(1 /* sessionId */, 100 /* vmem */, 1 /* activeProcessCount */);
SessionState *two = AcquireSessionState(2, 101, 1);
SessionState *three = AcquireSessionState(3, 101, 1);
SessionState *four = AcquireSessionState(4, 99, 1);
/* Ensure we can detect runaway sessions */
*isRunawayDetector = 0;
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, l, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, l, 1);
static EventVersion fakeLatestRunawayVersion = 0;
static EventVersion fakeCurrentVersion = 1;
latestRunawayVersion = &fakeLatestRunawayVersion;
CurrentVersion = &fakeCurrentVersion;
RedZoneHandler_FlagTopConsumer();
assert_true(one->runawayStatus == RunawayStatus_NotRunaway &&
two->runawayStatus == RunawayStatus_NotRunaway /* three is tied with two. So, won't be flagged */ &&
three->runawayStatus == RunawayStatus_PrimaryRunawaySession /* First detected max consumer is
flagged (note the usedList is reversed, so "three" will be ahead of "two") */ &&
four->runawayStatus == RunawayStatus_NotRunaway);
DestroySessionStateArray();
}
/*
* Checks if SessionState_Shutdown marks the session clean when the pinCount
* drops to 0 (i.e., releasing the entry back to the freeList)
*/
void
test__SessionState_Shutdown__MarksSessionCleanUponRelease(void **state)
{
/* Only 3 entries to test the reuse */
CreateSessionStateArray(1);
/* These should be new */
SessionState *first = AcquireSessionState(1, gp_sessionstate_loglevel);
SessionState *reuseFirst = AcquireSessionState(1, gp_sessionstate_loglevel);
SessionState *reuseAgain = AcquireSessionState(1, gp_sessionstate_loglevel);
assert_true(reuseFirst == first && reuseAgain == first);
assert_true(reuseFirst->pinCount == 3);
/* Entry 1 had 2 pinCount. So, we need 3 release call. */
ReleaseSessionState(1);
assert_true(reuseFirst->pinCount == 2 && AllSessionStateEntries->numSession == 1);
ReleaseSessionState(1);
assert_true(reuseFirst->pinCount == 1 && AllSessionStateEntries->numSession == 1);
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, lockid, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, lockid, 1);
/* Bypass assertion */
MySessionState = first;
sessionStateInited = true;
will_be_called(RunawayCleaner_RunawayCleanupDoneForSession);
EXPECT_EREPORT(gp_sessionstate_loglevel);
/* This will finally release the entry */
SessionState_Shutdown();
assert_true(AllSessionStateEntries->numSession == 0);
DestroySessionStateArray();
}
/*
* Checks if SessionState_Init initializes the global variables
* such as MySessionState and sessionStateInited properly
*/
void
test__SessionState_Init__TestSideffects(void **state)
{
/* Only 2 entry to test initialization */
CreateSessionStateArray(1);
will_be_called_count(LWLockAcquire, 1);
will_be_called_count(LWLockRelease, 1);
expect_any_count(LWLockAcquire, lockid, 1);
expect_any_count(LWLockAcquire, mode, 1);
expect_any_count(LWLockRelease, lockid, 1);
assert_true(MySessionState == NULL);
assert_true(sessionStateInited == false);
EXPECT_EREPORT(gp_sessionstate_loglevel);
SessionState_Init();
assert_true(NULL != MySessionState);
assert_true(sessionStateInited);
DestroySessionStateArray();
}
/*
* Test cdbdisp_makeResult would return NULL if OOM happens
*/
void
test__cdbdisp_makeResult__oom(void **state)
{
CdbDispatchResult *result = NULL;
struct CdbDispatchResults *results = _init_cdbdisp_makeResult();
struct SegmentDatabaseDescriptor *segdbDesc =
(struct SegmentDatabaseDescriptor *) palloc0(sizeof(struct SegmentDatabaseDescriptor));
/*
* createPQExpBuffer is supposed to return NULL in OOM cases
*/
will_return_count(createPQExpBuffer, NULL, -1);
expect_any_count(destroyPQExpBuffer, str, -1);
will_be_called_count(destroyPQExpBuffer, -1);
result = cdbdisp_makeResult(results, segdbDesc, 0);
assert_true(result == NULL);
}
