// Copyright (c) 1999-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\realtime\t_lat2.cpp

// 

//

#include <e32test.h>

#include <e32svr.h>

#include <e32property.h>

#include <e32atomics.h>

#include "runtests.h"

#include "d_latncy.h"

_LIT(KLatencyLddFileName,"D_LATNCY");

_LIT(KThreadName,"LatencyThreadU");

RTest test(_L("Latency"));

RThread Main;

TUint TicksPerMs;

struct SFullLatencyResults : public SLatencyResults

	{

	TUint iKernRetAddr;

	TUint iUserRetAddr;

	TInt64 iCount;

	TInt64 iSumIntTicks;

	TInt64 iSumKernTicks;

	TInt64 iSumUserTicks;

	TUint iIntCpsr;

	TUint iKernCpsr;

	TUint iKernR14;

	TUint iUserCpsr;

	TUint iUserR14;

	void Update(SLatencyResults& aResults);

	};

SFullLatencyResults Latencies;

volatile TUint32 UpdateCount=0;

TUint TimerToMicroseconds(TUint aTimerValue)

	{

	return (aTimerValue*1000+TicksPerMs-1)/TicksPerMs;

	}

void SFullLatencyResults::Update(SLatencyResults& aResults)

	{

	__e32_atomic_add_acq32(&UpdateCount, 1);

	// memory barrier

	if (aResults.iIntTicks>iIntTicks)

		{

		iIntTicks=aResults.iIntTicks;

		iIntRetAddr=aResults.iIntRetAddr;

#ifdef __CAPTURE_EXTRAS

		iIntCpsr=aResults.iIntSpsr;

		iIntR14=aResults.iIntR14;

#endif

		}

	if (aResults.iKernThreadTicks>iKernThreadTicks)

		{

		iKernThreadTicks=aResults.iKernThreadTicks;

		iKernRetAddr=aResults.iIntRetAddr;

#ifdef __CAPTURE_EXTRAS

		iKernCpsr=aResults.iIntSpsr;

		iKernR14=aResults.iIntR14;

#endif

		}

	if (aResults.iUserThreadTicks>iUserThreadTicks)

		{

		iUserThreadTicks=aResults.iUserThreadTicks;

		iUserRetAddr=aResults.iIntRetAddr;

#ifdef __CAPTURE_EXTRAS

		iUserCpsr=aResults.iIntSpsr;

		iUserR14=aResults.iIntR14;

#endif

		}

	iSumIntTicks+=aResults.iIntTicks;

	iSumKernTicks+=aResults.iKernThreadTicks;

	iSumUserTicks+=aResults.iUserThreadTicks;

	++iCount;

	// memory barrier

	__e32_atomic_add_rel32(&UpdateCount, 1);

	}

TInt LatencyThread(TAny* aStatus)

	{

	TRequestStatus* pS=(TRequestStatus*)aStatus;

	RLatency l;

	TInt r=l.Open();

	if (r!=KErrNone)

		return r;

	TicksPerMs=l.TicksPerMs();

	Mem::FillZ(&Latencies,sizeof(Latencies));

	Main.RequestComplete(pS,0);

	SLatencyResults results;

	l.Start();

	volatile TInt forever = 1;

	while(forever)

		{

		User::WaitForAnyRequest();

		l.GetResults(results);

		Latencies.Update(results);

		}

	return 0;

	}

void GetLatencies(SFullLatencyResults& aResults)

	{

	FOREVER

		{

		TUint32 u1 = UpdateCount;

		__e32_memory_barrier();

		aResults=Latencies;

		__e32_memory_barrier();

		TUint32 u2 = UpdateCount;

		if (u1==u2 && !(u1&1))	// no good if it changed partway through or was changing when we started

			break;

		}

	}

_LIT(KPrefixRuntests, "RUNTESTS: RT");

