// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\nkernsa\threadbasic.cpp

// 

//

#include <nktest/nkutils.h>

#define SLEEP_TIME 1

#ifndef __SMP__

#define iNThreadBaseSpare7 iSpare7

#endif

struct SThreadInfo1

	{

	volatile TInt iRunCount;

	volatile TInt iBlockEvery;

	volatile TBool iStop;

	CircBuf* iBuf;

	NThread* iThread;

	};

TInt WaitForRun(SThreadInfo1& aI, TInt aCount)

	{

	TUint32 initial = NKern::TickCount();

	TUint32 final = initial + 2;

	FOREVER

		{

		if (aI.iRunCount >= aCount)

			return aI.iRunCount;

		TUint32 x = NKern::TickCount();

		if ((x - final) < 0x80000000u)

			return KErrTimedOut;

		}

	}

void BasicThread(TAny* a)

	{

	SThreadInfo1& info = *(SThreadInfo1*)a;

	NThread* pC = NKern::CurrentThread();

	while (!info.iStop)

		{

		TInt r = info.iBuf->TryPut((TUint32)pC);

		TEST_RESULT(r==KErrNone, "Buffer full");

		TInt c = (TInt)__e32_atomic_add_ord32(&info.iRunCount, 1);

		TInt m = (c+1)%info.iBlockEvery;

		if (!m)

			NKern::WaitForAnyRequest();

		}

	}

void BasicThread0(TAny*)

	{

	NThread* pC = NKern::CurrentThread();

	TInt my_priority = pC->i_NThread_BasePri;

	TInt this_cpu = NKern::CurrentCpu();

	CircBuf* buf = CircBuf::New(KNumPriorities * KMaxCpus * 8);

	TEST_OOM(buf);

	SThreadInfo1* pI = (SThreadInfo1*)malloc(KNumPriorities * KMaxCpus * sizeof(SThreadInfo1));

	TEST_OOM(pI);

	memclr(pI, KNumPriorities * KMaxCpus * sizeof(SThreadInfo1));

	NFastSemaphore exitSem(0);

	TInt pri;

	TInt cpu;

	for_each_cpu(cpu)

		{

		for (pri = 1; pri < KNumPriorities; ++pri)

			{

			TInt ix = cpu * KNumPriorities + pri;

			SThreadInfo1& info = pI[ix];

			info.iBlockEvery = 1;

			info.iBuf = buf;

			info.iThread = CreateUnresumedThreadSignalOnExit("Basic", &BasicThread, pri, &info, 0, -1, &exitSem, cpu);

			TEST_OOM(info.iThread);

			}

		}

	TInt c = buf->Count();

	TEST_RESULT1(c==0, "Unexpected count %d", c);	// nothing resumed yet

	for_each_cpu(cpu)

		{

		for (pri = 1; pri < KNumPriorities; ++pri)

			{

			TInt ix = cpu * KNumPriorities + pri;

			SThreadInfo1& info = pI[ix];

			NKern::ThreadResume(info.iThread);

			TInt r = WaitForRun(info, 1);

			if (pri>my_priority || cpu!=this_cpu)

				{

				TEST_RESULT(r==1, "WaitForRun");

				c = buf->Count();

				TEST_RESULT1(c==1, "Unexpected count %d", c);	// thread should have run

				TUint32 x = buf->Get();

				c = buf->Count();

				TEST_RESULT1(c==0, "Unexpected count %d", c);

				TEST_RESULT(x==(TUint32)info.iThread, "Wrong thread");

				}

			else

				{

				TEST_RESULT(r==KErrTimedOut, "WaitForRun");

				c = buf->Count();

				TEST_RESULT1(c==0, "Unexpected count %d", c);	// thread won't have run since current has priority

				}

			}

		}

	NKern::Sleep(10);	// let lower priority threads run

	c = buf->Count();

	TEST_RESULT1(c==my_priority, "Unexpected count %d", c);

	for (pri = my_priority; pri >= 1; --pri)

		{

		TInt ix = this_cpu * KNumPriorities + pri;

		SThreadInfo1& info = pI[ix];

		TEST_RESULT(info.iRunCount==1, "Bad run count");

		TUint32 x = buf->Get();

		TEST_RESULT(x==(TUint32)info.iThread, "Wrong thread");

		}

	for_each_cpu(cpu)

		{

		for (pri = 1; pri < KNumPriorities; ++pri)

			{

			TInt ix = cpu * KNumPriorities + pri;

			SThreadInfo1& info = pI[ix];

			info.iStop = TRUE;

			NKern::ThreadRequestSignal(info.iThread);

			NKern::FSWait(&exitSem);

			}

		}

	free(pI);

	delete buf;

	}

