// Copyright (c) 1997-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\nkern\d_implicit.cpp
// LDD for testing nanokernel implicit system lock
// 
//

#define __INCLUDE_NTHREADBASE_DEFINES__

#include "platform.h"
#include "nk_priv.h"
#include "d_implicit.h"

#ifndef __SMP__
#include "../misc/prbs.h"

const TInt KMajorVersionNumber=0;
const TInt KMinorVersionNumber=1;
const TInt KBuildVersionNumber=1;

const TInt KStackSize=1024;

inline NThreadBase::NThreadBase()
	{
	}

class DImpSysTestFactory : public DLogicalDevice
//
// Implicit system lock test LDD factory
//
	{
public:
	DImpSysTestFactory();
	virtual TInt Install();						//overriding pure virtual
	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual
	virtual TInt Create(DLogicalChannelBase*& aChannel);	//overriding pure virtual
	};

class DImpSysTest : public DLogicalChannelBase
//
// Implicit system lock test LDD channel
//
	{
public:
	DImpSysTest();
protected:
	virtual TInt Request(TInt aReqNo, TAny* a1, TAny* a2);
	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);
public:
	TInt CreateThread(TInt);
	TInt Start(TInt aTest);
	TInt Stop(SStats& aStats);
	static void Thread1(TAny*);
	static void Thread2(TAny*);
	static void Thread3(TAny*);
public:
	TInt iFailCount;
	TInt iCount1;
	TInt iCount2;
	TInt iCount3;
	TInt iTestNum;
	NFastMutex iMutex;
	NThread iThread1;	// holds fast mutex, imp sys
	NThread iThread2;	// holds system lock, not imp sys
	NThread iThread3;	// random stuff
	TUint32 iStack1[KStackSize/sizeof(TUint32)];
	TUint32 iStack2[KStackSize/sizeof(TUint32)];
	TUint32 iStack3[KStackSize/sizeof(TUint32)];
	};

TInt DImpSysTest::CreateThread(TInt a)
	{
	SNThreadCreateInfo info;
	info.iStackSize=KStackSize;
	info.iPriority=(a==3)?16:12;
	info.iTimeslice=-1;
	info.iAttributes=(TUint8)((a==1)?KThreadAttImplicitSystemLock:0);
	info.iHandlers=NULL;
	info.iFastExecTable=NULL;
	info.iSlowExecTable=NULL;
	info.iParameterBlock=(const TUint32*)this;
	info.iParameterBlockSize=0;

	NThread* pT=NULL;
	switch (a)
		{
		case 1:
			pT=&iThread1;
			info.iFunction=&Thread1;
			info.iStackBase=iStack1;
			break;
		case 2:
			pT=&iThread2;
			info.iFunction=&Thread2;
			info.iStackBase=iStack2;
			break;
		case 3:
			pT=&iThread3;
			info.iFunction=&Thread3;
			info.iStackBase=iStack3;
			break;
		default:
			return KErrArgument;
		}

	return NKern::ThreadCreate(pT,info);
	}

void DImpSysTest::Thread1(TAny* aPtr)
	{
	DImpSysTest& d=*(DImpSysTest*)aPtr;
	TScheduler* pS=TScheduler::Ptr();
	NFastMutex& m=pS->iLock;
	TUint seed[2];
	seed[0]=1;
	seed[1]=0;
	FOREVER
		{
		NKern::FMWait(&d.iMutex);
		Kern::NanoWait(1300000);	// spin for 1.3ms
		TInt c = NKern::CurrentContext();
		__NK_ASSERT_ALWAYS(c == NKern::EThread);
		NKern::FMSignal(&d.iMutex);
		if (m.iHoldingThread)
			++d.iFailCount;
		TInt x=Random(seed)&3;
		if (x)
			NKern::Sleep(x);
		++d.iCount1;
		}
	}

void DImpSysTest::Thread2(TAny* aPtr)
	{
	DImpSysTest& d=*(DImpSysTest*)aPtr;
	TUint seed[2];
	seed[0]=2;
	seed[1]=0;
	FOREVER
		{
		TInt c = NKern::CurrentContext();
		__NK_ASSERT_ALWAYS(c == NKern::EThread);
		NKern::LockSystem();
		Kern::NanoWait(1100000);	// spin for 1.1ms
		NKern::UnlockSystem();
		TInt x=Random(seed)&3;
		if (x)
			NKern::Sleep(x);
		++d.iCount2;
		}
	}

