// Copyright (c) 1995-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\prime\t_semutx.cpp

// Tests the RSemaphore, RMutex and RCriticalSection classes

// Overview:

// Tests the RSemaphore, RMutex and RCriticalSection classes

// API Information:

// RSemaphore, RMutex, RCriticalSection

// Details:

// - Test RSemaphore and RMutex with the producer/consumer scenario.

// Create two threads, use signal and wait to coordinate the

// threads. Verify results are as expected.

// - Calculate the time required to create, resume and close a thread.

// - Test RSemaphore::Wait(timeout) in a variety ways and timeout 

// values. Verify results are as expected.

// - Test RMutex via two threads which write to an array. The writing

// and updating of the index is wrapped within a mutex pair. Verify 

// results are as expected.

// - Test RCriticalSection via two threads which write to an array. The 

// writing and updating of the index is wrapped within a critical section

// pair. Verify results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <hal.h>

#include <e32atomics.h>

#include <u32hal.h>

#include <e32svr.h>

const TInt KMaxBufferSize=10;

const TInt KMaxArraySize=10;

const TInt KNumProducerItems=100;

enum {EThread1ID=1,EThread2ID};

RTest test(_L("T_SEMUTX"));

RMutex mutex;

RCriticalSection criticalSn;

TInt thread1Count,thread2Count;

TInt arrayIndex;

TInt array[KMaxArraySize];

TInt consumerArray[KNumProducerItems];

RSemaphore slotAvailable,itemAvailable;

TBool doCpuLocking = EFalse;

// return num of cpus in system

TInt NumCpus()

	{

	TInt r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);

	return r;

	}

TInt LockCurrentThreadToCpu0(TBool aCallingIsMainTestThread = EFalse)

	{

	if (aCallingIsMainTestThread) 

		{

		if (NumCpus() > 1) 

			{

			doCpuLocking = ETrue;

			return UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, 0, 0); 

			}

		else

			{

			return KErrNone;

			}

		}

	return UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, 0, 0); 

	}

TInt UnlockCurrentThreadToCpu0(TBool aCallingIsMainTestThread = EFalse)

	{

	if (aCallingIsMainTestThread) 

		{

		if (NumCpus() > 1) 

			{

			doCpuLocking = EFalse;

			return UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*) 0xffffffffu, 0); 

			}

		else

			{

			return KErrNone;

			}

		}

	return UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny*) 0xffffffffu, 0); 

	}

/******************************************************************************

 * Random Number Generation

 ******************************************************************************/

void Random(TUint64& a)

	{

	TInt i;

	for (i=64; i>0; --i)

		{

		TUint64 x = a<<1;

		TUint64 y = x<<1;

		x^=y;

		a = (y>>1) | (x>>63);

		}

	}

// Returns 256*log2(a/2^64)

TInt Log2(TUint64 a)

	{

	const TUint64 KBit63 = UI64LIT(0x8000000000000000);

	TInt n = __e32_find_ms1_64(a);

	a <<= (63-n);

	n -= 64;

	TInt i;

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

		{

		a >>= 32;

		a *= a;

		n <<= 1;

		if (a & KBit63)

			{

			++n;

			}

		else

			{

			a <<= 1;

			}

		}

	return n;

	}

TUint32 ExpRV(TUint64 aU, TUint32 aMean, TUint32 aTick)

	{

	TInt n = -Log2(aU);

	TUint64 x = TUint64(n) * TUint64(aMean);

	x *= TUint64(22713);	// 2^15 * ln2

	TUint64 p(aTick);

	p <<= 22;

	x += p;

	p += p;

	x /= p;

	return I64LOW(x);

	}

/*----------------------------------------------------------------------------*/

class MLock

	{

public:

	enum {EPollable=1, ETimeoutAvail=2, ENestable=4, ELimit1=8, ELooseTimeout=16};

public:

	virtual TInt Flags()=0;

	virtual void Release()=0;

	virtual void Wait()=0;

	virtual void Signal()=0;

	virtual TInt Wait(TInt aTimeout);

	virtual TInt Poll();

	};

TInt MLock::Wait(TInt)

	{ return KErrNotSupported; }

TInt MLock::Poll()

	{ return KErrNotSupported; }

