// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#include <e32std.h>

#include <centralrepository.h>

#include "t_cenrep_helper.h"

#include <hal.h>

#include <hal_data.h>

#include "srvPerf.h"

#include "srvreqs.h"

#include "TE_PerfTestStep.h"

#ifdef __CENTREP_SERVER_PERFTEST__

// Function DecodeEventAndData

// Extract the high 8-bit event Id and the low 24-bit data

// from the 32 bit integer.

//

// param aEntry - the 32 bit integer to decode

// param aEventId - return the EventId Id.

// param aData - return the 24-bit data value

inline

void DecodeEventAndData(TUint32 aEntry, TUint& aEventId, TUint32& aData)

	{

	aEventId = (aEntry >> KEventIdShiftBits) & KEventIdMask;

	aData = aEntry & KDataMask;

	}

// Function FindRepUid

// Search for the given Repository UID in aArray.

//

// param aArray - the RArray containing a number of repositories.

// param aRepUid - the rep UID to search for.

// Return - if aRepUid is in the array, return its index in array,

//          else return KErrNotFound.

TInt FindRepUid(const RArray<TRepStatistics>& aArray, TUint32 aRepUid)

	{

	for (TInt i = 0; i < aArray.Count(); i++)

		{

		if (aArray[i].MatchUid(aRepUid))

			return i;

		}

	return KErrNotFound;

	}

// Function GetFuncCodeName

// Map CentRep function code to string.

//

// param aFunc - the function code to map to string.

// Return - textual representation of the function code.

_LIT(KEInitialise, "Open");

_LIT(KECreateInt, "ECreateInt");

_LIT(KECreateReal, "ECreateReal");

_LIT(KECreateString, "ECreateString");

_LIT(KEDelete, "EDelete");

_LIT(KEGetInt, "EGetInt");

_LIT(KESetInt, "ESetInt");

_LIT(KEGetReal, "EGetReal");

_LIT(KESetReal, "ESetReal");

_LIT(KEGetString, "EGetString");

_LIT(KESetString, "ESetString");

_LIT(KEFind, "EFind");

_LIT(KEFindEqInt, "EFindEqInt");

_LIT(KEFindEqReal, "EFindEqReal");

_LIT(KEFindEqString, "EFindEqString");

_LIT(KEFindNeqInt, "EFindNeqInt");

_LIT(KEFindNeqReal, "EFindNeqReal");

_LIT(KEFindNeqString, "EFindNeqString");

_LIT(KEGetFindResult, "EGetFindResult");

_LIT(KENotifyRequestCheck, "ENotifyRequestCheck");

_LIT(KENotifyRequest, "ENotifyRequest");

_LIT(KENotifyCancel, "ENotifyCancel");

_LIT(KENotifyCancelAll, "ENotifyCancelAll");

_LIT(KEGroupNotifyRequest, "EGroupNotifyRequest");

_LIT(KEGroupNotifyCancel, "EGroupNotifyCancel");

_LIT(KEReset, "EReset");

_LIT(KEResetAll, "EResetAll");

_LIT(KETransactionStart, "ETransactionStart");

_LIT(KETransactionCommit, "ETransactionCommit");

_LIT(KETransactionCancel, "ETransactionCancel");

_LIT(KEMove, "EMove");

_LIT(KETransactionState, "ETransactionState");

_LIT(KETransactionFail, "ETransactionFail");

_LIT(KEDeleteRange, "EDeleteRange");

_LIT(KEGetSetParameters, "EGetSetParameters");

_LIT(KEClose, "EClose");

_LIT(KEEvict, "Evict");

_LIT(KUnknownFunction, "UnknownCode");