void BasicThreadTest1()

	{

	TEST_PRINT("Testing all thread priorities without timeslice");

	TInt pri;

	TInt cpu;

	for_each_cpu(cpu)

		{

		for (pri = 1; pri < KNumPriorities; ++pri)

			{

			TEST_PRINT2("Basic0 pri %d cpu %d", pri, cpu);

			CreateThreadAndWaitForExit("Basic0", &BasicThread0, pri, 0, 0, -1, cpu);

			}

		}

	}

void Spinner(TAny*)

	{

	FOREVER

		{

		}

	}

void BasicThreadTest2()

	{

	TEST_PRINT("Kill an unresumed thread");

	NFastSemaphore exitSem(0);

	TInt cpu;

	for_each_cpu(cpu)

		{

		TEST_PRINT1("Thread on CPU %d", cpu);

		NThread* t = CreateUnresumedThreadSignalOnExit("Spinner", &Spinner, 33, 0, 0, -1, &exitSem, cpu);

		TEST_OOM(t);

		NKern::ThreadKill(t);

		NKern::FSWait(&exitSem);

		TEST_PRINT("OK");

		}

	}

void TimesliceTestThread(TAny* a)

	{

	NThread* pC = NKern::CurrentThread();

	TUint id = pC->iNThreadBaseSpare7;

	CircBuf* buf = (CircBuf*)a;

	TUint32 thresh = norm_fast_counter_freq();

	TUint32 thresh2 = thresh;

	thresh /= 3000;

	if (thresh < 10)

		thresh = 10;

	TUint32 last_interval_begin = norm_fast_counter();

	TUint32 last_seen_time = norm_fast_counter();

	FOREVER

		{

		TUint32 nfc = norm_fast_counter();

		TUint32 delta = nfc - last_seen_time;

		TUint32 interval_length = last_seen_time - last_interval_begin;

		if (delta > thresh || interval_length > thresh2)

			{

			last_interval_begin = nfc;

			TUint32 x = (id<<24) | interval_length;

			TInt r = buf->TryPut(x);

			if (r != KErrNone)

				break;

			}

		last_seen_time = nfc;

		}

	}

