// 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\fastsem.cpp
// 
//

#define __INCLUDE_NTHREADBASE_DEFINES__

#include <nktest/nkutils.h>

void CheckSemaphoreCount(NFastSemaphore* aS, TInt aExpected)
	{
	TInt w = 0;
	TInt r;
	do	{
		r = WaitWithTimeout(aS, KMinTimeout);
		TEST_RESULT1(r==KErrNone || r==KErrTimedOut, "Invalid return code %d", r);
		if (r == KErrNone)
			++w;
		} while(r == KErrNone);
	TEST_RESULT2(w==aExpected, "Signalled %d, Waited %d", aExpected, w);
	}

void FSTest1(TAny* a)
	{
	TInt n = (TInt)a;
	NFastSemaphore s(0);

	TInt i;
	for (i=0; i<n; ++i) NKern::FSSignal(&s);
	CheckSemaphoreCount(&s, n);
	NKern::FSSignalN(&s, n);
	CheckSemaphoreCount(&s, n);
	}

#define DO_FS_TEST1(n,a)	CreateThreadAndWaitForExit("FSTest1", &FSTest1, 12, (TAny*)(n), 0, -1, (a))

struct SFSTest2Info
	{
	NFastSemaphore iSem;
	volatile TInt iBlockCount;
	volatile TInt iSignals;
	volatile TInt iWaits;
	volatile TBool iStart;
	volatile TBool iStop;
	};

void FSTest2Signaller0(TAny* a)
	{
	SFSTest2Info& info = *(SFSTest2Info*)a;
	while (!info.iStart)
		{
		}
//	NThreadBase* t = info.iSem.iOwningThread;
	while (!info.iStop)
		{
		++info.iBlockCount;
		__e32_atomic_add_ord32(&info.iSignals, 1);
		NKern::FSSignal(&info.iSem);
		}
	TEST_PRINT1("Ran %d times", info.iBlockCount);
	}

#ifdef __SMP__
class NKTest
	{
public:
	static TBool ThreadIsBlocked(NThreadBase* aT)
		{ return aT->iWaitState.ThreadIsBlocked(); }
	};
#endif

void FSTest2Signaller(TAny* a)
	{
	SFSTest2Info& info = *(SFSTest2Info*)a;
	while (!info.iStart)
		{
		}
	NThreadBase* t = info.iSem.iOwningThread;
	TInt count0=0;
	TInt countneg=0;
	TInt blocked=0;
	TInt prev_block_count = info.iBlockCount;
	TInt tries = 1;
	TUint32 seed[2];
	seed[0] = NKern::CurrentCpu()+1;
	seed[1] = 0;
	while (!info.iStop)
		{
		TInt c = info.iSem.iCount;
		if (c>=1)
			continue;
		if (--tries==0)
			{
			TInt bc;
			do	{
				bc = info.iBlockCount;
				} while (bc<=prev_block_count);
			prev_block_count = bc;
			tries = random(seed) & 127;
			tries += 71;
			}
		TUint32 x = random(seed) & 63;
		while (x)
			--x;
		c = info.iSem.iCount;
		NKern::FSSignal(&info.iSem);
		__e32_atomic_add_ord32(&info.iSignals, 1);
		if (c==0) ++count0;
		if (c<0) ++countneg;
#ifdef __SMP__
		if (NKTest::ThreadIsBlocked(t)) ++blocked;
#else
		if (t->iNState == NThread::EWaitFastSemaphore) ++blocked;
#endif
		}
	TEST_PRINT1("Count =0 %d times", count0);
	TEST_PRINT1("Count <0 %d times", countneg);
	TEST_PRINT1("Blocked  %d times", blocked);
	}

void FSTest2(TAny* a)
	{
	SFSTest2Info& info = *(SFSTest2Info*)a;
	NFastSemaphore exitSem(0);
	NKern::FSSetOwner(&info.iSem, 0);
	info.iBlockCount = 0;
	info.iWaits = 0;
	info.iSignals = 0;
	info.iStart = FALSE;
	info.iStop = FALSE;
	TInt cpu;
	TInt threads = 0;
	TInt this_cpu = NKern::CurrentCpu();
	for_each_cpu(cpu)
		{
		if (cpu==this_cpu)
			CreateThreadSignalOnExit("FSTest2Sig0", &FSTest2Signaller0, 11, a, 0, KSmallTimeslice, &exitSem, cpu);
		else
			CreateThreadSignalOnExit("FSTest2Sig", &FSTest2Signaller, 12, a, 0, KSmallTimeslice, &exitSem, cpu);
		++threads;
		}

	info.iStart = TRUE;
	while(info.iWaits < 1048576)
		{
		NKern::FSWait(&info.iSem);
		++info.iWaits;
		}

	info.iStop = TRUE;
	while (threads--)
		NKern::FSWait(&exitSem);
	TEST_PRINT1("Leftover signals %d", info.iSignals-info.iWaits);
	TInt r;
	do	{
		r = WaitWithTimeout(&info.iSem, KMinTimeout);
		TEST_RESULT1(r==KErrNone || r==KErrTimedOut, "Invalid return code %d", r);
		if (r == KErrNone)
			++info.iWaits;
		} while(r == KErrNone);
	TEST_PRINT2("Signalled %d, Waited %d", info.iSignals, info.iWaits);
	TEST_RESULT(info.iWaits==info.iSignals, "MISMATCH!");
	}

void DoFsTest2()
	{
	SFSTest2Info info;
	CreateThreadAndWaitForExit("FSTest2", &FSTest2, 12, (TAny*)&info, 0, KSmallTimeslice, 0);
	}


void TestFastSemaphore()
	{
	TEST_PRINT("Testing Fast Semaphores...");

	TInt cpu;
	for_each_cpu(cpu)
		{
		DO_FS_TEST1(0,cpu);
		DO_FS_TEST1(1,cpu);
		DO_FS_TEST1(2,cpu);
		DO_FS_TEST1(13,cpu);
		}

	DoFsTest2();
	}