diff -r 000000000000 -r bde4ae8d615e os/ossrv/lowlevellibsandfws/pluginfw/TestExecute/EComPerfTest/src/Te_EComStartupStatePerfTestStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/ossrv/lowlevellibsandfws/pluginfw/TestExecute/EComPerfTest/src/Te_EComStartupStatePerfTestStep.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,352 @@ +// 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: +// Te_EComPerfTestStep.cpp +// Implements the performance loggr for ECOM +// +// + +/** + @file + @internalComponent +*/ + +#include "Te_EComStartupStatePerfTestStep.h" +#include +#include +#include +#include +#include +#include "Interface.h" +#include "EcomTestUtils.h" + +#ifdef __ECOM_SERVER_PERFORMANCE__ +// Start-up urel/armv5 test limits for CS and NC are calculated using the number of DLL's added to the +// registry for Ro Internal Drives and Non RO Internal Drives respectively. +// The test limit formula used for the upper limit is: +// 50mS+(1.75mS*number of DLLs discovered) for H2 builds +// 15mS+(1mS*number of DLLs discovered) for H4 RAM (non-NAND) builds +// 125mS+(1.5mS*number of DLLs discovered) for H4 NAND builds +// 5mS+(1mS*number of DLLs discovered) for H6 RAM (non-NAND) builds +// 40mS+(1.5mS*number of DLLs discovered) for H6 NAND builds +// These figures were determined using benchmarks from the ONB&TR. +// Although these limits are passed to CheckPerformance() for non urel/armv5 testing this method +// does not test against them. It is disabled. + +const TReal KStartupLimitBaseH2RAM = 50; +const TReal KStartupLimitMultiplierH2RAM = 2.05; + +const TReal KStartupLimitBaseH4RAM = 25; +const TReal KStartupLimitMultiplierH4RAM = 1; + +const TReal KStartupLimitBaseH6RAM = 5; +const TReal KStartupLimitMultiplierH6RAM = 0.5; + +const TReal KStartupLimitBaseH4NAND = 140; +const TReal KStartupLimitMultiplierH4NAND = 1.5; + +const TReal KStartupLimitBaseH6NAND = 40; +const TReal KStartupLimitMultiplierH6NAND = 1; + +// There is no discovery at CD therefore limit is fixed. +const TReal KCriticalDynamicLimitH2RAM = 10; +const TReal KCriticalDynamicLimitH4RAM = 2; +const TReal KCriticalDynamicLimitH4NAND = 5; +const TReal KCriticalDynamicLimitH6RAM = 1; +const TReal KCriticalDynamicLimitH6NAND = 2.5; + +// Initialisation limit is independant of DLL count and is also fixed +const TReal KInitialisationLimitH2RAM = 50; +const TReal KInitialisationLimitH4RAM = 25; +const TReal KInitialisationLimitH4NAND = 25; +const TReal KInitialisationLimitH6RAM = 5; +const TReal KInitialisationLimitH6NAND = 5; + +#endif //__ECOM_SERVER_PERFORMANCE__ + +CEComStartupStatePerfTest::CEComStartupStatePerfTest() : CEComPerfTestBase(KEComStartupStatePerfTest) +/** + * Constructor + */ + { + // does nothing here. + } + +CEComStartupStatePerfTest::~CEComStartupStatePerfTest() +/** + * Destructor + */ + { + // does nothing here. + } + +#ifdef __ECOM_SERVER_PERFORMANCE__ +void CEComStartupStatePerfTest::RetrieveRegistryCountL( + RegistryCounts::TRegistryCounts::TRegistryCountDriveType aDriveType, + RegistryCounts::TRegistryCounts& aCounts, + TPtrC aMessage) + { + RegistryCounts::GetRegistryCountsL(aDriveType, aCounts); + INFO_PRINTF3(_L("Drive count for %S: [%d]"), &aMessage, aCounts.iDrives); + INFO_PRINTF3(_L("DLL count for %S: [%d]"), &aMessage, aCounts.iDlls); + INFO_PRINTF3(_L("Interface count for %S: [%d]"), &aMessage, aCounts.iInterfaces); + INFO_PRINTF3(_L("Implementation count for %S: [%d]\n"), &aMessage, aCounts.iImplementations); + } + +TVerdict CEComStartupStatePerfTest::ProcessState(RStartupStateTimerResults& aTimerResults, + TInt aTimerState, + TReal& aStateStartTime, + TReal& aStateComplTime) + { + TInt idx = aTimerResults.FindInOrderTimerResult(aTimerState); + + if(idx == KErrNotFound) + { + INFO_PRINTF1(_L("Something went wrong......whoops\n")); + SetTestStepResult(EFail); + return EFail; + } + + const TStartupStateTimerResult& timerResult = aTimerResults.At(idx); + aStateStartTime = timerResult.iStartTime; + aStateComplTime = timerResult.iEndTime; + + INFO_PRINTF3(_L("State: %d elapsed time: %f mSecs\n"), aTimerState, aStateComplTime - aStateStartTime); + + return EPass; + } + +TVerdict CEComStartupStatePerfTest::ProcessState(REComHeapUsageRecords& aHeapResults, TInt aState,TInt& aHeapUsage) + { + TInt heap=aHeapResults.GetHeapUsageAtState(aState); + if (heap==KErrNotFound) + { + INFO_PRINTF1(_L("Something went wrong......whoops\n")); + SetTestStepResult(EFail); + return EFail; + } + aHeapUsage=heap; + INFO_PRINTF3(_L("State: %d heap usage: %d bytes\n"), aState,aHeapUsage); + return EPass; + } + +#endif //__ECOM_SERVER_PERFORMANCE__ + +/* + Retrieves startup state timing from the ECom server and tests that the time spent during the different startup states is within a set of maximum bounds + @return EPass if the test succeeds and the measured times are within the maximumum, EFail otherwise + */ +TVerdict CEComStartupStatePerfTest::doTestStepL() + { +#ifdef __ECOM_SERVER_PERFORMANCE__ + + // get the registry counts from the server + // the DLL count is used to set the test limits for the startup tests + INFO_PRINTF1(_L("RO Internal Registry Counts")); + RegistryCounts::TRegistryCounts roIntCounts; + RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::ERoInternal, roIntCounts, _L("RO internal drives")); + + INFO_PRINTF1(_L("Non RO Internal Registry Counts")); + RegistryCounts::TRegistryCounts nonRoIntCounts; + RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::ENonRoInternal, nonRoIntCounts, _L("Non RO internal drives")); + + INFO_PRINTF1(_L("All Registry Counts")); + RegistryCounts::TRegistryCounts allCounts; + RetrieveRegistryCountL(RegistryCounts::TRegistryCounts::EAll, allCounts, _L("All drives")); + + //set configuration-dependent timing limits + TReal CriticalStaticLimit = 0; + TReal NonCriticalLimit = 0; + TReal CriticalDynamicLimit = 0; + TReal InitialisationLimit = 0; + + THardwareConfiguration hardware_configuration = EComTestUtils::GetHardwareConfiguration(); + switch (hardware_configuration) + { + case EPlatformH2RAM: + CriticalStaticLimit = KStartupLimitBaseH2RAM + (KStartupLimitMultiplierH2RAM * roIntCounts.iDlls); + NonCriticalLimit = KStartupLimitBaseH2RAM + (KStartupLimitMultiplierH2RAM * nonRoIntCounts.iDlls); + CriticalDynamicLimit = KCriticalDynamicLimitH2RAM; + InitialisationLimit = KInitialisationLimitH2RAM; + INFO_PRINTF1(_L("Hardware configuration: H2 RAM")); + break; + + case EPlatformH2NAND: + INFO_PRINTF1(_L("Hardware configuration: H2 NAND")); + INFO_PRINTF1(_L("***Performance testing on H2 NAND is not supported!***")); + SetTestStepResult(EFail); + break; + + case EPlatformH2NANDDP: + INFO_PRINTF1(_L("Hardware configuration: H2 NAND DP")); + INFO_PRINTF1(_L("***Performance testing on H2 NAND DP is not supported!***")); + SetTestStepResult(EFail); + break; + + case EPlatformH4RAM: + CriticalStaticLimit = KStartupLimitBaseH4RAM + (KStartupLimitMultiplierH4RAM * roIntCounts.iDlls); + NonCriticalLimit = KStartupLimitBaseH4RAM + (KStartupLimitMultiplierH4RAM * nonRoIntCounts.iDlls); + CriticalDynamicLimit = KCriticalDynamicLimitH4RAM; + InitialisationLimit = KInitialisationLimitH4RAM; + INFO_PRINTF1(_L("Hardware configuration: H4 RAM")); + break; + + case EPlatformH4NAND: + CriticalStaticLimit = KStartupLimitBaseH4NAND + (KStartupLimitMultiplierH4NAND * roIntCounts.iDlls); + NonCriticalLimit = KStartupLimitBaseH4NAND + (KStartupLimitMultiplierH4NAND * nonRoIntCounts.iDlls); + CriticalDynamicLimit = KCriticalDynamicLimitH4NAND; + InitialisationLimit = KInitialisationLimitH4NAND; + INFO_PRINTF1(_L("Hardware configuration: H4 NAND")); + break; + + case EPlatformH4NANDDP: + INFO_PRINTF1(_L("Hardware configuration: H4 NAND DP")); + break; + + case EPlatformH6RAM: + CriticalStaticLimit = KStartupLimitBaseH6RAM + (KStartupLimitMultiplierH6RAM * roIntCounts.iDlls); + NonCriticalLimit = KStartupLimitBaseH6RAM + (KStartupLimitMultiplierH6RAM * nonRoIntCounts.iDlls); + CriticalDynamicLimit = KCriticalDynamicLimitH6RAM; + InitialisationLimit = KInitialisationLimitH6RAM; + INFO_PRINTF1(_L("Hardware configuration: H6 RAM")); + break; + + case EPlatformH6NAND: + CriticalStaticLimit = KStartupLimitBaseH6NAND + (KStartupLimitMultiplierH6NAND * roIntCounts.iDlls); + NonCriticalLimit = KStartupLimitBaseH6NAND + (KStartupLimitMultiplierH6NAND * nonRoIntCounts.iDlls); + CriticalDynamicLimit = KCriticalDynamicLimitH6NAND; + InitialisationLimit = KInitialisationLimitH6NAND; + INFO_PRINTF1(_L("Hardware configuration: H6 NAND")); + break; + + case EPlatformH6NANDDP: + INFO_PRINTF1(_L("Hardware configuration: H6 NAND DP")); + break; + + case EPlatformWINSCW: + INFO_PRINTF1(_L("Hardware configuration: WINSCW")); + break; + + default: + SetTestStepResult(EFail); + INFO_PRINTF1(_L("***Unrecognized platform!***")); + break; + } + + // get all the timer results from the server + RStartupStateTimerResults timerResults; + timerResults.GetAllTimerResults(); + + // Get ecom start time and state. The state is a test state and should be -1 + TInt idx = timerResults.FindInOrderTimerResult(-1); + if(idx == KErrNotFound) + { + INFO_PRINTF1(_L("Something went wrong......whoops\n")); + SetTestStepResult(EFail); + return TestStepResult(); + } + + TStartupStateTimerResult timerResult = timerResults.At(idx); + TReal ecomStartTime = timerResult.iStartTime; + TReal ecomComplTime = timerResult.iEndTime; + TReal stateStartTime = 0.0; + TReal stateComplTime = 0.0; + TReal accumulatedTime = 0.0; + TReal initialisationTime = 0.0; + + //Test for Critical Static state + INFO_PRINTF1(_L("Critical Static")); + TVerdict result = ProcessState(timerResults, EStartupStateCriticalStatic, stateStartTime, stateComplTime); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + accumulatedTime += (stateComplTime - stateStartTime); + CheckPerformance(stateComplTime - stateStartTime, CriticalStaticLimit, _L("Critical static state")); + + //Test for initialisation + initialisationTime = ecomComplTime - ecomStartTime - accumulatedTime; + INFO_PRINTF2(_L("Initialisation Elapsed: %f mSecs\n"), ecomComplTime - ecomStartTime); + accumulatedTime += initialisationTime; + CheckPerformance(initialisationTime, InitialisationLimit, _L("Initialisation Time")); + + //Test for Critical Dynamic state + result = ProcessState(timerResults, EStartupStateCriticalDynamic, stateStartTime, stateComplTime); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + accumulatedTime += (stateComplTime - stateStartTime); + CheckPerformance(stateComplTime - stateStartTime, CriticalDynamicLimit, _L("Critical dynamic state")); + + //Test for Non Critical state + result = ProcessState(timerResults, EStartupStateNonCritical, stateStartTime, stateComplTime); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + accumulatedTime += (stateComplTime - stateStartTime); + CheckPerformance(stateComplTime - stateStartTime, NonCriticalLimit, _L("Non critical state")); + + //Test for overall time + INFO_PRINTF2(_L("Ecom Stop Time: %f mSecs\n"), stateComplTime); + INFO_PRINTF2(_L("Total Elapsed Time: %f mSecs\n"), stateComplTime - ecomStartTime); + INFO_PRINTF2(_L("Total Accumulated Time: %f mSecs\n"), accumulatedTime); + // CheckPerformance(accumulatedTime, 1000); Test unecessary as individual times that make up accumulated are already tested + + // Now get all the heap results from the server + REComHeapUsageRecords heapResults; + heapResults.OpenL(); + + //Test for Critical Static state + TInt CSUsage=0; + INFO_PRINTF1(_L("Critical Static state")); + result=ProcessState(heapResults,EStartupStateCriticalStatic,CSUsage); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + //Test for initialisation + INFO_PRINTF1(_L("Initialisation state(including Critical Static measurement)")); + TInt heapUsage=0; + result=ProcessState(heapResults,-1,heapUsage); + TInt initialisationHeapUsage=heapUsage-CSUsage; + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + INFO_PRINTF1(_L("Initialisation state(excluding Critical Static measurement)")); + INFO_PRINTF3(_L("State: %d heap usage: %d bytes\n"), -1,initialisationHeapUsage); + + //Test for Critical Dynamic state + INFO_PRINTF1(_L("Critical Dynamic state")); + result=ProcessState(heapResults,EStartupStateCriticalDynamic,heapUsage); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + + //Test for Non Critical State + INFO_PRINTF1(_L("Non Critical sate")); + result=ProcessState(heapResults,EStartupStateNonCritical,heapUsage); + if(result != EPass && result != EIgnore) + { + return TestStepResult(); + } + + heapResults.Close(); +#else + MacroNotDefinedError(); +#endif // __ECOM_SERVER_PERFORMANCE__ + return TestStepResult(); + }