anki-3d-engine/tests/util/Thread.cpp

// Copyright (C) 2014, Panagiotis Christopoulos Charitos.
// All rights reserved.
// Code licensed under the BSD License.
// http://www.anki3d.org/LICENSE

#include "tests/framework/Framework.h"
#include "anki/util/Thread.h"
#include "anki/util/StdTypes.h"
#include "anki/util/HighRezTimer.h"
#include <cstring>

namespace anki {

//==============================================================================
ANKI_TEST(Util, Thread)
{
	static const char* THREAD_NAME = "name";
	Thread t(THREAD_NAME);

	static const U64 NUMBER = 0xFAFAFAFABABABA;
	U64 u = NUMBER;

	t.start(&u, [](Thread::Info& info) -> Error
	{
		Bool check = true; 
		
		// Check name
		check = check && (std::strcmp(info.m_threadName, THREAD_NAME) == 0);

		// Check user value
		U64& num = *reinterpret_cast<U64*>(info.m_userData);
		check = check && (num == NUMBER);

		// Change number
		num = 0xF00;

		HighRezTimer::sleep(1.0);

		return (check != true) ? ErrorCode::FUNCTION_FAILED : ErrorCode::NONE;
	});

	ANKI_TEST_EXPECT_EQ(u, NUMBER); // It should be the old value
	Error err = t.join();
	ANKI_TEST_EXPECT_EQ(err, 0);
	ANKI_TEST_EXPECT_EQ(u, 0xF00);
}

//==============================================================================
ANKI_TEST(Util, Mutex)
{
	Thread t0(nullptr), t1(nullptr);
	Mutex mtx;

	static const U ITERATIONS = 1000000;

	class In
	{
	public:
		I64 m_num = ITERATIONS;
		Mutex* m_mtx;
	};

	In in;
	in.m_mtx = &mtx;

	t0.start(&in, [](Thread::Info& info) -> Error
	{
		In& in = *reinterpret_cast<In*>(info.m_userData);
		I64& num = in.m_num;
		Mutex& mtx = *in.m_mtx;

		for(U i = 0; i < ITERATIONS; i++)
		{
			mtx.lock();
			num += 2;
			mtx.unlock();
		}

		return ErrorCode::NONE;
	});

	t1.start(&in, [](Thread::Info& info) -> Error
	{
		In& in = *reinterpret_cast<In*>(info.m_userData);
		I64& num = in.m_num;
		Mutex& mtx = *in.m_mtx;

		for(U i = 0; i < ITERATIONS; i++)
		{

			mtx.lock();
			--num;
			mtx.unlock();
		}

		return ErrorCode::NONE;
	});


	ANKI_TEST_EXPECT_NO_ERR(t0.join());
	ANKI_TEST_EXPECT_NO_ERR(t1.join());

	ANKI_TEST_EXPECT_EQ(in.m_num, ITERATIONS * 2);
}

//==============================================================================

/// Struct for our tests
struct TestJobTP: Threadpool::Task
{
	U32 in = 0;
	U32 iterations = 0;

	Error operator()(U32 /*threadId*/, PtrSize /*threadsCount*/)
	{
		for(U32 i = 0; i < iterations; i++)	
		{
			++in;
		}

		return ErrorCode::NONE;
	}
};

} // end namespace anki

ANKI_TEST(Util, Threadpool)
{
	const U32 threadsCount = 4;
	const U32 repeat = 5;
	Threadpool* tp = new Threadpool(threadsCount);

	TestJobTP jobs[threadsCount];

	for(U32 i = 1; i < repeat; i++)
	{
		U32 iterations = rand() % 100000;

		for(U32 j = 0; j < threadsCount; j++)
		{
			jobs[j].in = i;
			jobs[j].iterations = iterations;

			tp->assignNewTask(j, &jobs[j]);
		}

		ANKI_TEST_EXPECT_NO_ERR(tp->waitForAllThreadsToFinish());

		for(U32 j = 0; j < threadsCount; j++)
		{
			ANKI_TEST_EXPECT_EQ(jobs[j].in, i + iterations);
		}
	}

	delete tp;
}

//==============================================================================
ANKI_TEST(Util, Barrier)
{
	// Simple test
	{
		Barrier b(2);
		Thread t(nullptr);

		t.start(&b, [](Thread::Info& info) -> Error
		{
			Barrier& b = *reinterpret_cast<Barrier*>(info.m_userData);
			b.wait();
			return ErrorCode::NONE;
		});

		b.wait();
		ANKI_TEST_EXPECT_NO_ERR(t.join());
	}
}