// Copyright (c) 2006-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\fastmutex.cpp

// 

//

#include <nktest/nkutils.h>

const TInt KReadCount = 100000;

//const TInt KReadCount = 2000000;

#ifdef __CPU_ARM

const TUint32 KTickLimit = (KReadCount>100000) ? (((TUint32)KReadCount)/10*18) : 180000u;

#else

const TUint32 KTickLimit = (KReadCount>100000) ? (((TUint32)KReadCount)/10*6) : 60000u;

#endif

class NFastMutexX

	{

public:

	TInt iRefCount;

	NFastMutex* iMutex;

public:

	NFastMutexX();

	~NFastMutexX();

	void Create();

	TBool Open();

	TBool Close();

	TBool Wait();

	TBool Signal();

	TBool WaitFull();

	TBool SignalFull();

	};

NFastMutexX::NFastMutexX()

	:	iRefCount(0), iMutex(0)

	{}

void NFastMutexX::Create()

	{

	iMutex = new NFastMutex;

	TEST_OOM(iMutex);

	__e32_atomic_store_rel32(&iRefCount, 1);

	}

NFastMutexX::~NFastMutexX()

	{

	TEST_RESULT2(iRefCount==0, "Bad mutex ref count %d %08x", iRefCount, this);

	memset(this, 0xbf, sizeof(*this));

	}

TBool NFastMutexX::Open()

	{

	return __e32_atomic_tas_ord32(&iRefCount, 1, 1, 0) >  0;

	}

TBool NFastMutexX::Close()

	{

	TInt r = __e32_atomic_tas_ord32(&iRefCount, 1, -1, 0);

	if (r==1)

		{

		memset(iMutex, 0xbf, sizeof(NFastMutex));

		delete iMutex;

		iMutex = 0;

		}

	return r==1;

	}

TBool NFastMutexX::Wait()

	{

	if (Open())

		{

		NKern::FMWait(iMutex);

		return TRUE;

		}

	return FALSE;

	}

TBool NFastMutexX::Signal()

	{

	NKern::FMSignal(iMutex);

	return Close();

	}

TBool NFastMutexX::WaitFull()

	{

	if (Open())

		{

		FMWaitFull(iMutex);

		return TRUE;

		}

	return FALSE;

	}

TBool NFastMutexX::SignalFull()

	{

	FMSignalFull(iMutex);

	return Close();

	}

void FMTest0()

	{

	TEST_PRINT("Testing non-contention case");

	NFastMutex m;

	TEST_RESULT(!m.HeldByCurrentThread(), "Mutex held by current thread");

	TEST_RESULT(!NKern::HeldFastMutex(), "Current thread holds a fast mutex");

	NKern::FMWait(&m);

	TEST_RESULT(m.HeldByCurrentThread(), "Mutex not held by current thread");

	TEST_RESULT(NKern::HeldFastMutex()==&m, "HeldFastMutex() incorrect");

	NKern::FMSignal(&m);

	TEST_RESULT(!m.HeldByCurrentThread(), "Mutex held by current thread");

	TEST_RESULT(!NKern::HeldFastMutex(), "Current thread holds a fast mutex");

	}

struct SFMTest1Info

	{

	NFastMutex iMutex;

	volatile TUint32* iBlock;

	TInt iBlockSize;	// words

	TInt iPriorityThreshold;

	volatile TBool iStop;

	NThread* iThreads[3*KMaxCpus];

	};

void FMTest1Thread(TAny* a)

	{

	SFMTest1Info& info = *(SFMTest1Info*)a;

	NThread* pC = NKern::CurrentThread();

	TUint32 seed[2] = {(TUint32)pC, 0};

	TBool wait = (pC->iPriority > info.iPriorityThreshold);

	TBool thread0 = (pC==info.iThreads[0]);

	TInt n = 0;

	while (!info.iStop)

		{

		if (thread0)

			NKern::ThreadSetPriority(pC, 11);

		NKern::FMWait(&info.iMutex);

		TBool ok = verify_block((TUint32*)info.iBlock, info.iBlockSize);

		TEST_RESULT(ok, "Block corrupt");

		++info.iBlock[0];

		setup_block((TUint32*)info.iBlock, info.iBlockSize);

		++n;

		NKern::FMSignal(&info.iMutex);

		if (wait)

			{

			TUint32 x = random(seed) & 1;

			NKern::Sleep(x+1);

			}

		}

	TEST_PRINT2("Thread %T ran %d times", pC, n);

	}