/*----------------------------------------------------------------------------*/

class LockS : public MLock

	{

public:

	LockS();

	virtual TInt Flags();

	virtual void Release();

	virtual void Wait();

	virtual void Signal();

	virtual TInt Wait(TInt aTimeout);

	virtual TInt Poll();

public:

	RSemaphore	iT;

	};

LockS::LockS()

	{ test_KErrNone(iT.CreateLocal(1)); }

TInt LockS::Flags()

	{ return EPollable|ETimeoutAvail; }

void LockS::Release()

	{ iT.Close(); }

void LockS::Wait()

	{ iT.Wait(); }

void LockS::Signal()

	{ iT.Signal(); }

TInt LockS::Wait(TInt aTimeout)

	{ return iT.Wait(aTimeout); }

TInt LockS::Poll()

	{ return iT.Poll(); }

/*----------------------------------------------------------------------------*/

class LockM : public MLock

	{

public:

	LockM();

	virtual TInt Flags();

	virtual void Release();

	virtual void Wait();

	virtual void Signal();

	virtual TInt Wait(TInt aTimeout);

	virtual TInt Poll();

public:

	RMutex		iT;

	};

LockM::LockM()

	{ test_KErrNone(iT.CreateLocal()); }

TInt LockM::Flags()

	{ return EPollable|ETimeoutAvail|ENestable|ELimit1; }

void LockM::Release()

	{ iT.Close(); }

void LockM::Wait()

	{ iT.Wait(); }

void LockM::Signal()

	{ iT.Signal(); }

TInt LockM::Wait(TInt aTimeout)

	{ return iT.Wait(aTimeout); }

TInt LockM::Poll()

	{ return iT.Poll(); }

/*----------------------------------------------------------------------------*/

class LockFL : public MLock

	{

public:

	LockFL();

	virtual TInt Flags();

	virtual void Release();

	virtual void Wait();

	virtual void Signal();

	virtual TInt Wait(TInt aTimeout);

	virtual TInt Poll();

public:

	RFastLock	iT;

	};

LockFL::LockFL()

	{ test_KErrNone(iT.CreateLocal()); }

TInt LockFL::Flags()

	{ return ETimeoutAvail|EPollable|ELimit1|ELooseTimeout; }

void LockFL::Release()

	{ iT.Close(); }

void LockFL::Wait()

	{ iT.Wait(); }

void LockFL::Signal()

	{ iT.Signal(); }

TInt LockFL::Wait(TInt aTimeout)

	{ return iT.Wait(aTimeout); }

TInt LockFL::Poll()

	{ return iT.Poll(); }

/*----------------------------------------------------------------------------*/

class LockCS : public MLock

	{

public:

	LockCS();

	virtual TInt Flags();

	virtual void Release();

	virtual void Wait();

	virtual void Signal();

public:

	RCriticalSection iT;

	};

LockCS::LockCS()

	{ test_KErrNone(iT.CreateLocal()); }

TInt LockCS::Flags()

	{ return ELimit1; }

void LockCS::Release()

	{ iT.Close(); }

void LockCS::Wait()

	{ iT.Wait(); }

void LockCS::Signal()

	{ iT.Signal(); }

/*----------------------------------------------------------------------------*/

class LFSR

	{

public:

	LFSR(TInt aBits, TInt aTap2, TInt aTap3=0, TInt aTap4=0);

	~LFSR();

	void Step();

	void Step(TInt aSteps);

	TBool operator==(const LFSR& a) const;

public:

	TUint32* iData;

	TInt iBits;

	TInt iTap2;

	TInt iTap3;

	TInt iTap4;

	TInt iNW;

	TInt iSh1;

	TInt iIx2;

	TInt iSh2;

	TInt iIx3;

	TInt iSh3;

	TInt iIx4;

	TInt iSh4;

	};

