Method run_

test/Thread/ThreadSchedulingPolicyTestCase.cpp:99–164

+---------------------------------------------------------------------------------------------------------------------*/

bool ThreadSchedulingPolicyTestCase::run_() const
{
	const auto allocatedMemory = mallinfo().uordblks;

	// scheduling policy, sequence point multiplier, sequence point step
	using Parameters = std::tuple<SchedulingPolicy, unsigned int, unsigned int>;
	static const Parameters parametersArray[]
	{
			Parameters{SchedulingPolicy::fifo, 2, 1},
			Parameters{SchedulingPolicy::roundRobin, 1, totalThreads},
	};

	for (const auto& parameters : parametersArray)
	{
		{
			const auto schedulingPolicy = std::get<0>(parameters);
			const auto multiplier = std::get<1>(parameters);
			const auto step = std::get<2>(parameters);

			SequenceAsserter sequenceAsserter;

			std::array<DynamicThread, totalThreads> threads
			{{
					makeTestThread(schedulingPolicy, sequenceAsserter, {0 * multiplier, 0 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {1 * multiplier, 1 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {2 * multiplier, 2 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {3 * multiplier, 3 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {4 * multiplier, 4 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {5 * multiplier, 5 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {6 * multiplier, 6 * multiplier + step}),
					makeTestThread(schedulingPolicy, sequenceAsserter, {7 * multiplier, 7 * multiplier + step}),
			}};

			decltype(TickClock::now()) testStart;

			{
				const InterruptMaskingLock interruptMaskingLock;

				// wait for beginning of next tick - test threads should be started in the same tick
				ThisThread::sleepFor({});

				for (auto& thread : threads)
					thread.start();

				testStart = TickClock::now();
			}

			for (auto& thread : threads)
				thread.join();

			const auto testDuration = TickClock::now() - testStart;

			if (sequenceAsserter.assertSequence(totalThreads * 2) == false)
				return false;

			// exact time cannot be calculated, because wasteTime() is not precise when context switches occur during it
			if (testDuration < testThreadDuration * totalThreads)
				return false;