void FMTest1PInterfererThread(TAny* a)

	{

	SFMTest1Info& info = *(SFMTest1Info*)a;

	NThread* pC = NKern::CurrentThread();

	TEST_PRINT1("Thread %T start", pC);

	TUint32 seed[2] = {(TUint32)pC, 0};

	NThread* t0 = info.iThreads[0];

	TInt n = 0;

	while (!__e32_atomic_load_acq32(&info.iStop))

		{

		while (!__e32_atomic_load_acq32(&info.iStop) && t0->iPriority != 11)

			__chill();

		TUint32 x = random(seed) & 2047;

		while(x)

			{

			__e32_atomic_add_ord32(&x, TUint32(-1));

			}

		if (__e32_atomic_load_acq32(&info.iStop))

			break;

		NKern::ThreadSetPriority(t0, 9);

		++n;

		}

	TEST_PRINT2("Thread %T ran %d times", pC, n);

	}

void FMTest1()

	{

	TEST_PRINT("Testing mutual exclusion");

	NFastSemaphore exitSem(0);

	SFMTest1Info* pI = new SFMTest1Info;

	TEST_OOM(pI);

	memclr(pI, sizeof(SFMTest1Info));

	pI->iBlockSize = 256;

	pI->iBlock = (TUint32*)malloc(pI->iBlockSize*sizeof(TUint32));

	TEST_OOM(pI->iBlock);

	pI->iPriorityThreshold = 10;

	pI->iBlock[0] = 0;

	setup_block((TUint32*)pI->iBlock, pI->iBlockSize);

	pI->iStop = FALSE;

	TInt cpu;

	TInt threads = 0;

	for_each_cpu(cpu)

		{

		CreateThreadSignalOnExit("FMTest1H", &FMTest1Thread, 11, pI, 0, KSmallTimeslice, &exitSem, cpu);

		CreateThreadSignalOnExit("FMTest1L0", &FMTest1Thread, 10, pI, 0, KSmallTimeslice, &exitSem, cpu);

		CreateThreadSignalOnExit("FMTest1L1", &FMTest1Thread, 10, pI, 0, KSmallTimeslice, &exitSem, cpu);

		threads += 3;

		}

	FOREVER

		{

		NKern::Sleep(1000);

		TEST_PRINT1("%d", pI->iBlock[0]);

		if (pI->iBlock[0] > 65536)

			{

			pI->iStop = TRUE;

			break;

			}

		}

	while (threads--)

		NKern::FSWait(&exitSem);

	TEST_PRINT1("Total iterations %d", pI->iBlock[0]);

	free((TAny*)pI->iBlock);

	free(pI);

	}

void FMTest1P()

	{

	TEST_PRINT("Testing priority change");

	if (NKern::NumberOfCpus()==1)

		return;

	NFastSemaphore exitSem(0);

	SFMTest1Info* pI = new SFMTest1Info;

	TEST_OOM(pI);

	memclr(pI, sizeof(SFMTest1Info));

	TEST_PRINT1("Info@0x%08x", pI);

	pI->iBlockSize = 256;

	pI->iBlock = (TUint32*)malloc(pI->iBlockSize*sizeof(TUint32));

	TEST_OOM(pI->iBlock);

	pI->iPriorityThreshold = 9;

	pI->iBlock[0] = 0;

	setup_block((TUint32*)pI->iBlock, pI->iBlockSize);

	pI->iStop = FALSE;

	TInt cpu;

	TInt threadCount = 0;

	TInt pri = 9;

	char name[16] = "FMTest1P.0";

	for_each_cpu(cpu)

		{

		name[9] = (char)(threadCount + '0');

		if (cpu==1)

			pI->iThreads[threadCount] = CreateThreadSignalOnExit("FMTest1PInterferer", &FMTest1PInterfererThread, 12, pI, 0, KSmallTimeslice, &exitSem, 1);

		else

			pI->iThreads[threadCount] = CreateThreadSignalOnExit(name, &FMTest1Thread, pri, pI, 0, KSmallTimeslice, &exitSem, cpu);

		pri = 10;

		threadCount++;

		}

	TUint32 b0 = 0xffffffffu;

	FOREVER

		{

		NKern::Sleep(1000);

		TUint32 b = pI->iBlock[0];

		TEST_PRINT1("%d", b);

		if (b > 1048576)

			{

			pI->iStop = TRUE;

			break;

			}

		if (b == b0)

			{

			__crash();

			}

		b0 = b;

		}

	while (threadCount--)

		NKern::FSWait(&exitSem);

	TEST_PRINT1("Total iterations %d", pI->iBlock[0]);

	free((TAny*)pI->iBlock);

	free(pI);

	}