const TDesC* GetFuncCodeName(TUint aFunc)

	{

	switch (aFunc)

		{

		case EInitialise: return(&KEInitialise);

		case ECreateInt: return(&KECreateInt);

		case ECreateReal: return(&KECreateReal);

		case ECreateString: return(&KECreateString);

		case EDelete: return(&KEDelete);

		case EGetInt: return(&KEGetInt);

		case ESetInt: return(&KESetInt);

		case EGetReal: return(&KEGetReal);

		case ESetReal: return(&KESetReal);

		case EGetString: return(&KEGetString);

		case ESetString: return(&KESetString);

		case EFind: return(&KEFind);

		case EFindEqInt: return(&KEFindEqInt);

		case EFindEqReal: return(&KEFindEqReal);

		case EFindEqString: return(&KEFindEqString);

		case EFindNeqInt: return(&KEFindNeqInt);

		case EFindNeqReal: return(&KEFindNeqReal);

		case EFindNeqString: return(&KEFindNeqString);

		case EGetFindResult: return(&KEGetFindResult);

		case ENotifyRequestCheck: return(&KENotifyRequestCheck);

		case ENotifyRequest: return(&KENotifyRequest);

		case ENotifyCancel: return(&KENotifyCancel);

		case ENotifyCancelAll: return(&KENotifyCancelAll);

		case EGroupNotifyRequest: return(&KEGroupNotifyRequest);

		case EGroupNotifyCancel: return(&KEGroupNotifyCancel);

		case EReset: return(&KEReset);

		case EResetAll: return(&KEResetAll);

		case ETransactionStart: return(&KETransactionStart);

		case ETransactionCommit: return(&KETransactionCommit);

		case ETransactionCancel: return(&KETransactionCancel);

		case EMove: return(&KEMove);

		case ETransactionState: return(&KETransactionState);

		case ETransactionFail: return(&KETransactionFail);

		case EDeleteRange: return(&KEDeleteRange);

		case EGetSetParameters: return (&KEGetSetParameters);

		case EClose: return(&KEClose);

		case EEvict: return (&KEEvict);

		}

		return &KUnknownFunction;

	}

#endif //__CENTREP_SERVER_PERFTEST__

//--------------------

// class CPerfTestStep

//--------------------

// doTestStepL

// Implement the pure virtual function.

// This test fetches the performance data collected by

// CentRep server, sums the CPU time spent in servicing

// each type of request and time spent in opening each

// repository, and prints out the total.

