Ejemplo n.º 1
0
//---------------------------------------------------------------------------
//	@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);
}
Ejemplo n.º 2
0
//---------------------------------------------------------------------------
//	@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;
}
Ejemplo n.º 3
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;
}
Ejemplo n.º 4
0
//---------------------------------------------------------------------------
//	@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;
}
Ejemplo n.º 5
0
//---------------------------------------------------------------------------
//	@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;
}