LFSR::LFSR(TInt aBits, TInt aTap2, TInt aTap3, TInt aTap4)

	{

	iBits = aBits;

	iTap2 = aTap2;

	iTap3 = aTap3;

	iTap4 = aTap4;

	iNW = (aBits + 31) >> 5;

	iData = (TUint32*)User::AllocZ(iNW*sizeof(TUint32));

	test(iData!=0);

	iData[0] = 1;

	iSh1 = (aBits-1)&31;

	iIx2 = (iTap2-1)>>5;

	iSh2 = (iTap2-1)&31;

	if (iTap3)

		{

		iIx3 = (iTap3-1)>>5;

		iSh3 = (iTap3-1)&31;

		}

	else

		{

		iIx3 = -1;

		iSh3 = 0;

		}

	if (iTap4)

		{

		iIx4 = (iTap4-1)>>5;

		iSh4 = (iTap4-1)&31;

		}

	else

		{

		iIx4 = -1;

		iSh4 = 0;

		}

	}

LFSR::~LFSR()

	{

	User::Free(iData);

	}

void LFSR::Step(TInt aSteps)

	{

	while (aSteps--)

		Step();

	}

void LFSR::Step()

	{

	TUint32 b = iData[iNW-1]>>iSh1;

	b ^= (iData[iIx2]>>iSh2);

	if (iIx3>=0)

		b ^= (iData[iIx3]>>iSh3);

	if (iIx4>=0)

		b ^= (iData[iIx4]>>iSh4);

	b &= 1;

	TInt i;

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

		{

		TUint32 bb = iData[i] >> 31;

		iData[i] = (iData[i]<<1)|b;

		b = bb;

		}

	iData[iNW-1] &= ((2u<<iSh1)-1u);

	}

TBool LFSR::operator==(const LFSR& a) const

	{

	if (iBits!=a.iBits || iTap2!=a.iTap2 || iTap3!=a.iTap3 || iTap4!=a.iTap4 || iNW!=a.iNW)

		return EFalse;

	if (iData==a.iData)

		return ETrue;

	if (memcompare((const TUint8*)iData, iNW, (const TUint8*)a.iData, a.iNW))

		return EFalse;

	return ETrue;

	}

/*----------------------------------------------------------------------------*/

class CStack

	{

public:	   

	CStack() {iCount=0;};

	void Push(TInt aItem) {iStack[iCount++]=aItem;};

	TInt Pop(void) {return(iStack[--iCount]);};

private:

	TInt iStack[KMaxBufferSize];

	TInt iCount;

	};

CStack stack;

TInt Producer(TAny*)

	{

	for(TInt ii=0;ii<KNumProducerItems;ii++)

		{

		slotAvailable.Wait();

		mutex.Wait();

		stack.Push(ii);

		mutex.Signal();

		itemAvailable.Signal();

		}

	return(KErrNone);

	}

TInt Consumer(TAny*)

	{

	TInt item;

	for(TInt ii=0;ii<KNumProducerItems;ii++)

		{

		itemAvailable.Wait();

		mutex.Wait();

		item=stack.Pop();

		mutex.Signal();

		slotAvailable.Signal();

		consumerArray[item]=item;

		}

	return(KErrNone);

	}

void BusyWait(TInt aMicroseconds)

	{

	TTime begin;

	begin.HomeTime();

	FOREVER

		{

		TTime now;

		now.HomeTime();

		TTimeIntervalMicroSeconds iv=now.MicroSecondsFrom(begin);

		if (iv.Int64()>=TInt64(aMicroseconds))

			return;

		}

	}

TInt MutexThreadEntryPoint1(TAny*)

//

// Mutex test thread 1

//

	{	

	TInt n = NumCpus();

	thread1Count=0;

	TBool running=ETrue;

	do

		{

		mutex.Wait();

		BusyWait(100000);

		if (arrayIndex<KMaxArraySize)

			{

			array[arrayIndex++]=EThread1ID;

			thread1Count++;

			}

		else

			running=EFalse;

		mutex.Signal();

		if (n > 1) 

			{

			// when the mutex is singaled, due to priority balancing, the other

			// thread will be scheduled to run on a CPU other than this one. The delay

			// in getting that thread to run means that this one can manage to re-claim the 

			// mutex before the other thread gets to run. So we add a small delay here 

			User::After(100); 

			}

		} while (running);

	return(KErrNone);

	}

TInt MutexThreadEntryPoint2(TAny*)

//

// Mutex test thread 2

//

	{

	TInt n = NumCpus();

	thread2Count=0;

	TBool running=ETrue;

	do

		{

		mutex.Wait();