sl@0: // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <ecom/ecom.h>
sl@0: #include <hal.h>
sl@0: #include "EComSessionAux.h"
sl@0: 
sl@0: #ifdef __ECOM_SERVER_TESTABILITY__
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to set the next
sl@0: state to be used by the ServerStartupManager of EComServer
sl@0: @param aState the next state to be used by the EComServer
sl@0: */
sl@0: void ChangeStartupStateL(TInt aState)
sl@0: 	{
sl@0: 	TIpcArgs params = TIpcArgs(EChangeStartupState, aState);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to force EComServer
sl@0: to process the next state.
sl@0: */
sl@0: void ProcessCurrentStartupStateL()
sl@0: 	{
sl@0: 	TIpcArgs params = TIpcArgs(EProcessStartupState);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to get the current 
sl@0: startup state of EComServer
sl@0: @return current startup state of EComServer
sl@0: */
sl@0: TInt GetCurrentStartupStateL()
sl@0: 	{
sl@0: 	TInt currentState = 0;
sl@0: 	TPckg<TInt> statePckg(currentState);
sl@0: 	TIpcArgs params = TIpcArgs(EGetStartupState, &statePckg);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	
sl@0: 	return currentState;
sl@0: 	}
sl@0: 
sl@0: #endif
sl@0: 
sl@0: #ifdef __ECOM_SERVER_PERFORMANCE__
sl@0: 
sl@0: //==================== For Startup State Time Results ===================
sl@0: /** Method used for TLinearOrder for TTimerResult arrays*/
sl@0: TInt CompareTimerResults(const TStartupStateTimerResult& aTimerResult1, const TStartupStateTimerResult& aTimerResult2)
sl@0: 	{
sl@0: 	if(aTimerResult1.iState < aTimerResult2.iState)
sl@0: 		{
sl@0: 		return -1;
sl@0: 		}
sl@0: 	else if(aTimerResult1.iState > aTimerResult2.iState)
sl@0: 		{
sl@0: 		return 1;
sl@0: 		}
sl@0: 		
sl@0: 	return 0;
sl@0: 	}
sl@0: 	
sl@0: /** Method used for TIdentityRelation for TTimerResult arrays*/
sl@0: TBool MatchOnState(const TStartupStateTimerResult& aKey, const TStartupStateTimerResult& aIndexItem)
sl@0: 	{
sl@0: 	return aIndexItem.iState == aKey.iState;
sl@0: 	}
sl@0: 
sl@0: TInt RStartupStateTimerResults::FindTimerResult(TInt aState)
sl@0: 	{
sl@0: 	TIdentityRelation<TStartupStateTimerResult> identity(MatchOnState);
sl@0: 	TStartupStateTimerResult key;
sl@0: 	key.iState = aState;
sl@0: 	return iTimerResults.Find(key, identity);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Method that returns the idx of the timer result at requested state
sl@0: @param aTimerResults the sorted timer results array to search for the 
sl@0: timer value
sl@0: @param aState the state of the requested timer result 
sl@0: @return The index of the matching timer result KErrNotFound, if no 
sl@0: matching object can be found
sl@0: */	
sl@0: TInt RStartupStateTimerResults::FindInOrderTimerResult(TInt aState)
sl@0: 	{
sl@0: 	TLinearOrder<TStartupStateTimerResult> compareFunc(CompareTimerResults);
sl@0: 	TStartupStateTimerResult key;
sl@0: 	key.iState = aState;
sl@0: 	return iTimerResults.FindInOrder(key, compareFunc);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to get the timer recordings
sl@0: for performance testing. If the specified aTimerIdx is beyond the boundaries
sl@0: of the recorded values then aTimerResult would return a value of 0 and aState
sl@0: would return a value of -1. 
sl@0: @param aTimerIdx the index of the timer to use
sl@0: @param aTimerResult the timer readings
sl@0: @param aState the state of the server when timer was read (a zero indexed value)
sl@0: */
sl@0: TInt RStartupStateTimerResults::GetTimerResult(TInt aTimerIdx, TUint32& aTimerResult, TInt& aState)
sl@0: 	{
sl@0: 	TInt returnedStatus;
sl@0: 	TStartupStateTimerEntry result;
sl@0: 
sl@0: 	TPckg<TInt> statusPckg(returnedStatus);
sl@0: 	TPckg<TStartupStateTimerEntry> resultPckg(result);
sl@0: 
sl@0: 	TIpcArgs params = TIpcArgs(EGetStartupStateTimerResult, aTimerIdx, &statusPckg, &resultPckg);
sl@0: 	TRAPD(err, REComSession::SetGetParametersL(params));
sl@0: 	if (err != KErrNone)
sl@0: 		{
sl@0: 		return err;	
sl@0: 		}
sl@0: 	
sl@0: 	aTimerResult = result.iTimerResult;
sl@0: 	aState = result.iState;
sl@0: 	
sl@0: 	return returnedStatus;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to get all of the timer recordings
sl@0: for performance testing.
sl@0: @param aTimerResults a reference to an array to store sorted timer results.
sl@0: */
sl@0: void RStartupStateTimerResults::GetAllTimerResults()
sl@0: 	{
sl@0: 	TInt counter = 0;
sl@0: 	while(ETrue)
sl@0: 		{
sl@0: 		TUint32 time = 0;
sl@0: 		TInt state = -1;
sl@0: 		TReal realTime = 0.0;
sl@0: 		
sl@0: 		// get state start info
sl@0: 		TInt err = GetTimerResult(counter++, time, state);
sl@0: 		if(err || (time == 0 && state == -1))
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		
sl@0: 		realTime = FastCountToMilliseconds(time);
sl@0: 		
sl@0: 		//search state
sl@0: 		TInt idx = FindTimerResult(state);
sl@0: 		if(idx == KErrNotFound) //if it has not been entered to the array make a new entry
sl@0: 			{
sl@0: 			TStartupStateTimerResult timerResult;
sl@0: 			timerResult.iState = state;
sl@0: 			timerResult.iStartTime = realTime;
sl@0: 			timerResult.iEndTime = 0;
sl@0: 			
sl@0: 			iTimerResults.Append(timerResult);
sl@0: 			}
sl@0: 		else //if it has already been entered update the end time
sl@0: 			{
sl@0: 			TStartupStateTimerResult& timerResult = iTimerResults[idx];
sl@0: 			timerResult.iEndTime = realTime;
sl@0: 			}
sl@0: 		}
sl@0: 	
sl@0: 	//the array is populated, sort it for faster search.
sl@0: 	TLinearOrder<TStartupStateTimerResult> compareFunc(CompareTimerResults);
sl@0: 	iTimerResults.Sort(compareFunc);
sl@0: 	}
sl@0: 
sl@0: void RStartupStateTimerResults::ResetTimerCountL()
sl@0: 	{
sl@0: 	
sl@0: 	TIpcArgs params = TIpcArgs(EResetStartupStateTimerCounts);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0:  Frees any allocated resources
sl@0: */
sl@0: void RStartupStateTimerResults::Close()
sl@0: 	{
sl@0: 	iTimerResults.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Startup state timer results must have been populated by a call to RetrieveResults before this method is called
sl@0:  @param aIndex The index of the timing entry to retrieve
sl@0:  @return The timer result entry for the given index
sl@0: */
sl@0: TStartupStateTimerResult& RStartupStateTimerResults::At(TInt aIndex)
sl@0: 	{
sl@0: 	return iTimerResults[aIndex];
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  @return The number of timer results retrieved
sl@0: */
sl@0: TInt RStartupStateTimerResults::Count()
sl@0: 	{
sl@0: 	return iTimerResults.Count();
sl@0: 	}
sl@0: 
sl@0: //==================== For Client Requests Time Results ===================
sl@0: /**
sl@0:  Retrieves a single client request timer entry from the ECom server
sl@0:  @param aTimerIdx The index of the timing entry to retrieve
sl@0:  @return KErrNone if successful, KErrOverflow if aTimerIdx is greater than the number of timing entries
sl@0: */
sl@0: TInt RClientRequestTimerResults::GetTimerResult(TInt aTimerIdx, TClientRequestTimerEntry& aTimerEntry)
sl@0: 	{
sl@0: 	TInt returnedStatus;
sl@0: 	TPckg<TInt> statusPckg(returnedStatus);
sl@0: 	TPckg<TClientRequestTimerEntry> resultPckg(aTimerEntry);
sl@0: 	
sl@0: 	TIpcArgs params = TIpcArgs(EGetAccumulatedClientRequestsTimerResult, aTimerIdx, &statusPckg, &resultPckg);
sl@0: 	TRAPD(err, REComSession::SetGetParametersL(params));
sl@0: 	if (err != KErrNone)	
sl@0: 		{
sl@0: 		return err;	
sl@0: 		}
sl@0: 	
sl@0: 	return returnedStatus;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Retrieves all client request timer entries from the ECom server
sl@0: */
sl@0: void RClientRequestTimerResults::RetrieveResultsL()
sl@0: 	{
sl@0: 	TClientRequestTimerEntry timerEntry;
sl@0: 	TInt err = KErrNone;
sl@0: 	for (TInt i = 0; err == KErrNone; i++)
sl@0: 		{
sl@0: 		err = GetTimerResult(i, timerEntry);
sl@0: 		if (err == KErrNone)
sl@0: 			{
sl@0: 			iResults.Append(timerEntry);
sl@0: 			}
sl@0: 		else if (err != KErrOverflow)
sl@0: 			{
sl@0: 			User::Leave(err);
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0:  Determines the total time taken by ECom server servicing client requests with the given state and request type
sl@0:  by going through each of the retrieved timer entries and adding up their associated times
sl@0:  @pre RetrieveResultsL must have been called before this method is called
sl@0:  @param aState The startup state to retrieve timer results for
sl@0:  @param aRequestType The type of client request to retrieve timer results for
sl@0:  @param aNumRequests On return contains the number of client requests matching aState and aRequestType
sl@0:  @return The total time taken servicing client requests matching startup state aState and aRequestType
sl@0: */
sl@0: TReal RClientRequestTimerResults::GetAccumulatedClientRequestTime(TInt aState, TEComClientRequestType aRequestType, TUint& aNumRequests)
sl@0: 	{
sl@0: 	TUint32 accumulatedTicks = 0;
sl@0: 	
sl@0: 	aNumRequests = 0;
sl@0: 	for (TInt i = 0; i < iResults.Count(); i++)
sl@0: 		{
sl@0: 		if (iResults[i].iState == aState && iResults[i].iClientRequestType == aRequestType)
sl@0: 			{
sl@0: 			TUint netTime = iResults[i].iEndTime - iResults[i].iStartTime;
sl@0: 			accumulatedTicks += netTime;
sl@0: 			aNumRequests++;
sl@0: 			}
sl@0: 		}
sl@0: 		
sl@0: 	return FastCountToMilliseconds(accumulatedTicks);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Determines the total time taken by ECom server servicing client requests with the given state
sl@0:  by going through each of the retrieved timer entries and adding up their associated times
sl@0:  Client request timer results must have been populated by a call to RetrieveResults before this method is called
sl@0:  @param aState The startup state to retrieve timer results for
sl@0:  @param aNumRequests On return contains the number of client requests matching aState
sl@0:  @return The total time taken servicing client requests matching startup state aState
sl@0: */
sl@0: TReal RClientRequestTimerResults::GetAccumulatedClientRequestTime(TInt aState, TUint& aNumRequests)
sl@0: 	{
sl@0: 	TUint32 accumulatedTicks = 0;
sl@0: 	
sl@0: 	aNumRequests = 0;
sl@0: 	for (TInt i = 0; i < iResults.Count(); i++)
sl@0: 		{
sl@0: 		if (iResults[i].iState == aState)
sl@0: 			{
sl@0: 			TUint netTime = iResults[i].iEndTime - iResults[i].iStartTime;
sl@0: 			accumulatedTicks += netTime;
sl@0: 			aNumRequests++;
sl@0: 			}
sl@0: 		}
sl@0: 		
sl@0: 	return FastCountToMilliseconds(accumulatedTicks);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Determines the total time taken by ECom server servicing client requests with the given request type
sl@0:  by going through each of the retrieved timer entries and adding up their associated times
sl@0:  Client request timer results must have been populated by a call to RetrieveResults before this method is called
sl@0:  @param aRequestType The type of client request to retrieve timer results for
sl@0:  @param aNumRequests On return contains the number of client requests matching aRequestType
sl@0:  @return The total time taken servicing client requests matching startup state aRequestType
sl@0: */
sl@0: TReal RClientRequestTimerResults::GetAccumulatedClientRequestTime(TEComClientRequestType aRequestType, TUint& aNumRequests)
sl@0: 	{
sl@0: 	TUint32 accumulatedTicks = 0;
sl@0: 	
sl@0: 	aNumRequests = 0;
sl@0: 	for (TInt i = 0; i < iResults.Count(); i++)
sl@0: 		{
sl@0: 		if (iResults[i].iClientRequestType == aRequestType)
sl@0: 			{
sl@0: 			TUint netTime = iResults[i].iEndTime - iResults[i].iStartTime;
sl@0: 			accumulatedTicks += netTime;
sl@0: 			aNumRequests++;
sl@0: 			}
sl@0: 		}
sl@0: 		
sl@0: 	return FastCountToMilliseconds(accumulatedTicks);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  Determines the total time taken by ECom server servicing all client requests
sl@0:  by going through each of the retrieved timer entries and adding up their associated times
sl@0:  Client request timer results must have been populated by a call to RetrieveResults before this method is called
sl@0:  @param aNumRequests On return contains the number of client requests
sl@0:  @return The total time taken servicing client requests
sl@0: */
sl@0: TReal RClientRequestTimerResults::GetAccumulatedClientRequestTime(TUint& aNumRequests)
sl@0: 	{
sl@0: 	TUint32 accumulatedTicks = 0;
sl@0: 	
sl@0: 	aNumRequests = 0;
sl@0: 	for (TInt i = 0; i < iResults.Count(); i++)
sl@0: 		{
sl@0: 		TUint netTime = iResults[i].iEndTime - iResults[i].iStartTime;
sl@0: 		accumulatedTicks += netTime;
sl@0: 		aNumRequests++;
sl@0: 		}
sl@0: 		
sl@0: 	return FastCountToMilliseconds(accumulatedTicks);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Frees any resources
sl@0: */
sl@0: void RClientRequestTimerResults::Close()
sl@0: 	{
sl@0: 	iResults.Reset();
sl@0: 	}
sl@0: 
sl@0: /**	
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to get the number of
sl@0: drives, plugins, interfaces, implementation for performance testing.
sl@0: @param aCounts a reference to a struct to store results.
sl@0: */
sl@0: void RegistryCounts::GetRegistryCountsL(TRegistryCounts::TRegistryCountDriveType aType, TRegistryCounts& aCounts)
sl@0: 	{
sl@0: 	TPckg<TRegistryCounts> registryCountPckg(aCounts);
sl@0: 	TIpcArgs params = TIpcArgs(EGetRegistryCounts, aType, &registryCountPckg);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	}
sl@0: 
sl@0: 
sl@0: //==================== For ECom Performance Time Results ===================
sl@0: /**
sl@0: @internalComponent
sl@0: A helper function to use SetGetParametersL to get the time recordings
sl@0: for performance testing. If the specified aTimerIdx is beyond the size
sl@0: of the valid recorded values then KErrOverFlow returns from the server side
sl@0: @param aTimerIdx the index of the time record to use
sl@0: @param aTimeEntry the fast time record entry
sl@0: */
sl@0: TInt REComPerfTimeRecords::GetTimeRecordEntry(TInt aTimeIdx, TEComPerfTimeRecordEntry& aTimeEntry)
sl@0: 	{
sl@0: 	TInt returnedStatus;
sl@0: 
sl@0: 	TPckg<TInt> statusPckg(returnedStatus);
sl@0: 	TPckg<TEComPerfTimeRecordEntry> resultPckg(aTimeEntry);
sl@0: 
sl@0: 	TIpcArgs params = TIpcArgs(EGetEComPerfTimeRecord, aTimeIdx, &statusPckg, &resultPckg);
sl@0: 	TRAPD(err, REComSession::SetGetParametersL(params));
sl@0: 	if (err != KErrNone)
sl@0: 		{
sl@0: 		return err;	
sl@0: 		}
sl@0: 		
sl@0: 	return returnedStatus;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Get all ECom performance time records from server and fill up local array for further use
sl@0: */
sl@0: void REComPerfTimeRecords::OpenL()
sl@0: 	{
sl@0: 	TEComPerfTimeRecordEntry timeEntry;
sl@0: 	TInt err = KErrNone;
sl@0: 	
sl@0: 	iTimeRecords.Reset();
sl@0: 	
sl@0: 	// Get the first record from server
sl@0: 	TInt idx = 0;
sl@0: 	err = GetTimeRecordEntry(idx, timeEntry);
sl@0: 	while(err == KErrNone)
sl@0: 		{
sl@0: 		// If it is a valid record entry, append it to local record array, 
sl@0: 		//  and get the next entry from server.
sl@0: 		if (timeEntry.iType != ENullType)
sl@0: 			{
sl@0: 			iTimeRecords.Append(timeEntry);
sl@0: 			idx++;
sl@0: 			err = GetTimeRecordEntry(idx, timeEntry);
sl@0: 			}
sl@0: 		// Otherwise finished
sl@0: 		else
sl@0: 			break;
sl@0: 		}
sl@0: 			
sl@0: 	if (err != KErrOverflow)
sl@0: 		{
sl@0: 		User::LeaveIfError(err);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Transform raw fast count records into real time results (in mSecs), and collect the results by specified type.
sl@0: */
sl@0: void REComPerfTimeRecords::RetrieveResultsByTypeL(TEComPerfTimeRecordType aType, RArray<TEComPerfRealTimeResult>& aTimeResults)
sl@0: 	{
sl@0: 	TEComPerfRealTimeResult timeResult;
sl@0: 	TBool start = ETrue;
sl@0: 	TInt count = iTimeRecords.Count();
sl@0: 
sl@0: 	if(count)
sl@0: 		{
sl@0: 		for (TInt i = 0; i < count; i++)
sl@0: 			{
sl@0: 			// If the record has correct type
sl@0: 			if(iTimeRecords[i].iType == aType)
sl@0: 				{
sl@0: 				// If the record is the first of the couple, it should be the start time record
sl@0: 				if(start)
sl@0: 					{
sl@0: 					timeResult.iStartTime = FastCountToMilliseconds(iTimeRecords[i].iTime);
sl@0: 					timeResult.iType = iTimeRecords[i].iType;
sl@0: 					timeResult.iInfo = iTimeRecords[i].iInfo;
sl@0: 					start = EFalse;
sl@0: 					}
sl@0: 				// Otherwise it should be the end time record.
sl@0: 				else
sl@0: 					{
sl@0: 					timeResult.iEndTime = FastCountToMilliseconds(iTimeRecords[i].iTime);
sl@0: 					aTimeResults.Append(timeResult);
sl@0: 					start = ETrue;
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	else // Leave if there's no records to retrieve
sl@0: 		{
sl@0: 		User::Leave(KErrNotFound);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0: 
sl@0: */
sl@0: void REComPerfTimeRecords::RetrieveResultsInfoByTypeL(TEComPerfTimeRecordType aType, RArray<TInt>& aInfos)
sl@0: 	{
sl@0: 	TInt count = iTimeRecords.Count();
sl@0: 	if(count)
sl@0: 		{
sl@0: 		for (TInt i = 0; i < count; i++)
sl@0: 			{
sl@0: 			// If the record has correct type, insert the info into aInfos array. No duplicate infos are recorded.
sl@0: 			if(iTimeRecords[i].iType == aType)
sl@0: 				{
sl@0: 				TInt err = aInfos.InsertInOrder(iTimeRecords[i].iInfo);
sl@0: 				
sl@0: 				if(err!=KErrAlreadyExists)
sl@0: 					User::LeaveIfError(err);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	else // Leave if there's no records to retrieve
sl@0: 		{
sl@0: 		User::Leave(KErrNotFound);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // Reset all fast count records on server
sl@0: void REComPerfTimeRecords::ResetRecordsOnServerL()
sl@0: 	{
sl@0: 	TIpcArgs params = TIpcArgs(EResetEComPerfTimeRecords);
sl@0: 	REComSession::SetGetParametersL(params);
sl@0: 	}
sl@0: 
sl@0: TInt REComPerfTimeRecords::Count()
sl@0: 	{
sl@0: 	return iTimeRecords.Count();
sl@0: 	}
sl@0: 
sl@0: // Empty local time result array
sl@0: void REComPerfTimeRecords::Reset()
sl@0: 	{
sl@0: 	iTimeRecords.Reset();
sl@0: 	}
sl@0: 
sl@0: // Release resources
sl@0: void REComPerfTimeRecords::Close()
sl@0: 	{
sl@0: 	iTimeRecords.Close();
sl@0: 	}
sl@0: 
sl@0: //==================== For ECom Performance Heap Usage Results ===================
sl@0: /**
sl@0: @internalComponent
sl@0: */
sl@0: void REComHeapUsageRecords::OpenL()
sl@0: 	{
sl@0: 	iHeapRecords.Reset();
sl@0: 	
sl@0: 	// Get the first record from server
sl@0: 	TInt idx = 0;
sl@0: 	TEComPerfHeapUsage heapEntry;
sl@0: 	TInt err=GetHeapRecordEntry(idx,heapEntry);
sl@0: 	while(err == KErrNone && heapEntry.iState!=0)
sl@0: 		{
sl@0: 		//check existing array for a start item
sl@0: 		TBool startFound=EFalse;
sl@0: 		for (TInt i=0;i<iHeapRecords.Count();i++)
sl@0: 			{
sl@0: 			//if can find one this entry must be a start entry so update the heap usage
sl@0: 			if (iHeapRecords[i].iState==heapEntry.iState)
sl@0: 				{
sl@0: 				iHeapRecords[i].iHeapSize=heapEntry.iHeapSize-(iHeapRecords[i].iHeapSize);
sl@0: 				startFound=ETrue;
sl@0: 				break;
sl@0: 				}
sl@0: 			}
sl@0: 		//only append the entry if it is a new start entry
sl@0: 		if (!startFound)
sl@0: 			iHeapRecords.Append(heapEntry);
sl@0: 		idx++;
sl@0: 		err=GetHeapRecordEntry(idx,heapEntry);
sl@0: 		}
sl@0: 			
sl@0: 	if (err != KErrOverflow)
sl@0: 		{
sl@0: 		User::LeaveIfError(err);
sl@0: 		}	
sl@0: 	}
sl@0: 
sl@0: TInt REComHeapUsageRecords::GetHeapUsageAtState(TInt aState)
sl@0: 	{
sl@0: 	for (TInt i=0;i<iHeapRecords.Count();i++)
sl@0: 		{
sl@0: 		if (iHeapRecords[i].iState==aState)
sl@0: 			{
sl@0: 			return iHeapRecords[i].iHeapSize;
sl@0: 			}
sl@0: 		}
sl@0: 	return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: void REComHeapUsageRecords::Close()
sl@0: 	{
sl@0: 	iHeapRecords.Reset();
sl@0: 	iHeapRecords.Close();
sl@0: 	}
sl@0: 
sl@0: TInt REComHeapUsageRecords::GetHeapRecordEntry(TInt aHeapIdx,TEComPerfHeapUsage& aHeapEntry)
sl@0: 	{
sl@0: 	TInt returnedStatus;
sl@0: 	TPckg<TInt> statusPckg(returnedStatus);
sl@0: 	TPckg<TEComPerfHeapUsage> resultPckg(aHeapEntry);
sl@0: 	TIpcArgs params = TIpcArgs(EGetEComServerHeapResult, aHeapIdx,&statusPckg,&resultPckg);
sl@0: 	TRAPD(err, REComSession::SetGetParametersL(params));
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: //===========================================================
sl@0: /**
sl@0: Converts time retrieved using FastCounter to milliseconds
sl@0:  @param aFastCount The time to convert to milliseconds, retrieved using User::FastCounter
sl@0:  @return The time in milliseconds corresponding to aFastCount
sl@0: */
sl@0: TReal FastCountToMilliseconds(TInt aFastCount)
sl@0: 	{
sl@0: 	TInt freqInHz;
sl@0: 	HAL::Get(HAL::EFastCounterFrequency, freqInHz);
sl@0: 	TReal freqInkHz = freqInHz / 1000;
sl@0: 	return (TReal)aFastCount / freqInkHz;
sl@0: 	}
sl@0: 	
sl@0: #endif