TVerdict CPerfTestStep::doTestStepL()

	{

#ifdef __CENTREP_SERVER_PERFTEST__

	TBuf<KMaxFileName> sharedString; 

	TPtrC resultSection;

	TInt testMode;

	TInt bRet;

	// get test mode from ini file

	bRet = GetIntFromConfig(ConfigSection(), KIniTestMode, testMode);

	TESTL(bRet==1);

	_LIT(KBlankLine, "\n");

	Logger().WriteFormat(KBlankLine);	 	

	if (testMode == ETiming)

		{

		bRet = GetStringFromConfig(ConfigSection(), KResultsSection, resultSection);

		TESTL(bRet==1);

		}

	if (testMode == EBoot)

		{

		_LIT(KDoTestStepDisclaimer1, "For this test boot-up is considered to be finished when CommsDat repository is loaded 9 times.");

		Logger().WriteFormat(KDoTestStepDisclaimer1);

		_LIT(KDoTestStepDisclaimer2, "This is when the watcher thread is used to make re-attempts to connect to the network.");

		Logger().WriteFormat(KDoTestStepDisclaimer2);

		}

	// Setup IPC args to retreive performance data from server.

	TUint bufSize = KCentRepPerfTestArraySize * sizeof(TUint32);

	TAny* buf = User::AllocL(bufSize);

	TPtr8 bufDesc(static_cast<TUint8*>(buf), bufSize);

	TUint numValidEntries;

	TPckg<TUint> pckg(numValidEntries);

	TInt ret = SetGetParameters(TIpcArgs(EGetPerfResults, &bufDesc, &pckg));

	if (ret != KErrNone)

		{

		_LIT(KSetGetParamFailFmt, "Send msg err %d");

		ERR_PRINTF2(KSetGetParamFailFmt, ret);

		User::Free(buf);

		return EFail;

		}

	if (testMode == EBoot)

		{

		_LIT(KNumValidEntriesFmt, "Num Valid entries = %d");

		Logger().WriteFormat(KNumValidEntriesFmt, numValidEntries);

		}

	RArray<TUint32> perfData(sizeof(TUint32),static_cast<TUint32*>(buf),KCentRepPerfTestArraySize);

	CleanupClosePushL(perfData);

	// Need to find the tick frequency before using ConvertTickToSecAndMilli.

	HAL::Get(HALData::EFastCounterFrequency, iTickFreq);

	TUint sec;

	TUint milliSec;

	const TUint KNumIpcs = EEvict + 1; 

	TIpcStatistics ipcStats[KNumIpcs];

	RArray<TRepStatistics> repStats;

	CleanupClosePushL(repStats);

    TUint32 totalElapsedTicks = 0;

	const TDesC* eventName;

	// Process the data

	// Performance data has 3 parts. First event ID and CPU tick

	// to service the request. 2nd & 3rd, if event is open/close/evict

	// the time of the event and repository UID.

	TInt i;

	for (i=0; i<numValidEntries && i<KCentRepPerfTestArraySize;)

		{

		TUint eventId;

		TUint32 ticksToServiceIpc;

		TUint32 repositoryUid;

		// This entry is elapsed ticks to service the request

		DecodeEventAndData(perfData[i++], eventId, ticksToServiceIpc);

		totalElapsedTicks += ticksToServiceIpc;

		ipcStats[eventId].AddData(ticksToServiceIpc);

		TBool repOpenCloseEvict = eventId == EInitialise || eventId == EClose || eventId == EEvict;

		if (repOpenCloseEvict)

			{

			TESTL(i < numValidEntries);

			TUint32 eventTime = perfData[i++];

			TESTL(i < numValidEntries);

			repositoryUid = perfData[i++];

			// Only rep open is stored in repStats array.

			// Close and evict go into the ipcStats.

			if (eventId == EInitialise)

				{

				TInt idx = FindRepUid(repStats, repositoryUid);

				if (idx == KErrNotFound)

					{

					repStats.Append(TRepStatistics(repositoryUid, ticksToServiceIpc));

					}

				else

					{

					repStats[idx].AddData(ticksToServiceIpc);

					}

				} // if eventId == EInitialise

			if (testMode == EBoot)

				{

				// Display the time that this event occur.

				eventName = GetFuncCodeName(eventId);

				ConvertTickToSecAndMilli(eventTime, sec, milliSec);

				_LIT(KRepOpenCloseFmt, "REP %X %S at %d.%03d");

				Logger().WriteFormat(KRepOpenCloseFmt, repositoryUid, eventName, sec, milliSec);

				}

			} // if repOpenCloseEvict

		} // for i

	// Display the IPC statistics

	Logger().WriteFormat(KBlankLine);

	Logger().WriteFormat(KBlankLine);

	_LIT(KIpcStatsFmt, "IPC Statistics:");

	Logger().WriteFormat(KIpcStatsFmt);

	TInt numIpcMsgs = 0;

	TInt numLogItems = 0;

	TBuf<50> keyName;

	_LIT(KIndividualIpcStat, "%S used %d times, sum of CPU time = %d ms");

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

		{

		if (ipcStats[i].iUseCount == 0)

			{

			continue;

			}

		numIpcMsgs += ipcStats[i].iUseCount;

		eventName = GetFuncCodeName(i);

		ConvertTickToSecAndMilli(ipcStats[i].iSumElapsedTicks, sec, milliSec);

		if (sec > 0)

			{

			milliSec += sec * 1000;

			}

		Logger().WriteFormat(KIndividualIpcStat, eventName, ipcStats[i].iUseCount, milliSec);

		if (testMode == ETiming)

			{

			sharedString.AppendFormat(_L(" %S %d %d"), eventName, ipcStats[i].iUseCount, milliSec);

			numLogItems++;

			}

		}

	if (testMode == ETiming)

		{

		TBuf<2> numofItems;

		numofItems.Num(numLogItems);

		sharedString.Insert(0, numofItems);

		WriteSharedDataL(resultSection, sharedString, ESetText);

		}

	// Display Repository statistics

	Logger().WriteFormat(KBlankLine);

	Logger().WriteFormat(KBlankLine);

	_LIT(KRepStatsFmt, "Repository Statistics:");

	Logger().WriteFormat(KRepStatsFmt);

	if (testMode == ETiming)

		{

		numLogItems = 0;

		sharedString.Copy(_L(" "));

		}

	_LIT(KIndividualRepStat, "%X used %d times, sum of load time %d ms");

	for (i = 0; i < repStats.Count(); i++)

		{

		ConvertTickToSecAndMilli(repStats[i].iSumLoadTicks, sec, milliSec);

		if (sec > 0)

			{

			milliSec += sec * 1000;

			}

		Logger().WriteFormat(KIndividualRepStat, repStats[i].iRepUid,

			repStats[i].iUseCount, milliSec);

		if (testMode == ETiming)

			{

			sharedString.AppendFormat(_L(" %08X %d %d"), repStats[i].iRepUid, repStats[i].iUseCount, milliSec);

			numLogItems++;

			}

		}

	if (testMode == ETiming)

		{

		TBuf<2> numofItems;

		numofItems.Num(numLogItems);

		sharedString.Insert(1, numofItems);

		WriteSharedDataL(resultSection, sharedString, EAppendText);

		Logger().WriteFormat(KBlankLine);

		}

	if (testMode == EBoot)

		{

		// show total CPU used by CentralRepository server.

		ConvertTickToSecAndMilli(totalElapsedTicks, sec, milliSec);

		if (sec > 0)

			{

			milliSec += sec * 1000;

			}

		Logger().WriteFormat(KBlankLine);

		Logger().WriteFormat(KBlankLine);

		_LIT(KTotalCpuFmt, "Total CPU time used by CentRepSrv: %d ms");

		Logger().WriteFormat(KTotalCpuFmt, milliSec);

		_LIT(KNoteAboutTotal, "The above does not include kernel processing time and client idle time for the %d IPC messages.\n");

		Logger().WriteFormat(KNoteAboutTotal, numIpcMsgs);

		}

	// Stop performance test data recording in the server

	TInt r = SetGetParameters(TIpcArgs(EStopPerfTests));

	TEST(r==KErrNone);

	CleanupStack::PopAndDestroy(); // repStats

	CleanupStack::PopAndDestroy(); // perfData

	return EPass;

#else

	_LIT(KWarnTestMacroOff, "Performance test macro __CENTREP_SERVER_PERFTEST__ is disabled. Test not run.");

	WARN_PRINTF1(KWarnTestMacroOff);

	return EPass;

#endif

	}