struct SFMTest2InfoC

	{

	NFastMutex iMutex;

	TInt iMax;

	TBool iStop;

	};

struct SFMTest2InfoT

	{

	SFMTest2InfoC* iCommon;

	TUint32 iMaxDelay;

	TInt iIterations;

	TUint32 iSpinTime;

	TUint32 iBlockTimeMask;

	TUint32 iBlockTimeOffset;

	NThread* iThread;

	union {

		TUint8 iSpoiler;

		TUint32 iDelayThreshold;

		};

	};

TBool StopTest = FALSE;

void FMTest2Thread(TAny* a)

	{

	SFMTest2InfoT& t = *(SFMTest2InfoT*)a;

	SFMTest2InfoC& c = *t.iCommon;

	NThreadBase* pC = NKern::CurrentThread();

	TUint32 seed[2] = {(TUint32)pC, 0};

	while (!c.iStop)

		{

		++t.iIterations;

		if (t.iSpoiler)

			{

			nfcfspin(t.iSpinTime);

			}

		else

			{

			TUint32 initial = norm_fast_counter();

			NKern::FMWait(&c.iMutex);

			TUint32 final = norm_fast_counter();

			TUint32 delay = final - initial;

			if (delay > t.iMaxDelay)

				{

				t.iMaxDelay = delay;

				__e32_atomic_add_ord32(&c.iMax, 1);

				if (delay > t.iDelayThreshold)

					__crash();

				}

			nfcfspin(t.iSpinTime);

			NKern::FMSignal(&c.iMutex);

			}

		if (t.iBlockTimeMask)

			{

			TUint32 sleep = (random(seed) & t.iBlockTimeMask) + t.iBlockTimeOffset;

			NKern::Sleep(sleep);

			}

		}

	TEST_PRINT3("Thread %T %d iterations, max delay %d", pC, t.iIterations, t.iMaxDelay);

	}

SFMTest2InfoT* CreateFMTest2Thread(	const char* aName,

									SFMTest2InfoC& aCommon,

									TUint32 aSpinTime,

									TUint32 aBlockTimeMask,

									TUint32 aBlockTimeOffset,

									TBool aSpoiler,

									TInt aPri,

									TInt aTimeslice,

									NFastSemaphore& aExitSem,

									TUint32 aCpu

								  )

	{

	SFMTest2InfoT* ti = new SFMTest2InfoT;

	TEST_OOM(ti);

	ti->iCommon = &aCommon;

	ti->iMaxDelay = 0;

	ti->iDelayThreshold = 0xffffffffu;

	ti->iIterations = 0;

	ti->iSpinTime = aSpinTime;

	ti->iBlockTimeMask = aBlockTimeMask;

	ti->iBlockTimeOffset = aBlockTimeOffset;

	ti->iSpoiler = (TUint8)aSpoiler;

	ti->iThread = 0;

	NThread* t = CreateUnresumedThreadSignalOnExit(aName, &FMTest2Thread, aPri, ti, 0, aTimeslice, &aExitSem, aCpu);

	ti->iThread = t;

	DEBUGPRINT("Thread at %08x, Info at %08x", t, ti);

	return ti;

	}

extern void DebugPrint(const char*, int);

