// 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

     }