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

	}