void FMTest2()

	{

	TEST_PRINT("Testing priority inheritance");

	NFastSemaphore exitSem(0);

	SFMTest2InfoC common;

	common.iMax = 0;

	common.iStop = FALSE;

	TInt cpu;

	TInt threads = 0;

	SFMTest2InfoT* tinfo[32];

	memset(tinfo, 0, sizeof(tinfo));

	DEBUGPRINT("Common info at %08x", &common);

	for_each_cpu(cpu)

		{

		tinfo[threads++] = CreateFMTest2Thread("FMTest2H", common, 500, 7, 7, FALSE, 60-cpu, KSmallTimeslice, exitSem, cpu);

		tinfo[threads++] = CreateFMTest2Thread("FMTest2L", common, 500, 0, 0, FALSE, 11, KSmallTimeslice, exitSem, cpu);

		tinfo[threads++] = CreateFMTest2Thread("FMTest2S", common, 10000, 15, 31, TRUE, 32, -1, exitSem, cpu);

		}

	tinfo[0]->iDelayThreshold = 0x300;

	TInt max = 0;

	TInt i;

	TInt iter = 0;

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

		{

		NKern::ThreadResume(tinfo[i]->iThread);

		}

	FOREVER

		{

		NKern::Sleep(5000);

		DebugPrint(".",1);	// only print one char since interrupts are disabled for entire time

		TInt max_now = common.iMax;

		if (max_now==max)

			{

			if (++iter==20)

				break;

			}

		else

			{

			iter = 0;

			max = max_now;

			}

		}

	common.iStop = TRUE;

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

		NKern::FSWait(&exitSem);

	DebugPrint("\r\n",2);

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

		{

		TEST_PRINT3("%d: Iter %10d Max %10d", i, tinfo[i]->iIterations, tinfo[i]->iMaxDelay);

		if (i==0)

			{

			TEST_RESULT(tinfo[0]->iMaxDelay < 700, "Thread 0 MaxDelay too high");

			}

		else if (i==3)

			{

			TEST_RESULT(tinfo[3]->iMaxDelay < 1200, "Thread 1 MaxDelay too high");

			}

		}

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

		delete tinfo[i];

	}

struct SWriterInfo

	{

	void DoInOp(TUint aWhich);

	void DoOutOp(TUint aWhich);

	TUint32* iBuf[6];

	TInt iWords;

	volatile TUint32 iWrites;

	volatile TUint32 iIn;

	volatile TBool iStop;

	NFastMutex* iM;

	NFastMutexX* iMX;

	TUint32 iInSeq;		// do nibble 0 followed by nibble 1 followed by nibble 2

	TUint32 iOutSeq;	// 0=nothing, 1=mutex, 2=freeze, 3=CS, 4=mutex the long way

						// 5 = mutexX, 6 = mutexX the long way, 7=join frozen group

						// 8 = join mutex-holding group, 9=join idle group

	TInt iFrz;

	TInt iPriority;

	TInt iTimeslice;

	TInt iCpu;

	NFastSemaphore iHandshake;

	TUint64 iInitFastCounter;

	TUint32 iFastCounterDelta;

	NThread* volatile iIvThrd;

#ifdef __SMP__

	NThreadGroup* iGroup;

#endif

	};

void SWriterInfo::DoInOp(TUint aWhich)

	{

	switch ((iInSeq>>(aWhich*4))&0xf)

		{

		case 0:	break;

		case 1:	NKern::FMWait(iM); break;

		case 2: iFrz=NKern::FreezeCpu(); break;

		case 3: NKern::ThreadEnterCS(); break;

		case 4: FMWaitFull(iM); break;

		case 5: iMX->Wait(); break;

		case 6: iMX->WaitFull(); break;

#ifdef __SMP__

		case 7:

		case 8:

		case 9:	NKern::JoinGroup(iGroup); break;

#endif

		}

	}

void SWriterInfo::DoOutOp(TUint aWhich)

	{

	switch ((iOutSeq>>(aWhich*4))&0xf)

		{

		case 0:	break;

		case 1:	NKern::FMSignal(iM); break;

		case 2: NKern::EndFreezeCpu(iFrz); break;

		case 3: NKern::ThreadLeaveCS(); break;

		case 4: FMSignalFull(iM); break;

		case 5: iMX->Signal(); break;

		case 6: iMX->SignalFull(); break;

#ifdef __SMP__

		case 7:

		case 8:

		case 9:	NKern::LeaveGroup(); break;

#endif

		}

	}

struct SReaderInfo

	{

	enum TTestType

		{

		ETimeslice,

		ESuspend,

		EKill,

		EMigrate,

		EInterlockedSuspend,

		EInterlockedKill,

		EInterlockedMigrate,

		EMutexLifetime,