// 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();

	}