void TimesliceTest()

	{

//	NThread* pC = NKern::CurrentThread();

//	TInt my_priority = pC->i_NThread_BasePri;

//	TInt this_cpu = NKern::CurrentCpu();

	CircBuf* buf = CircBuf::New(1024);

	TEST_OOM(buf);

	NFastSemaphore exitSem(0);

	TInt cpu;

	TInt i;

	TInt id = 0;

	NThread* t[KMaxCpus*3];

	TInt timeslice[3] =

		{

		__microseconds_to_timeslice_ticks(20000),

		__microseconds_to_timeslice_ticks(23000),

		__microseconds_to_timeslice_ticks(19000)

		};

	TInt expected[3] =

		{

		__microseconds_to_norm_fast_counter(20000),

		__microseconds_to_norm_fast_counter(23000),

		__microseconds_to_norm_fast_counter(19000)

		};

	for_each_cpu(cpu)

		{

		for (i=0; i<3; ++i)

			{

			t[id] = CreateThreadSignalOnExit("Timeslice", &TimesliceTestThread, 10, buf, 0, timeslice[i], &exitSem, cpu);

			TEST_OOM(t[id]);

			t[id]->iNThreadBaseSpare7 = id;

			++id;

			}

		nfcfspin(__microseconds_to_norm_fast_counter(1000));

		}

	for (i=0; i<id; ++i)

		{

		NKern::FSWait(&exitSem);

		TEST_PRINT("Thread exited");

		}

	TUint32 x;

	TUint32 xtype = 0;

	TUint32 ncpus = NKern::NumberOfCpus();

	TUint32 xcpu = (ncpus>1) ? 1 : 0;

	while (buf->TryGet(x)==KErrNone)

		{

		TUint32 id = x>>24;

		TUint32 time = x&0xffffff;

		TEST_PRINT2("Id %d Time %d", id, time);

		TUint32 xid = xcpu*3 + xtype;

		if (xcpu==0 && ++xtype==3)

			xtype=0;

		if (++xcpu == ncpus)

			xcpu=0;

		TEST_RESULT2(id==xid, "Expected id %d got id %d", xid, id);

		TUint32 exp = expected[id%3];

		TUint32 tol = exp/100;

		if (tol < 2)

			tol = 2;

		TUint32 diff = (time > exp) ? time - exp : exp - time;

		TEST_RESULT2(diff < tol, "Out of Tolerance: exp %d got %d", exp, time);

		}

	delete buf;

	}

struct SThreadInfo2

	{

	enum {ENumTimes=8};

	TInt Add(TUint32 aTime, TUint32 aId);

	NFastMutex* iMutex;

	TInt iSpin1;

	TInt iSpin2;

	TInt iSpin3;

	NThread* iThread2;

	volatile TInt iCount;

	volatile TUint32 iId[ENumTimes];

	volatile TUint32 iTime[ENumTimes];

	};

TInt SThreadInfo2::Add(TUint32 aTime, TUint32 aId)

	{

	TInt c = __e32_atomic_tas_ord32(&iCount, ENumTimes, 0, 1);

	if (c>=ENumTimes)

		return KErrOverflow;

	iTime[c] = aTime;

	iId[c] = aId;

	return KErrNone;

	}

/*

If Thread1 and Thread2 on different CPUs:

	Point0

	PointA	just after Point0

	PointB	PointA + spin1

	PointE	PointA + spin1

	PointC	PointB + spin2

	PointD	PointB + spin2

	PointF	PointE + spin3

If Thread1 and Thread2 on same CPU, no mutex:

	Point0

	PointA	just after Point0

	PointB	PointA + spin1 or PointA + spin1 + timeslice if spin1>=timeslice

	PointE	PointA + spin1 or PointA + timeslice whichever is later

If Thread1 and Thread2 on same CPU, mutex:

	Point0

	PointA	just after Point0

	PointB	PointA + spin1

	PointC	PointB + spin2

	PointE	PointA + spin1 +spin2 or PointA + timeslice whichever is later

	PointD	PointA + spin1 + spin2 if (spin1+spin2)<timeslice, otherwise PointA + spin1 + spin2 + timeslice

*/

void TimesliceTest2Thread1(TAny* a)

	{

	SThreadInfo2& info = *(SThreadInfo2*)a;

	TEST_RESULT(info.Add(norm_fast_counter(),1)==KErrNone, "Add failed");		// Point A

	if (info.iMutex)

		NKern::FMWait(info.iMutex);

	nfcfspin(info.iSpin1);

	NKern::ThreadResume(info.iThread2);

	TEST_RESULT(info.Add(norm_fast_counter(),1)==KErrNone, "Add failed");		// Point B

	nfcfspin(info.iSpin2);

	TEST_RESULT(info.Add(norm_fast_counter(),1)==KErrNone, "Add failed");		// Point C

	if (info.iMutex)

		NKern::FMSignal(info.iMutex);

	TEST_RESULT(info.Add(norm_fast_counter(),1)==KErrNone, "Add failed");		// Point D

	nfcfspin(__microseconds_to_norm_fast_counter(100000));

	}

