// 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\misc\t_svr6.cpp

 // 

 //

 #define __E32TEST_EXTENSION__

 #include <e32base.h>

 #include <e32base_private.h>

 #include <e32test.h>

 #include <e32svr.h>

 #include "u32std.h"

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

 #include "../mmu/freeram.h"

 const TInt KStackSize=0x1000;

 const TInt KHeapMaxSize=0x100000;

 const TInt KMajorVersionNumber=1;

 const TInt KMinorVersionNumber=0;

 const TInt KBuildVersionNumber=1;

 const TInt KNumMessageSlots=10;

 _LIT(KServerName,"StressSvr");

 LOCAL_D RTest test(_L("T_SVR6"));

 class CMySession : public CSession2

 	{

 public:

 	CMySession();

 	virtual void ServiceL(const RMessage2& aMessage);			 //pure virtual fns.

 	void Process(const RMessage2& aMessage);

 public:

 	TInt iOutstanding;

 	TUint iSeed[2];

 	};

 class CMyServer : public CServer2

 	{

 public:

 	enum {ETest};

 public:

 	CMyServer(TInt aPriority);

 	static CMyServer* New(TInt aPriority);

 	virtual CSession2* NewSessionL(const TVersion& aVersion, const RMessage2&) const;//Overloading

 	};

 class CMyActiveScheduler : public CActiveScheduler

 	{

 public:

 	virtual void Error(TInt anError) const;  //Overloading pure virtual function

 	};

 class RStressSvr : public RSessionBase

 	{

 public:

 	TInt Connect();

 	TInt Test();

 	void Test(TRequestStatus& aStatus);

 	TVersion Version();

 	};

 class CThread : public CActive

 	{

 public:

 	CThread(TInt aPriority);

 	~CThread();

 	virtual void RunL();

 	virtual void DoCancel();

 	virtual void DisplayStats()=0;

 	virtual TBool PanicBadHandleAllowed();

 	virtual void RegisterAllowedPanic();

 	virtual void Cleanup();

 	virtual TInt ProcessStartError(TInt anError);

 	TInt Start();

 public:

 	virtual TInt StartThread()=0;

 public:

 	RThread iThread;

 	TInt iExitCount;

 	TInt iServerTerminatedCount;

 	TInt iTerminateCount;

 	};

 class CServerThread : public CThread

 	{

 public:

 	static void NewL();

 	CServerThread();

 	virtual TInt StartThread();

 	virtual void DisplayStats();

 public:

 	TInt iMessagesReceived;

 	};

 class CClientThread : public CThread

 	{

 public:

 	static void NewL(TInt anId, TInt aPrimaryId);

 	CClientThread(TInt anId);

 	virtual TInt StartThread();

 	virtual void DisplayStats();

 	virtual TBool PanicBadHandleAllowed();

 	virtual void RegisterAllowedPanic();

 	virtual void Cleanup();

 	virtual TInt ProcessStartError(TInt anError);

 public:

 	TInt iId;

 	TInt iCloses;

 	CClientThread* iPrimary;

 	RStressSvr iSession;

 	TBool iConnected;

 	TBool iWaitingToRestart;

 	};

 class CRandomTimer : public CActive

 	{

 public:

 	static void NewL();

 	CRandomTimer(TInt aPriority);

 	~CRandomTimer();

 	virtual void RunL();

 	virtual void DoCancel();

 	void Start();

 public:

 	RTimer iTimer;

 	TUint iSeed[2];

 	TInt iCount;

 	};

 class CStatsTimer : public CActive

 	{

 public:

 	static void NewL();

 	CStatsTimer(TInt aPriority);

 	~CStatsTimer();

 	virtual void RunL();

 	virtual void DoCancel();

 	void Start();

 public:

 	RTimer iTimer;

 	TInt iInitFreeRam;

 	TInt iMaxDelta;

 	TInt iCount;

 	};

 const TInt KNumPrimaryClients=3;

 const TInt KNumSecondariesPerPrimary=3;

 const TInt KNumClients=KNumPrimaryClients*KNumSecondariesPerPrimary;

 LOCAL_D CServerThread* TheServer;

 LOCAL_D CClientThread* TheClients[KNumClients];

 LOCAL_D CRandomTimer* TheRandomTimer;

 CMySession::CMySession()

 //

 // Constructor

 //

 	{

 	iSeed[0]=User::TickCount();

 	}

 CMyServer* CMyServer::New(TInt aPriority)

 //

 // Create a new CMyServer.

 //

 	{

 	return new CMyServer(aPriority);

 	}

 CMyServer::CMyServer(TInt aPriority)

 //

 // Constructor.

 //

 	: CServer2(aPriority, ESharableSessions)

 	{}

 CSession2* CMyServer::NewSessionL(const TVersion& aVersion, const RMessage2&) const

 //

 // Create a new client for this server.

 //

 	{

 	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

 	if (!User::QueryVersionSupported(v,aVersion))

 		User::Leave(KErrNotSupported);

 	return new(ELeave) CMySession;

 	}

 void CMySession::ServiceL(const RMessage2& aMessage)

 //

 // Handle messages for this server.

 //

 	{

 	++TheServer->iMessagesReceived;

 	switch (aMessage.Function())

 		{

 		case CMyServer::ETest:

 			if (iOutstanding==KNumMessageSlots-1)

 				Process(aMessage);

 			else

 				++iOutstanding;

 			break;

 		default:

 			aMessage.Complete(KErrNotSupported);

 			break;

 		}

 	}

 void CMySession::Process(const RMessage2& aMessage)

 	{

 	TUint x=Random(iSeed)&16383;

 	if (x==0)

 		User::Exit(0);			// exit the server

 	else if (x<8)

 		aMessage.Terminate(0);	// terminate the client

 	else

 		aMessage.Complete(KErrNone);

 	}

 void CMyActiveScheduler::Error(TInt anError) const

 //

 // Called if any Run() method leaves.

 //

 	{

 	User::Panic(_L("Server Error"),anError);

 	}

 TInt RStressSvr::Connect()

 //

 // Connect to the server

 //

 	{

 	TInt r=CreateSession(KServerName,Version(),KNumMessageSlots);

 	if (r==KErrNone)

 		r=ShareAuto();

 	return r;

 	}

 TInt RStressSvr::Test()

 //

 // Send a message and wait for completion.

 //

 	{

 	return SendReceive(CMyServer::ETest);

 	}

 void RStressSvr::Test(TRequestStatus& aStatus)

 //

 // Send a message asynchronously

 //

 	{

 	SendReceive(CMyServer::ETest,aStatus);

 	}

 TVersion RStressSvr::Version()

 //

 // Return the current version.

 //

 	{

 	TVersion v(KMajorVersionNumber,KMinorVersionNumber,KBuildVersionNumber);

 	return(v);

 	}

 LOCAL_C TInt ServerThread(TAny*)

 	{

 	CMyActiveScheduler* pR=new CMyActiveScheduler;

 	if (!pR)

 		return KErrNoMemory;

 	CActiveScheduler::Install(pR);

 	CMyServer* pS=CMyServer::New(0);

 	if (!pS)

 		return KErrNoMemory;

 	TInt r=pS->Start(KServerName);

 	if (r!=KErrNone)

 		return r;

 	CActiveScheduler::Start();

 	delete pS;

 	delete pR;

 	return KErrNone;

 	}

 LOCAL_C TInt ClientThread(TAny* aPtr)

 	{

 	CClientThread* pT=(CClientThread*)aPtr;

 	CClientThread* pP=pT->iPrimary;

 	TBool primary=(pP==pT);

 	RStressSvr& d=pP->iSession;

 	TUint seed[2];

 	seed[0]=User::TickCount();

 	seed[1]=0;

 	TInt r=KErrNone;

 	TInt i;

 	if (primary)

 		{

 		FOREVER

 			{

 			FOREVER

 				{

 				r=d.Connect();

 				if (r!=KErrNotFound)

 					break;

 				User::After(50000);

 				}

 			if (r!=KErrNone)

 				return r;

 			pT->iConnected=ETrue;

 			TRequestStatus s[KNumMessageSlots];

 			for (i=0; i<KNumMessageSlots-1; i++)

 				d.Test(s[i]);

 			TInt n=Random(seed)&16383;

 			for (i=0; i<n && r==KErrNone; i++)

 				r=d.Test();

 			pT->iConnected=EFalse;

 			d.Close();

 			++pT->iCloses;

 			}

 		}

 	else

 		{

 		TRequestStatus s[KNumMessageSlots];

 		for (i=0; i<KNumMessageSlots-1; i++)

 			d.Test(s[i]);

 		FOREVER

 			{

 			if (pP->iConnected)

 				{

 				RStressSvr dd;

 				dd.SetHandle(pP->iSession.Handle());

 				TInt n=Random(seed)&16383;

 				for (i=0; i<n && r==KErrNone; i++)

 					r=dd.Test();

 				}

 			TInt ms=(Random(seed)&7)+1;

 			User::AfterHighRes(ms*1000);

 			}

 		}

 	}

 CThread::CThread(TInt aPriority)

 	: CActive(aPriority)

 	{

 	}

 CThread::~CThread()

 	{

 	Cancel();

 	iThread.Kill(0);

 	iThread.Close();

 	}

 _LIT(KLitKernExec,"KERN-EXEC");

 void CThread::RunL()

 	{

 	TExitType exitType=iThread.ExitType();

 	TInt exitReason=iThread.ExitReason();

 	TBuf<32> exitCat=iThread.ExitCategory();

 	TBool bad=EFalse;

 	if (exitType==EExitKill)

 		{

 		if (exitReason!=KErrNone && exitReason!=KErrServerTerminated)

 			bad=ETrue;

 		}

 	else if (exitType==EExitPanic)

 		{

 		if (!PanicBadHandleAllowed() || exitCat!=KLitKernExec || exitReason!=EBadHandle)

 			bad=ETrue;

 		else

 			RegisterAllowedPanic();

 		}

 	if (bad)

 		{

 		TFullName n(iThread.FullName());

 		test.Printf(_L("Thread %S exited %d,%d,%S\n"),&n,exitType,exitReason,&exitCat);

 		CActiveScheduler::Stop();

 		return;

 		}

 	Cleanup();

 	iThread.Close();

 	if (exitType==EExitTerminate)

 		++iTerminateCount;

 	else if (exitType==EExitKill && exitReason==KErrNone)

 		++iExitCount;

 	else if (exitReason==KErrServerTerminated)

 		++iServerTerminatedCount;

 	TInt r=Start();

 	if (r!=KErrNone)

 		{

 		test.Printf(_L("Start thread error %d\n"),r);

 		CActiveScheduler::Stop();

 		}

 	}

 void CThread::DoCancel()

 	{

 	iThread.LogonCancel(iStatus);

 	}

 const TInt KThreadStartAttempts=3;

 TInt CThread::Start()

 	{

 	TInt r=KErrNone;

 	TInt n=KThreadStartAttempts;

 	while(n--)

 		{

 		r=StartThread();

 		if (r==KErrNone)

 			break;

 		if (r!=KErrAlreadyExists)

 			break;

 		User::After(100000);

 		}

 	if (r==KErrNone)

 		{

 		iThread.Logon(iStatus);

 		SetActive();

 		}

 	return ProcessStartError(r);

 	}

 TBool CThread::PanicBadHandleAllowed()

 	{

 	return EFalse;

 	}

 void CThread::RegisterAllowedPanic()

 	{

 	}

 void CThread::Cleanup()

 	{

 	}

 TInt CThread::ProcessStartError(TInt anError)

 	{

 	return anError;

 	}

 CServerThread::CServerThread()

 	: CThread(0)

 	{

 	}

 TInt CServerThread::StartThread()

 	{

 	TUint seed[2];

 	seed[1]=0;

 	seed[0]=User::TickCount();

 	TInt heapMin=TInt(Random(seed)&0x0f)+1;

 	heapMin<<=12;

 	TInt r=iThread.Create(KNullDesC(),ServerThread,KStackSize,heapMin,KHeapMaxSize,this);	// use unnamed thread

 	if (r!=KErrNone)

 		return r;

 	iThread.Resume();

 	return KErrNone;

 	}

 void CServerThread::NewL()

 	{

 	CServerThread* pT=new (ELeave) CServerThread;

 	TheServer=pT;

 	CActiveScheduler::Add(pT);

 	User::LeaveIfError(pT->Start());

 	}

 void CServerThread::DisplayStats()

 	{

 	test.Printf(_L("Svr  : X:%9d ST:%9d T:%9d RX:%9d\n"),iExitCount,iServerTerminatedCount,iTerminateCount,iMessagesReceived);

 	}

 CClientThread::CClientThread(TInt anId)

 	: CThread(0), iId(anId)

 	{

 	}

 TInt CClientThread::StartThread()

 	{

 	TInt r=iThread.Create(KNullDesC(),ClientThread,KStackSize,NULL,this);	// use unnamed threads

 	if (r!=KErrNone)

 		return r;

 	iSession.SetHandle(0);

 	iThread.Resume();

 	return KErrNone;

 	}

 void CClientThread::NewL(TInt anId, TInt aPrimaryId)

 	{

 	CClientThread* pT=new (ELeave) CClientThread(anId);

 	TheClients[anId]=pT;

 	pT->iPrimary=TheClients[aPrimaryId];

 	CActiveScheduler::Add(pT);

 	User::LeaveIfError(pT->Start());

 	}

 void CClientThread::DisplayStats()

 	{

 	test.Printf(_L("Cli %1d: X:%9d ST:%9d T:%9d CL:%9d\n"),iId,iExitCount,iServerTerminatedCount,iTerminateCount,iCloses);

 	}

 TBool CClientThread::PanicBadHandleAllowed()

 	{

 	return (iPrimary!=this);

 	}

 void CClientThread::RegisterAllowedPanic()

 	{

 	++iCloses;

 	}

 void CClientThread::Cleanup()

 	{

 	TInt r=KErrNone;

 	if (iPrimary==this)

 		{

 		if (!IsLocalHandle(iSession.Handle()))	// don't close if not shared yet

 			iSession.Close();

 		CClientThread* pS1=TheClients[iId+1];

 		CClientThread* pS2=TheClients[iId+2];

 		if (pS1->iWaitingToRestart)

 			r=pS1->Start();

 		if (r==KErrNone && pS2->iWaitingToRestart)

 			r=pS2->Start();

 		if (r!=KErrNone)

 			{

 			test.Printf(_L("Start thread error %d\n"),r);

 			CActiveScheduler::Stop();

 			}

 		}

 	}

 TInt CClientThread::ProcessStartError(TInt anError)

 	{

 	if (anError==KErrAlreadyExists && iPrimary!=this && !iWaitingToRestart)

 		{

 		iWaitingToRestart=ETrue;

 		return KErrNone;

 		}

 	iWaitingToRestart=EFalse;

 	return anError;

 	}

 void CRandomTimer::NewL()

 	{

 	CRandomTimer* pR=new (ELeave) CRandomTimer(20);

 	User::LeaveIfError(pR->iTimer.CreateLocal());

 	CActiveScheduler::Add(pR);

 	TheRandomTimer=pR;

 	pR->Start();

 	}

 CRandomTimer::CRandomTimer(TInt aPriority)

 	: CActive(aPriority)

 	{

 	iSeed[0]=User::TickCount();

 	}

 CRandomTimer::~CRandomTimer()

 	{

 	Cancel();

 	iTimer.Close();

 	}

 void CRandomTimer::RunL()

 	{

 	++iCount;

 	TUint x=Random(iSeed)&15;

 	CThread* pT=NULL;

 	if (x==0)

 		pT=TheServer;

 	else if (x<10)

 		{

 		pT=TheClients[x-1];

 		if (((CClientThread*)pT)->iWaitingToRestart)

 			pT=NULL;

 		}

 	if (pT)

 		pT->iThread.Kill(0);

 	Start();

 	}

 void CRandomTimer::Start()

 	{

 	TUint x=Random(iSeed)&63;

 	x+=64;

 	iTimer.HighRes(iStatus, x*1000);

 	SetActive();

 	}

 void CRandomTimer::DoCancel()

 	{

 	iTimer.Cancel();

 	}

 void CStatsTimer::NewL()

 	{

 	CStatsTimer* pT=new (ELeave) CStatsTimer(-10);

 	User::LeaveIfError(pT->iTimer.CreateLocal());

 	CActiveScheduler::Add(pT);

 	pT->Start();

 	}

 CStatsTimer::CStatsTimer(TInt aPriority)

 	: CActive(aPriority)

 	{

 	iInitFreeRam = FreeRam();

 	}

 CStatsTimer::~CStatsTimer()

 	{

 	Cancel();

 	iTimer.Close();

 	}

 void CStatsTimer::RunL()

 	{

 	TheServer->DisplayStats();

 	TInt i;

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

 		TheClients[i]->DisplayStats();

 	test.Printf(_L("RndTm: %9d\n"),TheRandomTimer->iCount);

 	TInt free_ram = FreeRam();

 	TInt delta_ram = iInitFreeRam - free_ram;

 	if (delta_ram > iMaxDelta)

 		iMaxDelta = delta_ram;

 	if (++iCount==10)

 		{

 		test.Printf(_L("Max RAM delta %dK Free RAM %08x\n"), iMaxDelta/1024, free_ram);

 		iCount=0;

 		}

 	Start();

 	}

 void CStatsTimer::Start()

 	{

 	iTimer.After(iStatus, 1000000);

 	SetActive();

 	}

 void CStatsTimer::DoCancel()

 	{

 	iTimer.Cancel();

 	}

 void InitialiseL()

 	{

 	CActiveScheduler* pA=new (ELeave) CActiveScheduler;

 	CActiveScheduler::Install(pA);

 	CServerThread::NewL();

 	TInt p;

 	TInt s;

 	TInt id=0;

 	for (p=0; p<KNumClients; p+=KNumSecondariesPerPrimary)

 		{

 		for (s=0; s<KNumSecondariesPerPrimary; s++)

 			{

 			CClientThread::NewL(id,p);

 			id++;

 			}

 		}

 	CRandomTimer::NewL();

 	CStatsTimer::NewL();

 	}

 GLDEF_C TInt E32Main()

 //

 // Test timers.

 //

 	{

 	test.Title();

 	User::SetCritical(User::ESystemCritical);

 	RThread().SetPriority(EPriorityMore);

 	User::SetJustInTime(EFalse);	// prevent the debugger picking up expected thread panics.

 	TRAPD(r,InitialiseL());

 	test(r==KErrNone);

 	CActiveScheduler::Start();

 	test(0);

 	return(0);

 	}

 // Override heap creation for this process

 // This function runs at the beginning of every thread

 // Initial heap is shared but subsequent heaps are single threaded

 TInt UserHeap::SetupThreadHeap(TBool aNotFirst, SStdEpocThreadCreateInfo& aInfo)

 	{

 	TInt r = KErrNone;

 	if (!aInfo.iAllocator && aInfo.iHeapInitialSize>0)

 		{

 		// new heap required

 		RHeap* pH = NULL;

 		r = CreateThreadHeap(aInfo, pH, 0, aNotFirst);

 		}

 	else if (aInfo.iAllocator)

 		{

 		// sharing a heap

 		RAllocator* pA = aInfo.iAllocator;

 		pA->Open();

 		User::SwitchAllocator(pA);

 		}

 	return r;

 	}