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

RTest test(_L("T_CONDVAR2"));

const TInt KPacketSize = 1024;

const TInt KCrcSize = KPacketSize;

struct SMessage

	{

	TDblQueLink iLink;

	TUint	iSeq;

	TUint	iData[KPacketSize/4];

	TUint	iCrc;

	};

TDblQue<SMessage> Queue(0);

TUint PSeq;

TUint CSeq;

RHeap* SharedHeap;

RMutex Mutex;

RCondVar CV;

TInt NThreads;

class CThread : public CActive

	{

public:

	CThread(TInt aPriority);

	~CThread();

	virtual void RunL();

	virtual void DoCancel();

	virtual void DisplayStats()=0;

	TInt Start();

public:

	static TInt ThreadFunc(TAny* aPtr);

public:

	virtual TInt StartThread()=0;

	virtual TInt RunThread()=0;

public:

	RThread iThread;

	TInt iInnerCount;

	TInt iOuterCount;

	TInt iSuspendCount;

	TInt iExitCount;

	TInt iTerminateCount;

	TInt iCvCloseCount;

	TBool iProducer;

	TInt iId;

	TBool iCritical;

	TAny* iTempAlloc;

	};

class CProducerThread : public CThread

	{

public:

	static void NewL(TInt aId);

	CProducerThread(TInt aId);

	virtual TInt StartThread();

	virtual TInt RunThread();

	virtual void DisplayStats();

	};

class CConsumerThread : public CThread

	{

public:

	static void NewL(TInt aId);

	CConsumerThread(TInt aId);

	virtual TInt StartThread();

	virtual TInt RunThread();

	virtual void DisplayStats();

	};

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;

	TInt iBackOff;

	TInt iZeroHandle;

	CThread* iSuspended;

	};

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 KNumProducers=4;

CProducerThread* TheProducers[KNumProducers];

const TInt KNumConsumers=4;

CConsumerThread* TheConsumers[KNumConsumers];

CRandomTimer* TheRandomTimer;

CThread::CThread(TInt aPriority)

	: CActive(aPriority)

	{

	}

CThread::~CThread()

	{

	Cancel();

	iThread.Kill(0);

	iThread.Close();

	}

TInt StartAllThreads()

	{

	TInt i;

	TInt r = CV.CreateLocal();

	if (r!=KErrNone)

		return r;

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

		{

		r = TheConsumers[i]->Start();

		if (r!=KErrNone)

			return r;

		}

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

		{

		r = TheProducers[i]->Start();

		if (r!=KErrNone)

			return r;

		}

	return KErrNone;

	}

void CThread::RunL()

	{

	TExitType exitType = iThread.ExitType();

	TInt exitReason = iThread.ExitReason();

	const TDesC& exitCat = iThread.ExitCategory();

	TBool bad=EFalse;

	if (exitType==EExitKill)

		{

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

			bad=ETrue;

		}

	else if (exitType==EExitPanic)

		{

		if (exitCat!=_L("KERN-EXEC") || exitReason!=0 || CV.Handle()!=0)

			bad=ETrue;

		else

			++iCvCloseCount;

		}

	if (bad)

		{

		TFullName n(iThread.FullName());

		if (iProducer)

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

		else

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

		CActiveScheduler::Stop();

		return;

		}

	CLOSE_AND_WAIT(iThread);

	if (exitType==EExitTerminate)

		++iTerminateCount;

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

		++iExitCount;

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

		++iCvCloseCount;

	--NThreads;

	if (iTempAlloc)

		{

		SharedHeap->Free(iTempAlloc);

		iTempAlloc = NULL;

		}

	TInt r;

	if (CV.Handle()==0)

		{

		if (NThreads==0)

			r = StartAllThreads();

		else

			return;

		}

	else

		r=Start();

	if (r!=KErrNone)

		{

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

		CActiveScheduler::Stop();

		}

	}

void CThread::DoCancel()

	{

	iThread.LogonCancel(iStatus);

	}

TInt CThread::Start()

	{

	TInt r;

	FOREVER

		{

		r=StartThread();

		if (r==KErrNone)

			break;

		if (r!=KErrAlreadyExists)

			break;

		User::After(100000);

		}

	if (r==KErrNone)

		{

		iThread.Logon(iStatus);

		SetActive();

		}

	++NThreads;

	return r;

	}

TInt CThread::ThreadFunc(TAny* aPtr)

	{

	return ((CThread*)aPtr)->RunThread();

	}

CConsumerThread::CConsumerThread(TInt aId)

	: CThread(0)

	{

	iId = aId;

	}

void CConsumerThread::NewL(TInt aId)

	{

	CConsumerThread* pT=new (ELeave) CConsumerThread(aId);

	TheConsumers[aId] = pT;

	CActiveScheduler::Add(pT);

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

	}

TInt CConsumerThread::StartThread()

	{

	TInt r=iThread.Create(KNullDesC(), &ThreadFunc, KStackSize, SharedHeap, this);	// use unnamed thread

	if (r!=KErrNone)

		return r;

	iThread.Resume();

	return KErrNone;

	}

void CConsumerThread::DisplayStats()

	{

	test.Printf(_L("C%1d: I:%9d O:%9d S:%9d T:%9d C:%9d\n"), iId, iInnerCount, iOuterCount, iSuspendCount, iTerminateCount, iCvCloseCount);

	}