void TimesliceTest2Thread2(TAny* a)

	{

	SThreadInfo2& info = *(SThreadInfo2*)a;

	TEST_RESULT(info.Add(norm_fast_counter(),2)==KErrNone, "Add failed");		// Point E

	nfcfspin(info.iSpin3);

	TEST_RESULT(info.Add(norm_fast_counter(),2)==KErrNone, "Add failed");		// Point F

	nfcfspin(__microseconds_to_norm_fast_counter(100000));

	}

void DoTimesliceTest2(TInt aCpu, TInt aSpin1, TInt aSpin2, TInt aSpin3, TBool aUseMutex)

	{

	TEST_PRINT5("TT2: C=%1d S1=%d S2=%d S3=%d M=%1d", aCpu, aSpin1, aSpin2, aSpin3, aUseMutex);

	TInt this_cpu = NKern::CurrentCpu();

	NFastSemaphore exitSem(0);

	NFastMutex mutex;

	SThreadInfo2 info;

	info.iMutex = aUseMutex ? &mutex : 0;

	info.iSpin1 = aSpin1;

	info.iSpin2 = aSpin2;

	info.iSpin3 = aSpin3;

	info.iCount = 0;

	TInt timeslice = __microseconds_to_timeslice_ticks(5000);

	NThread* t1 = CreateUnresumedThreadSignalOnExit("Thread1", &TimesliceTest2Thread1, 10, &info, 0, timeslice, &exitSem, this_cpu);

	TEST_OOM(t1);

	info.iThread2 = CreateUnresumedThreadSignalOnExit("Thread2", &TimesliceTest2Thread2, 10, &info, 0, timeslice, &exitSem, aCpu);

	TEST_OOM(info.iThread2);

	NKern::ThreadResume(t1);

	TEST_RESULT(info.Add(norm_fast_counter(),0)==KErrNone, "Add failed");	// Point 0

	NKern::FSWait(&exitSem);

	NKern::FSWait(&exitSem);

	TEST_RESULT1(info.iCount==7, "Wrong count %d", info.iCount);

	TInt i;

	TUint32 pointA=0, pointB=0, pointC=0, pointD=0, pointE=0, pointF=0;

	TInt n1=0, n2=0;

	TUint32 delta = __microseconds_to_norm_fast_counter(100);

	TUint32 ts = __microseconds_to_norm_fast_counter(5000);

	for (i=0; i<info.iCount; ++i)

		{

		if (i>0)

			{

			TUint32 id = info.iId[i];

			TUint32 x = info.iTime[i] - info.iTime[0];

			TEST_PRINT2("%d: %d", id, x);

			if (id==1)

				{

				switch(++n1)

					{

					case 1: pointA = x; break;

					case 2: pointB = x; break;

					case 3: pointC = x; break;

					case 4: pointD = x; break;

					}

				}

			else

				{

				switch(++n2)

					{

					case 1: pointE = x; break;

					case 2: pointF = x; break;

					}

				}

			}

		}

	if (aCpu != this_cpu)

		{

		TEST_RESULT(RANGE_CHECK(TUint32(aSpin1), pointB, TUint32(aSpin1)+delta), "pointB");

		TEST_RESULT(RANGE_CHECK(TUint32(aSpin1), pointE, TUint32(aSpin1)+delta), "pointE");

		TEST_RESULT(RANGE_CHECK(pointB+aSpin2, pointC, pointB+aSpin2+delta), "pointC");

		TEST_RESULT(RANGE_CHECK(pointB+aSpin2, pointD, pointB+aSpin2+delta), "pointD");

		TEST_RESULT(RANGE_CHECK(pointE+aSpin3, pointF, pointE+aSpin3+delta), "pointF");

		}

	else if (aUseMutex)

		{

		TEST_RESULT(RANGE_CHECK(TUint32(aSpin1), pointB, aSpin1+delta), "pointB");

		TEST_RESULT(RANGE_CHECK(pointB+aSpin2, pointC, pointB+aSpin2+delta), "pointC");

		TUint32 xpe = aSpin1 + aSpin2;

		TUint32 xpd = xpe;

		if (xpe < ts)

			xpe = ts;

		else

			xpd += ts;

		TEST_RESULT(RANGE_CHECK(xpe, pointE, xpe+delta), "pointE");

		TEST_RESULT(RANGE_CHECK(xpd, pointD, xpd+delta), "pointD");

		}

	else

		{

		TUint32 xpb = aSpin1;

		TUint32 xpe = aSpin1;

		if (xpb >= ts)

			xpb += ts;

		else

			xpe = ts;

		TEST_RESULT(RANGE_CHECK(xpb, pointB, xpb+delta), "pointB");

		TEST_RESULT(RANGE_CHECK(xpe, pointE, xpe+delta), "pointE");

		}

	}