// ConvertTickToSecAndMilli

// Convert FastCounter ticks to seconds and milli-seconds.

//

// param aTick - ticks from User::FastCounter

// param aSec - return number of seconds in aTick

// param aMilliSec - return number of ms left behind after number of

//                   seconds is subtracted from aTick.

void CPerfTestStep::ConvertTickToSecAndMilli(TUint32 aTick, TUint& aSec, TUint& aMilliSec)

	{

	aSec = aTick / iTickFreq;

	aMilliSec = ((aTick - aSec * iTickFreq) * 1000 + (iTickFreq >> 1)) / iTickFreq;

	}

//------------------------

// class TRepStatistics

//------------------------

// AddData

// Increment number of times this rep is open, sum of CPU used

// to load it, and check cache miss.

void TRepStatistics::AddData(TUint32 aElapsedTicks)

	{

	iSumLoadTicks += aElapsedTicks;

	iUseCount++;

	if (aElapsedTicks >= KTicks2LoadFromCache)

		{

		iCacheMisses++;

		}

	}

//---------------------

// class TIpcStatistics

//---------------------

// AddData

// Increment number of times the IPC msg is received by server.

// Sum time to service this type of request.

void TIpcStatistics::AddData(TUint32 aElapsedTicks)

	{

	iUseCount++;

	iSumElapsedTicks += aElapsedTicks;

	}