void DImpSysTest::Thread3(TAny* aPtr)
	{
	DImpSysTest& d=*(DImpSysTest*)aPtr;
	TUint seed[2];
	seed[0]=3;
	seed[1]=0;
	if (d.iTestNum==RImpSysTest::ETestPriority)
		{
		FOREVER
			{
			TInt c = NKern::CurrentContext();
			__NK_ASSERT_ALWAYS(c == NKern::EThread);
			TInt x=Random(seed)&15;
			NKern::Sleep(x+1);
			x=Random(seed)&1;
			TInt p=10+Random(seed)&3;
			if (x)
				NKern::ThreadSetPriority(&d.iThread1,p);
			else
				NKern::ThreadSetPriority(&d.iThread2,p);
			++d.iCount3;
			}
		}
	else if (d.iTestNum==RImpSysTest::ETestRoundRobin)
		{
		FOREVER
			{
			TInt c = NKern::CurrentContext();
			__NK_ASSERT_ALWAYS(c == NKern::EThread);
			TInt x=Random(seed)&15;
			NKern::Sleep(x+1);
			NKern::RotateReadyList(12);
			++d.iCount3;
			}
		}
	else if (d.iTestNum==RImpSysTest::ETestDummy)
		{
		FOREVER
			{
			TInt c = NKern::CurrentContext();
			__NK_ASSERT_ALWAYS(c == NKern::EThread);
			TInt x=Random(seed)&15;
			NKern::Sleep(x+1);
			x=Random(seed)&255;
			TInt p=10+Random(seed)&3;
			if (x<85)
				{
				NKern::LockSystem();
				NKern::ThreadSetPriority(&d.iThread1,p);
				NKern::UnlockSystem();
				}
			else if (x<170)
				{
				NKern::LockSystem();
				NKern::ThreadSetPriority(&d.iThread2,p);
				NKern::UnlockSystem();
				}
			else
				{
				NKern::FMWait(&d.iMutex);
				NKern::FMSignal(&d.iMutex);
				}
			++d.iCount3;
			}
		}
	}

TInt DImpSysTest::Start(TInt aTest)
	{
	if (iTestNum>=0)
		return KErrInUse;
	iTestNum=aTest;
	iFailCount=0;
	iCount1=0;
	iCount2=0;
	iCount3=0;
	new (&iMutex) NFastMutex;
	TInt r=CreateThread(1);
	if (r==KErrNone)
		r=CreateThread(2);
	if (r==KErrNone)
		r=CreateThread(3);
	if (r==KErrNone)
		{
		NKern::ThreadResume(&iThread3);
		NKern::ThreadResume(&iThread1);
		NKern::ThreadResume(&iThread2);
		}
	if (r!=KErrNone)
		iTestNum=-1;
	return r;
	}


TInt DImpSysTest::Stop(SStats& a)
	{
	NKern::ThreadKill(&iThread1);
	NKern::ThreadKill(&iThread2);
	NKern::ThreadKill(&iThread3);
	NKern::ThreadSetPriority(&iThread1,16);
	NKern::ThreadSetPriority(&iThread2,16);
	NKern::ThreadSetPriority(&iThread3,16);
	while (iThread1.iNState!=NThread::EDead || iThread2.iNState!=NThread::EDead || iThread3.iNState!=NThread::EDead)
		NKern::Sleep(10);
	TInt size=3*(sizeof(NThread)+KStackSize)+sizeof(NFastMutex);
	memset(&iMutex,0xbb,size);
	a.iFailCount=iFailCount;
	a.iCount1=iCount1;
	a.iCount2=iCount2;
	a.iCount3=iCount3;
	iTestNum=-1;
	return KErrNone;
	}

DImpSysTestFactory::DImpSysTestFactory()
//
// Constructor
//
    {
    iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    //iParseMask=0;//No units, no info, no PDD
    //iUnitsMask=0;//Only one thing
    }

TInt DImpSysTestFactory::Create(DLogicalChannelBase*& aChannel)
//
// Create a new DImpSysTest on this logical device
//
    {
	aChannel=new DImpSysTest;
    return aChannel?KErrNone:KErrNoMemory;
    }

TInt DImpSysTestFactory::Install()
//
// Install the LDD - overriding pure virtual
//
    {
    return SetName(&KLddName);
    }

void DImpSysTestFactory::GetCaps(TDes8& aDes) const
//
// Get capabilities - overriding pure virtual
//
    {
    TCapsImpSysTestV01 b;
    b.iVersion=TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);
    Kern::InfoCopy(aDes,(TUint8*)&b,sizeof(b));
    }

DImpSysTest::DImpSysTest()
//
// Constructor
//
	: iTestNum(-1)
    {
    }

TInt DImpSysTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& aVer)
//
// Create channel
//
    {

    if (!Kern::QueryVersionSupported(TVersion(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber),aVer))
    	return KErrNotSupported;
	return KErrNone;
	}

TInt DImpSysTest::Request(TInt aReqNo, TAny* a1, TAny*)
	{
	SStats s;
	TInt r=KErrNotSupported;
	switch (aReqNo)
		{
		case RImpSysTest::EControlStart:
			r=Start((TInt)a1);
			break;
		case RImpSysTest::EControlStop:
			{
			r=Stop(s);
			kumemput32(a1,&s,sizeof(s));
			}
			break;
		default:
			break;
		}
	return r;
	}

#endif


DECLARE_STANDARD_LDD()
	{
#ifdef __SMP__
	return 0;	// not used on SMP
#else
    return new DImpSysTestFactory;
#endif
    }