TInt CConsumerThread::RunThread()

	{

	Mutex.Wait();

	TInt r = KErrNone;

	FOREVER

		{

		while (Queue.IsEmpty())

			{

			r = CV.Wait(Mutex);

			++iInnerCount;

			if (r!=KErrNone)

				return r;

			}

		++iOuterCount;

		iCritical = ETrue;

		SMessage* m = Queue.First();

		m->iLink.Deque();

		iTempAlloc = m;

		TBool seq_ok = (m->iSeq == CSeq++);

		iCritical = EFalse;

		Mutex.Signal();

		if (!seq_ok)

			return KErrCorrupt;

		TUint16 crc = 0;

		Mem::Crc(crc, m->iData, KCrcSize);

		if (crc != m->iCrc)

			return KErrCorrupt;

		iCritical = ETrue;

		iTempAlloc = NULL;

		User::Free(m);

		iCritical = EFalse;

		Mutex.Wait();

		}

	}

CProducerThread::CProducerThread(TInt aId)

	: CThread(0)

	{

	iId = aId;

	}

void CProducerThread::NewL(TInt aId)

	{

	CProducerThread* pT=new (ELeave) CProducerThread(aId);

	TheProducers[aId] = pT;

	CActiveScheduler::Add(pT);

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

	}

TInt CProducerThread::StartThread()

	{

	TInt r=iThread.Create(KNullDesC(), &ThreadFunc, KStackSize, SharedHeap, this);	// use unnamed thread

	if (r!=KErrNone)

		return r;

	iThread.Resume();

	return KErrNone;

	}

void CProducerThread::DisplayStats()

	{

	test.Printf(_L("P%1d: I:%9d O:%9d S:%9d T:%9d C:%9d\n"), iId, iInnerCount, iOuterCount, iSuspendCount, iTerminateCount, iCvCloseCount);

	}

TInt CProducerThread::RunThread()

	{

	TUint seed[2];

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

	seed[1] = 0;

	FOREVER

		{

		iCritical = ETrue;

		SMessage* m = new SMessage;

		iTempAlloc = m;

		iCritical = EFalse;

		TInt i = 0;

		for (; i<KPacketSize/4; ++i)

			m->iData[i] = Random(seed);

		TUint16 crc = 0;

		Mem::Crc(crc, m->iData, KCrcSize);

		m->iCrc = crc;

		Mutex.Wait();

		iCritical = ETrue;

		m->iSeq = PSeq++;

		Queue.AddLast(*m);

		iTempAlloc = NULL;

		iCritical = EFalse;

		CV.Signal();

		Mutex.Signal();

		++iOuterCount;

		if (!(Random(seed)&1))

			User::AfterHighRes(1000);

		}

	}

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;

	FOREVER

		{

		TUint x=Random(iSeed)&511;

		TInt tn=(TInt)(Random(iSeed) % (KNumConsumers + KNumProducers));

		CThread* pT = (tn>=KNumConsumers) ? (CThread*)TheProducers[tn-KNumConsumers] : (CThread*)TheConsumers[tn];

		if (x==511)

			{

			CV.Close();

			if (iSuspended)

				{

				if (iSuspended->iThread.Handle())

					iSuspended->iThread.Resume();

				iSuspended = NULL;

				}

			break;

			}

		if (pT->iThread.Handle()==0)

			{

			++iZeroHandle;

			continue;

			}

		if (x>=500)

			{

			if (pT->iCritical)

				{

				++iBackOff;

				continue;

				}

			pT->iThread.Terminate(0);

			if (iSuspended == pT)

				iSuspended = NULL;

			break;

			}

		if (iSuspended && (x&1))

			{

			if (iSuspended->iThread.Handle())

				iSuspended->iThread.Resume();

			iSuspended = NULL;

			}

		if (!iSuspended && !(x&15))

			{

			iSuspended = pT;

			pT->iThread.Suspend();

			++pT->iSuspendCount;

			}

		TThreadPriority tp;

		if (x>=400)

			tp = EPriorityMuchMore;

		else if (x>=300)

			tp = EPriorityMore;

		else if (x>=200)

			tp = EPriorityNormal;

		else if (x>=100)

			tp = EPriorityLess;

		else

			tp = EPriorityMuchLess;

		pT->iThread.SetPriority(tp);

		break;

		}

	Start();

	}

void CRandomTimer::Start()

	{

	TUint x=Random(iSeed)&15;

	x+=1;

	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()

	{

	TInt i;

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

		TheProducers[i]->DisplayStats();

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

		TheConsumers[i]->DisplayStats();

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

	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();

	}

_LIT(KSharedHeap, "SharedHeap");

void InitialiseL()

	{

	PSeq = 0;

	CSeq = 0;

	User::LeaveIfError(Mutex.CreateLocal());

	User::LeaveIfError(CV.CreateLocal());

	User::LeaveIfNull(SharedHeap = UserHeap::ChunkHeap(&KSharedHeap, 0x1000, 0x01000000));

	CActiveScheduler* pA=new (ELeave) CActiveScheduler;

	CActiveScheduler::Install(pA);

	TInt id;

	for (id=0; id<KNumConsumers; ++id)

		CConsumerThread::NewL(id);

	for (id=0; id<KNumProducers; ++id)

		CProducerThread::NewL(id);

	CRandomTimer::NewL();

	CStatsTimer::NewL();

	}

GLDEF_C TInt E32Main()

//

// Test timers.

//

	{

	test.Title();

	RThread().SetPriority(EPriorityAbsoluteHigh);

	TRAPD(r,InitialiseL());

	test(r==KErrNone);

	User::SetJustInTime(EFalse);

	CActiveScheduler::Start();

	test(0);

	return(0);

	}