void DisplayMaxValues(const TDesC& aPrefix)

	{

	SFullLatencyResults v;

	GetLatencies(v);

	TUint i=TimerToMicroseconds(v.iIntTicks);

	TUint k=TimerToMicroseconds(v.iKernThreadTicks);

	TUint u=TimerToMicroseconds(v.iUserThreadTicks);

	TUint ia=v.iIntRetAddr;

	TUint ka=v.iKernRetAddr;

	TUint ua=v.iUserRetAddr;

	test.Printf(_L("%SMAX: Int %4d %08x Kern %4d %08x User %4d %08x\n"),&aPrefix,i,ia,k,ka,u,ua);

	}

void DisplayAvgValues(const TDesC& aPrefix)

	{

	SFullLatencyResults v;

	GetLatencies(v);

	TUint i=TimerToMicroseconds(I64LOW(v.iSumIntTicks/v.iCount));

	TUint k=TimerToMicroseconds(I64LOW(v.iSumKernTicks/v.iCount));

	TUint u=TimerToMicroseconds(I64LOW(v.iSumUserTicks/v.iCount));

	test.Printf(_L("%SAVG: Int %4d Kern %4d User %4d Count %Ld\n"),&aPrefix,i,k,u,v.iCount);

	}

#ifdef __CAPTURE_EXTRAS

void DisplayExtras(const TDesC& aPrefix)

	{

	SFullLatencyResults v;

	GetLatencies(v);

	test.Printf(_L("%SInt : Cpsr %08x R14 %08x\n"),&aPrefix,v.iIntCpsr,v.iIntR14);

	test.Printf(_L("%SKern: Cpsr %08x R14 %08x\n"),&aPrefix,v.iKernCpsr,v.iKernR14);

	test.Printf(_L("%SUser: Cpsr %08x R14 %08x\n"),&aPrefix,v.iUserCpsr,v.iUserR14);

	}

#endif

void ClearMaxValues()

	{

	Mem::FillZ(&Latencies,6*sizeof(TUint));

	}

void ClearAvgValues()

	{

	Mem::FillZ(&Latencies.iCount,4*sizeof(TInt64));

	}

_LIT_SECURITY_POLICY_PASS(KPersistencePropReadPolicy);

_LIT_SECURITY_POLICY_PASS(KPersistencePropWritePolicy);

void AnnouncePersistence()

	{

	TInt r = RProperty::Define(KRuntestsIntentionalPersistenceKey, RProperty::EInt, KPersistencePropReadPolicy, KPersistencePropWritePolicy);

	test(r==KErrNone || r==KErrAlreadyExists);

	r = RProperty::Set(RProcess().SecureId(), KRuntestsIntentionalPersistenceKey, KRuntestsIntentionalPersistenceValue);

	test(r==KErrNone);

	}

class CConsoleReader : public CActive

	{

public:

	CConsoleReader();

	static void New();

	void Start();

	virtual void RunL();

	virtual void DoCancel();

public:

	CConsoleBase* iConsole;

	};

CConsoleReader::CConsoleReader()

	:	CActive(0)

	{

	}

void CConsoleReader::RunL()

	{

	TKeyCode k = iConsole->KeyCode();

	switch(k)

		{

		case '1':

			test.Printf(_L("Clearing Maximum Values\n"));

			ClearMaxValues();

			break;

		case '2':

			DisplayMaxValues(KNullDesC);

			break;

		case '3':

			test.Printf(_L("Clearing Average Values\n"));

			ClearAvgValues();

			break;

		case '4':

			DisplayAvgValues(KNullDesC);

			break;

#ifdef __CAPTURE_EXTRAS

		case '5':

			DisplayExtras(KNullDesC);

			break;

#endif

		case 'x':

		case 'X':

			CActiveScheduler::Stop();

			return;

		default:

			break;

		}

	Start();

	}

void CConsoleReader::DoCancel()

	{

	iConsole->ReadCancel();

	}