void TimesliceTest2()

	{

	TInt cpu;

	TInt ms = __microseconds_to_norm_fast_counter(1000);

	for_each_cpu(cpu)

		{

		DoTimesliceTest2(cpu, 1*ms, 10*ms, 10*ms, FALSE);

		DoTimesliceTest2(cpu, 2*ms, 10*ms, 10*ms, FALSE);

		DoTimesliceTest2(cpu, 7*ms, 20*ms, 20*ms, FALSE);

		DoTimesliceTest2(cpu, 1*ms, 1*ms, 10*ms, TRUE);

		DoTimesliceTest2(cpu, 1*ms, 2*ms, 10*ms, TRUE);

		DoTimesliceTest2(cpu, 2*ms, 2*ms, 10*ms, TRUE);

		DoTimesliceTest2(cpu, 7*ms, 7*ms, 10*ms, TRUE);

		DoTimesliceTest2(cpu, 7*ms, 7*ms, 50*ms, TRUE);

		}

	}

struct SThreadInfo3

	{

	enum TTestType

		{

		ESpin,

		ECount,

		EWaitFS,

		EWaitFM,

		EExit,

		EHoldFM,

		};

	TTestType iType;

	TAny* iObj;

	TInt iPri;

	TInt iCpu;

	volatile TInt iCount;

	volatile TInt iCurrCpu;

	volatile TBool iStop;

	NFastSemaphore* iExitSem;

	TInt iExitCpu;

	void Set(TTestType aType, TAny* aObj, TInt aPri, TInt aCpu)

		{iType=aType; iObj=aObj; iPri=aPri; iCpu=aCpu; iCount=0; iCurrCpu=-1; iStop=FALSE; iExitSem=0; iExitCpu=-1;}

	NThread* CreateThread(const char* aName, NFastSemaphore* aExitSem);

	static void ExitHandler(TAny* aP, NThread* aT, TInt aC);

	};

void BasicThread3(TAny* a)

	{

	SThreadInfo3& info = *(SThreadInfo3*)a;

	switch (info.iType)

		{

		case SThreadInfo3::ESpin:

			FOREVER

				{

				info.iCurrCpu = NKern::CurrentCpu();

				}

		case SThreadInfo3::ECount:

			FOREVER

				{

				info.iCurrCpu = NKern::CurrentCpu();

				__e32_atomic_add_ord32(&info.iCount, 1);

				}

		case SThreadInfo3::EWaitFS:

			NKern::FSSetOwner((NFastSemaphore*)info.iObj, 0);

			NKern::FSWait((NFastSemaphore*)info.iObj);

			break;

		case SThreadInfo3::EWaitFM:

			NKern::FMWait((NFastMutex*)info.iObj);

			NKern::FMSignal((NFastMutex*)info.iObj);

			break;

		case SThreadInfo3::EExit:

			break;