#include <hal.h>

#include <e32atomics.h>

#include <u32hal.h>

RCriticalSection criticalSn;

TInt array[KMaxArraySize];

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;

	}

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

	TInt n = NumCpus();

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

			}

	TInt n = NumCpus();