void CConsoleReader::New()

	{

	CConsoleReader* crdr = new CConsoleReader;

	test(crdr != NULL);

	crdr->iConsole = test.Console();

	CActiveScheduler::Add(crdr);

	crdr->Start();

	}

void CConsoleReader::Start()

	{

	iConsole->Read(iStatus);

	SetActive();

	}

class CPubSubWatcher : public CActive

	{

public:

	CPubSubWatcher();

	static void New();

	void Start();

	virtual ~CPubSubWatcher();

	virtual void RunL();

	virtual void DoCancel();

public:

	RProperty iProperty;

	};

CPubSubWatcher::CPubSubWatcher()

	:	CActive(0)

	{

	}

void CPubSubWatcher::RunL()

	{

	Start();

	DisplayMaxValues(KPrefixRuntests);

	DisplayAvgValues(KPrefixRuntests);

	}

void CPubSubWatcher::DoCancel()

	{

	iProperty.Cancel();

	}

void CPubSubWatcher::New()

	{

	CPubSubWatcher* psw = new CPubSubWatcher;

	test(psw != NULL);

	TInt r = psw->iProperty.Attach(KRuntestsCategory, KRuntestsCurrentTestKey, EOwnerThread);

	test(r==KErrNone);

	CActiveScheduler::Add(psw);

	psw->Start();

	}

void CPubSubWatcher::Start()

	{

	iProperty.Subscribe(iStatus);

	SetActive();

	}

CPubSubWatcher::~CPubSubWatcher()

	{

	iProperty.Close();

	}

GLDEF_C TInt E32Main()

	{

#ifdef _DEBUG

	// Don't run automatically on debug builds

	TUint32 creator_sid = User::CreatorSecureId();

	if (creator_sid == TUint32(KRuntestsCategoryValue))

		return KErrNone;

#endif

	// disable anything which will interfere, e.g. plat sec diagnostics

	User::SetDebugMask(UserSvr::DebugMask(2)|4, 2);

	test.Title();

	test.Printf(_L("*** Please note ***\n"));

	test.Printf(_L("\n"));

	test.Printf(_L("t_lat2 runs in the backgroud to measure latency while other tests are\n"));

	test.Printf(_L("running.  It should not be run as a standalone test, only as part of a\n"));

	test.Printf(_L("test run coordinated by runtests.  If run on its owm, it will simply wait\n"));

	test.Printf(_L("forever.\n"));

	test.Printf(_L("\n"));

	test.Start(_L("Load LDD"));

	TInt r=User::LoadLogicalDevice(KLatencyLddFileName);

	test(r==KErrNone || r==KErrAlreadyExists);

	test.Next(_L("Duplicate handle"));

	r=Main.Duplicate(RThread());

	test(r==KErrNone);

	test.Next(_L("Create thread"));

	RThread t;

	TRequestStatus sx;

	TRequestStatus sc;

	r=t.Create(KThreadName,LatencyThread,0x1000,NULL,&sc);

	test(r==KErrNone);

	t.Logon(sx);

	t.Resume();

	User::WaitForRequest(sx,sc);

	if (sx!=KRequestPending)

		{

		if (t.ExitType()==EExitKill && t.ExitReason()==KErrAlreadyExists)

			{

			test.Printf(_L("T_LAT2 already running.\n"));

			test.End();

			return 0;

			}

		test.Printf(_L("Initialisation failed, error %d\n"),sx.Int());

		test(0);

		}

	test(sc==KErrNone);

	CTrapCleanup* tcln = CTrapCleanup::New();

	test(tcln != NULL);

	CActiveScheduler* as = new CActiveScheduler;

	test(as != NULL);

	CActiveScheduler::Install(as);

	CConsoleReader::New();

	CPubSubWatcher::New();

	AnnouncePersistence();

	RProcess::Rendezvous(KErrNone);

	CActiveScheduler::Start();

	// latency test over

	User::SetDebugMask(UserSvr::DebugMask(2)&~4, 2);

	test.End();

	return 0;

	}