//---------------------------------------------------------------------------
// @function:
// CWorkerPoolManagerTest::Unittest_Stress
//
// @doc:
// Stress worker pool using a given combination of tasks and worker;
//
//---------------------------------------------------------------------------
void
CWorkerPoolManagerTest::Unittest_Stress
(
ULONG ulWorkers,
ULONG culTskCnt,
void *func(void *)
)
{
ULONG time = 0;
CAutoMemoryPool amp(CAutoMemoryPool::ElcStrict);
IMemoryPool *pmp = amp.Pmp();
// set worker count
CWorkerPoolManager *pwpm = CWorkerPoolManager::Pwpm();
pwpm->SetWorkersMin(ulWorkers);
pwpm->SetWorkersMax(ulWorkers);
// test convergence
while (ulWorkers != pwpm->UlWorkers())
{
clib::USleep(1000);
}
clib::USleep(1000);
// execute tasks
{
CAutoTaskProxy atp(pmp, pwpm);
CAutoRg<CTask *> argPtsk;
argPtsk = GPOS_NEW_ARRAY(pmp, CTask*, culTskCnt);
ULLONG ulSum = 0;
CWallClock clock;
for (ULONG i = 0; i < culTskCnt; i++)
{
argPtsk[i] = atp.PtskCreate(func, &ulSum);
}
for (ULONG i = 0; i < culTskCnt; i++)
{
atp.Schedule(argPtsk[i]);
}
for (ULONG i = 0; i < culTskCnt; i++)
{
atp.Wait(argPtsk[i]);
}
time = clock.UlElapsedMS();
}
// print results
GPOS_TRACE_FORMAT("\t* %d worker(s) - %d tasks: %dms", ulWorkers, culTskCnt, time);
}
//---------------------------------------------------------------------------
// @function:
// gpos_exec
//
// @doc:
// Set number of threads in worker pool;
// return 0 for successful completion, 1 for error;
//
//---------------------------------------------------------------------------
int gpos_set_threads(int min, int max)
{
try
{
CWorkerPoolManager *pwpm = CWorkerPoolManager::Pwpm();
// check if worker pool is initialized
if (NULL == pwpm)
{
return 1;
}
pwpm->SetWorkersMin(min);
pwpm->SetWorkersMax(max);
}
catch (...)
{
// unexpected failure
return 1;
}
return 0;
}
//---------------------------------------------------------------------------
// @function:
// CSyncHashtableTest::EresUnittest_Concurrency
//
// @doc:
// Spawn a number of tasks to access hash table; in order to increase
// the chances of concurrent access, we force each task to wait until
// all other tasks have actually started
//
//---------------------------------------------------------------------------
GPOS_RESULT
CSyncHashtableTest::EresUnittest_Concurrency()
{
// create memory pool
CAutoMemoryPool amp;
IMemoryPool *pmp = amp.Pmp();
CWorkerPoolManager *pwpm = CWorkerPoolManager::Pwpm();
GPOS_ASSERT(GPOS_SHT_THREADS <= pwpm->UlWorkersMax() &&
"Insufficient number of workers to run test");
SElemHashtable sht;
sht.Init
(
pmp,
GPOS_SHT_SMALL_BUCKETS,
GPOS_OFFSET(SElem, m_link),
GPOS_OFFSET(SElem, m_ulKey),
&(SElem::m_ulInvalid),
SElem::UlHash,
SElem::FEqualKeys
);
SElem *rgelem = GPOS_NEW_ARRAY(pmp, SElem, GPOS_SHT_ELEMENTS);
// insert an initial set of elements in hash table
for (ULONG i = 0; i < GPOS_SHT_ELEMENTS; i ++)
{
rgelem[i] = SElem(i, i);
if (i < GPOS_SHT_INITIAL_ELEMENTS)
{
sht.Insert(&rgelem[i]);
}
}
// create an event for tasks synchronization
CMutex mutex;
CEvent event;
event.Init(&mutex);
// scope for tasks
{
CAutoTaskProxy atp(pmp, pwpm);
CTask *rgtask[GPOS_SHT_THREADS];
pfuncHashtableTask rgpfuncTask[] =
{
PvUnittest_Inserter,
PvUnittest_Remover,
PvUnittest_Reader,
PvUnittest_Iterator
};
SElemTest elemtest(sht, rgelem, &event);
const ULONG ulTypes = GPOS_ARRAY_SIZE(rgpfuncTask);
// create tasks
for (ULONG i = 0; i < GPOS_SHT_THREADS; i++)
{
ULONG ulTaskIndex = i % ulTypes;
rgtask[i] = atp.PtskCreate
(
rgpfuncTask[ulTaskIndex],
&elemtest
);
atp.Schedule(rgtask[i]);
}
// wait for completion
for (ULONG i = 0; i < GPOS_SHT_THREADS; i++)
{
GPOS_CHECK_ABORT;
atp.Wait(rgtask[i]);
}
}
GPOS_DELETE_ARRAY(rgelem);
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CLoggerTest::EresUnittest_Stress
//
// @doc:
// Log to file
//
//---------------------------------------------------------------------------
GPOS_RESULT
CLoggerTest::EresUnittest_LoggerStress()
{
CAutoMemoryPool am;
IMemoryPool *pmp = am.Pmp();
CWorkerPoolManager *pwpm = CWorkerPoolManager::Pwpm();
ULONG ulWorkersMin = pwpm->UlWorkersMin();
ULONG ulWorkersMax = pwpm->UlWorkersMax();
pwpm->SetWorkersMin(50);
pwpm->SetWorkersMax(50);
ULONG timeOne = 0;
ULONG timeTen = 0;
ULONG timeFifty = 0;
const ULONG ulIterations = 10000;
GPOS_TRY
{
CWallClock clock;
Unittest_TestLoggerFile
(
pmp,
10 /*ulFiles*/,
10 * 1024 /*ulRotateThreshold*/,
1 /*ulWorkers*/,
ulIterations /*ulIterations*/
)
;
timeOne = clock.UlElapsedMS();
clock.Restart();
Unittest_TestLoggerFile
(
pmp,
10 /*ulFiles*/,
10 * 1024 /*ulRotateThreshold*/,
10 /*ulWorkers*/,
ulIterations /*ulIterations*/
)
;
timeTen = clock.UlElapsedMS();
clock.Restart();
Unittest_TestLoggerFile
(
pmp,
10 /*ulFiles*/,
10 * 1024 /*ulRotateThreshold*/,
50 /*ulWorkers*/,
ulIterations /*ulIterations*/
)
;
timeFifty = clock.UlElapsedMS();
// print results
GPOS_TRACE_FORMAT
(
"Log stress: 1 worker: %dms 10 workers: %dms 50 workers: %dms",
timeOne,
timeTen,
timeFifty
)
;
}
GPOS_CATCH_EX(ex)
{
pwpm->SetWorkersMin(ulWorkersMin);
pwpm->SetWorkersMax(ulWorkersMax);
GPOS_RETHROW(ex);
}
GPOS_CATCH_END;
pwpm->SetWorkersMin(ulWorkersMin);
pwpm->SetWorkersMax(ulWorkersMax);
return GPOS_OK;
}
//---------------------------------------------------------------------------
// @function:
// CWorkerPoolManagerTest::EresUnittest_Stress
//
// @doc:
// Stress worker pool using large number of tasks and workers
//
//---------------------------------------------------------------------------
GPOS_RESULT
CWorkerPoolManagerTest::EresUnittest_Stress()
{
CWorkerPoolManager *pwpm = CWorkerPoolManager::Pwpm();
ULONG ulWorkersMin = pwpm->UlWorkersMin();
ULONG ulWorkersMax = pwpm->UlWorkersMax();
#ifdef GPOS_DEBUG
BOOL fEnforceTimeSlices = CWorker::m_fEnforceTimeSlices;
#endif // GPOS_DEBUG
GPOS_TRY
{
GPOS_TRACE(GPOS_WSZ_LIT("Stress worker pool : "));
#ifdef GPOS_DEBUG
CWorker::m_fEnforceTimeSlices = false;
#endif // GPOS_DEBUG
// task function
void *(*func)(void *);
func = CAutoTaskProxyTest::PvUnittest_Short;
// 1 task per worker
CWorkerPoolManagerTest::Unittest_Stress(10, 10, func);
CWorkerPoolManagerTest::Unittest_Stress(100, 100, func);
// 10 tasks per worker
CWorkerPoolManagerTest::Unittest_Stress(10, 100, func);
CWorkerPoolManagerTest::Unittest_Stress(100, 1000, func);
}
GPOS_CATCH_EX(ex)
{
// restore worker count
pwpm->SetWorkersMin(ulWorkersMin);
pwpm->SetWorkersMax(ulWorkersMax);
#ifdef GPOS_DEBUG
CWorker::m_fEnforceTimeSlices = fEnforceTimeSlices;
#endif // GPOS_DEBUG
GPOS_RETHROW(ex);
}
GPOS_CATCH_END;
// restore worker count
pwpm->SetWorkersMin(ulWorkersMin);
pwpm->SetWorkersMax(ulWorkersMax);
#ifdef GPOS_DEBUG
CWorker::m_fEnforceTimeSlices = fEnforceTimeSlices;
CWorker::PwrkrSelf()->ResetTimeSlice();
#endif // GPOS_DEBUG
while (ulWorkersMax < pwpm->UlWorkers())
{
clib::USleep(1000);
}
return GPOS_OK;
}
