| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2018 Ericsson Telecom AB // |
| // // |
| // All rights reserved. This program and the accompanying materials // |
| // are made available under the terms of the Eclipse Public License v2.0 // |
| // which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_ExecCtrl_PullModel_PerfTest_Functions |
| // |
| // Purpose: |
| // This module contains the Functions to test pull model performance. |
| // |
| // Module depends on: |
| // <EPTF_ExecCtrl_Test_Definitions> |
| // <EPTF_ExecCtrl_Test_Function> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_CLI_Definitions> |
| // <EPTF_CLL_ExecCtrlTimeProfile_Definitions> |
| // <EPTF_CLL_ExecCtrl_Functions> |
| // <EPTF_CLL_ExecCtrl_CLIFunctions> |
| // <EPTF_CLL_ExecCtrl_Definitions> |
| // <EPTF_CLL_UIHandler_WidgetFunctions> |
| // <EPTF_CLL_ExecCtrlUIHandler_Definitions> |
| // <EPTF_CLL_HashMapInt2Int_Functions> |
| // <EPTF_CLL_HashMapOct2Int_Functions> |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // |
| // Current Owner: |
| // Jozsef Gyurusi (ETHJGI) |
| // |
| // Last Review Date: |
| // 2013-xx-xx |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////// |
| |
| module EPTF_ExecCtrl_PullModel_PerfTest_Functions { |
| |
| import from EPTF_ExecCtrl_PullModel_PerfTest_Definitions all; |
| |
| import from EPTF_CLL_ExecCtrl_Definitions all; |
| import from EPTF_CLL_LGenBase_ConfigFunctions all; |
| import from EPTF_CLL_LGenBase_Functions all; |
| import from EPTF_CLL_ExecCtrlClient_Functions all; |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_LoadRegulator_Functions all; |
| import from EPTF_CLL_LoadRegulator_Definitions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_LGenBase_ConfigDefinitions all; |
| import from EPTF_CLL_ExecCtrl_Functions all; |
| import from EPTF_CLL_DataSource_Functions all; |
| import from EPTF_CLL_ExecCtrl_CLIFunctions all; |
| import from EPTF_CLL_HostAdmin_BaseFunctions all; |
| import from EPTF_CLL_StatMeasure_Functions all; |
| |
| import from EPTF_CLL_UIHandler_XULFunctions all; |
| import from EPTF_CLL_UIHandler_WidgetFunctions all; |
| import from ttcn_ericsson_se_protocolModules_xtdp_xtdl all; |
| import from ttcn_ericsson_se_TitanSim_Perftest all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from TestResultGen all; |
| |
| function f_EPTF_ExecCtrl_Test_DataSourceClientReady( |
| in charstring pl_source, |
| in charstring pl_ptcName) |
| runs on myMTC_UI{ |
| if (pl_source==c_ExecCtrl_DataSource_sourceId) { |
| v_ready := true; |
| } |
| } |
| |
| function f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive( |
| in charstring pl_name, |
| in EPTF_ExecCtrl_CT pl_execCtrlCompRef) |
| runs on EPTF_ExecCtrlClient_CT { |
| f_EPTF_LGenBase_init(pl_name); |
| f_EPTF_LGenBase_declareBehaviorType(c_EPTF_ExecCtrl_Test_defaultBehaviorName, -1, null, null, null); |
| f_EPTF_LGenBase_declareEntityType(c_EPTF_ExecCtrl_Test_defaultETypeName, {c_EPTF_ExecCtrl_Test_defaultBehaviorName}); |
| f_EPTF_LGenBase_declareFSMTable(c_EPTF_ExecCtrl_Test_defaultFSMWithFSMStatsLive); |
| f_EPTF_ExecCtrlClient_init_CT(pl_name, pl_execCtrlCompRef); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function f_ExecCtrl_PullModel_PerfTest_createDefaultLGenWithSpecIdWithFSMStatsLive ( |
| in charstring pl_hostname, |
| in charstring pl_componentName |
| ) runs on ExecCtrlDSClient_Test_CT return EPTF_ExecCtrlClient_CT |
| { |
| var EPTF_ExecCtrlClient_CT vl_lgen := EPTF_ExecCtrlClient_CT.create; |
| vl_lgen.start( f_EPTF_ExecCtrl_CLITest_defaultLGenBehaviourWithFSMStatsLive("ExecCtrl_DefaultLGen_"&log2str(v_lgenId),self) ); |
| v_lgenId := v_lgenId + 1; |
| return vl_lgen; |
| } |
| |
| function f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad() |
| runs on EPTF_LoadRegulator_CT |
| return float |
| { |
| return 1.0; |
| } |
| |
| function f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS(in float loadToReach, in float oldCps) |
| runs on PhaseRegulator_CT |
| return float |
| { |
| return loadToReach; |
| } |
| |
| function f_EPTF_ExecCtrl_Test_PhaseRegulator_behavior( |
| in charstring pl_selfName, |
| in EPTF_Var_CT pl_execCtrlCompRef, |
| in float pl_loadToReach) |
| runs on PhaseRegulator_CT |
| { |
| f_EPTF_LoadRegulator_init_CT(pl_selfName, |
| refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad), |
| refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_calcCPS)); |
| f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef); |
| f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| function f_ExecCtrl_Regulator_Test_RegulatorBehaviour( |
| in charstring pl_selfName, |
| in EPTF_ExecCtrl_CT pl_execCtrlCompRef, |
| in float pl_loadToReach := 0.0 |
| ) runs on EPTF_LoadRegulator_CT { |
| f_EPTF_LoadRegulator_init_CT(pl_selfName, |
| refers(f_EPTF_ExecCtrl_Test_PhaseRegulator_getSutLoad), |
| refers(f_EPTF_LoadRegulator_calculateNextCps_limitMax)); |
| f_EPTF_LoadRegulator_registerToExecCtrl(pl_execCtrlCompRef); |
| f_EPTF_LoadRegulator_adjustTargetLoadInExecCtrl(pl_loadToReach); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| |
| |
| |
| |
| |
| |
| function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main( |
| in integer pl_nofExternalStatHandlers := 0, |
| in boolean pl_usePullModeForStats := false |
| ) runs on ExecCtrl_NewGUITest_CT { |
| |
| // create lot of egrps: |
| var EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList vl_EPTF_ExecCtrl_EGrpList := c_EPTF_ExecCtrl_DefaultScenarios_EGrpList; |
| // create lof of egrp->sc assignments: |
| var EPTF_LGenBase_TcMgmt_Scenarios2GrpList vl_EPTF_ExecCtrl_Scenarios2GrpList := c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList; |
| // add all egrps to LgenPool: |
| var EPTF_ExecCtrl_EntityGroup2LGenPool_List vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := c_EPTF_ExecCtrl_DefaultScenarios_EntityGroup2LGenPool_List; |
| for(var integer i :=1; i<tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofEGrps; i:=i+1) { |
| vl_EPTF_ExecCtrl_EGrpList := vl_EPTF_ExecCtrl_EGrpList&{vl_EPTF_ExecCtrl_EGrpList[0]}; |
| vl_EPTF_ExecCtrl_EGrpList[i].name := vl_EPTF_ExecCtrl_EGrpList[i].name & int2str(i); |
| |
| vl_EPTF_ExecCtrl_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList&{vl_EPTF_ExecCtrl_Scenarios2GrpList[0]}; |
| vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i].eGrpName := vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i].eGrpName & int2str(i); |
| vl_EPTF_ExecCtrl_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList&{vl_EPTF_ExecCtrl_Scenarios2GrpList[1]}; |
| vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i+1].eGrpName := vl_EPTF_ExecCtrl_Scenarios2GrpList[2*i+1].eGrpName & int2str(i); |
| vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List&{vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[0]}; |
| |
| vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[i].eGrpName := vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[i].eGrpName&int2str(i); |
| } |
| |
| // set CPS to 1.0: |
| var float vl_targetCPS := 1.0; |
| var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_normalScenario := c_EPTF_ExecCtrl_DefaultScenarios_normalScenario; |
| vl_EPTF_ExecCtrl_normalScenario.tcList[0].tcParamsList[3].target.cpsToReach := vl_targetCPS; |
| vl_EPTF_ExecCtrl_normalScenario.tcList[1].tcParamsList[3].target.cpsToReach := vl_targetCPS; |
| var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_weightedScenario := c_EPTF_ExecCtrl_DefaultScenarios_weightedScenario; |
| vl_EPTF_ExecCtrl_weightedScenario.scParamsList[0].weightedScData.cpsToReach := vl_targetCPS; |
| var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_normalScenarioInScGrp := c_EPTF_ExecCtrl_DefaultScenarios_normalScenarioInScGrp; |
| vl_EPTF_ExecCtrl_normalScenarioInScGrp.tcList[0].tcParamsList[3].target.cpsToReach := vl_targetCPS; |
| vl_EPTF_ExecCtrl_normalScenarioInScGrp.tcList[1].tcParamsList[3].target.cpsToReach := vl_targetCPS; |
| var EPTF_LGenBase_ScenarioTypeDeclarator vl_EPTF_ExecCtrl_weightedScenarioInScGrp := c_EPTF_ExecCtrl_DefaultScenarios_weightedScenarioInScGrp; |
| vl_EPTF_ExecCtrl_weightedScenarioInScGrp.scParamsList[0].weightedScData.cpsToReach := vl_targetCPS; |
| |
| var EPTF_ExecCtrl_LGenPool_Declarators vl_EPTF_ExecCtrl_lgenPoolDeclarators := c_EPTF_ExecCtrl_Test_defaultLGenPoolWithSpecId_DeclaratorsWithFSMStatsLive; |
| vl_EPTF_ExecCtrl_lgenPoolDeclarators[0].lgenPoolItems[0].num := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofLgens; |
| |
| f_EPTF_ExecCtrl_loadConfig( |
| pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList := vl_EPTF_ExecCtrl_EGrpList, |
| pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList := vl_EPTF_ExecCtrl_Scenarios2GrpList& |
| c_EPTF_ExecCtrl_DefaultScenarios_Scenarios2GrpList_scGroups, |
| pl_EPTF_LGenBase_ScenarioDeclaratorList := {}, |
| pl_EPTF_LGenBase_tcTypeDeclaratorList := {}, |
| pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList := {c_EPTF_ExecCtrl_DefaultScenarios_defaultTCType}, |
| pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList := {}, |
| pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList:= {}, |
| pl_EPTF_ExecCtrl_TimeProfileDescrList:={}, |
| pl_EPTF_ExecCtrl_TimeProfileList:={}, |
| pl_EPTF_ExecCtrl_TimeProfile2TcList:={}, |
| pl_EPTF_LGenBase_ScenarioTypeDeclaratorList:= { |
| vl_EPTF_ExecCtrl_normalScenario,vl_EPTF_ExecCtrl_weightedScenario, |
| vl_EPTF_ExecCtrl_normalScenarioInScGrp,vl_EPTF_ExecCtrl_weightedScenarioInScGrp |
| }, |
| pl_EPTF_ExecCtrl_ScenarioInstanceTypeList:={}, |
| pl_EPTF_ExecCtrl_LGenPool_Declarators:=vl_EPTF_ExecCtrl_lgenPoolDeclarators, |
| pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List:=vl_EPTF_ExecCtrl_EntityGroup2LGenPool_List, |
| pl_EPTF_ExecCtrl_LGenFunction_Entry_List:={{ |
| name := omit, |
| fn := refers(f_ExecCtrl_PullModel_PerfTest_createDefaultLGenWithSpecIdWithFSMStatsLive) |
| }}, |
| pl_EPTF_ExecCtrl_PhaseList_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_phases, |
| pl_EPTF_ExecCtrl_ScenarioGroup_Declarators:=c_EPTF_ExecCtrl_DefaultScenarios_scGroups, |
| pl_EPTF_ExecCtrl_RegulatorNames:={}, |
| pl_EPTF_ExecCtrl_RegulatedItems:={} |
| ); |
| f_EPTF_ExecCtrl_setManualControl(true); |
| |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_ExecCtrl_Test_DataSourceClientReady )); |
| f_EPTF_ExecCtrl_CLI_init_CT( |
| pl_selfName := "ExecCtrl", |
| pl_nrOfClients := 0, |
| pl_createLGenPools := true, |
| pl_CLI_compRef := mtc, |
| pl_loadModulepars := true, |
| pl_autoStart := true, |
| pl_dataSource_compRef := mtc, |
| pl_nofExternalStatHandlers := pl_nofExternalStatHandlers, |
| pl_usePullModeForStats := pl_usePullModeForStats |
| ); |
| |
| } |
| function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_execCtrlBehaviour( |
| in integer pl_nofExternalStatHandlers := 0, |
| in boolean pl_usePullModeForStats := false |
| ) runs on ExecCtrl_NewGUITest_CT { |
| f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main(pl_nofExternalStatHandlers,pl_usePullModeForStats); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| |
| function f_EPTF_ExecCtrl_Test_checkReadyToRun() runs on ExecCtrl_NewGUITest_CT return boolean { |
| var EPTF_Var_DirectContent vl_value; |
| f_EPTF_DataSource_getDataValue( |
| pl_dataValue := vl_value, |
| pl_source := "ExecCtrl", |
| pl_ptcName := "", |
| pl_element := "ReadyToRun", |
| pl_params := {} |
| ); |
| return vl_value == {statusLEDVal := {led_green, "ReadyToRun"}}; |
| } |
| |
| altstep as_EPTF_ExecCtrl_Test_measureCPU() runs on ExecCtrl_PullModelPerfTest_CT { |
| [] t_cpuMeasure.timeout { |
| f_EPTF_HostAdmin_Base_update(); |
| |
| var float vl_cpuLoad := f_EPTF_HostAdmin_Base_getProcessCpuLoad(v_execCtrlPID); |
| f_EPTF_StatMeasure_addData_standardDev(v_execCtrlCPULoadStat,vl_cpuLoad); |
| //action("**** ExecCtrlCPULoad: ", vl_cpuLoad); |
| var float vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getProcessMemUsage(v_execCtrlPID)); |
| f_EPTF_StatMeasure_addData_standardDev(v_execCtrlMemUsageStat,vl_memUsage); |
| //action("**** ExecCtrlMemUsage: ", vl_memUsage); |
| |
| vl_cpuLoad := f_EPTF_HostAdmin_Base_getProcessCpuLoad(v_uiHandlerPID); |
| f_EPTF_StatMeasure_addData_standardDev(v_uiHandlerCPULoadStat,vl_cpuLoad); |
| //action("**** UIHandlerCPULoad: ", vl_cpuLoad); |
| vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getProcessMemUsage(v_uiHandlerPID)); |
| f_EPTF_StatMeasure_addData_standardDev(v_uiHandlerMemUsageStat,vl_memUsage); |
| //action("**** UIHandlerMemUsage: ", vl_memUsage); |
| |
| |
| vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad(); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad); |
| //action("**** HostCPULoad: ", vl_cpuLoad); |
| vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getFreeMemory()); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_memUsage); |
| //action("**** HostMemUsage: ", vl_memUsage); |
| |
| t_cpuMeasure.start; |
| repeat; |
| } |
| } |
| |
| function f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_mainTestCase( |
| in integer pl_nofExternalStatHandlers := 0, |
| in boolean pl_usePullModeForStats := false |
| ) runs on ExecCtrl_PullModelPerfTest_CT |
| { |
| |
| var integer vl_startNumOfEGrps := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofEGrps; //Number of egrps |
| var integer vl_lGenNum := tsp_EPTF_ExecCtrl_PullModel_PerfTest_nofLgens; // Number of LGens |
| var float vl_maxStartUpTime := tsp_EPTF_ExecCtrl_PullModel_PerfTest_maxStartUpTime; |
| |
| var Testresult vl_testResult; |
| vl_testResult.name := "ExecCtrl Pull Model Measurement"; |
| vl_testResult.purpose := "To measure CPU load on ExecCtrl and StatHandlers when pull model is used"; |
| f_TestResultGen_getEnvironment(vl_testResult.environment); |
| vl_testResult.parameter_list := { |
| {name := "Number of EntityGroups", unit := "-", base := log2str(vl_startNumOfEGrps) }, |
| {name := "Number of LGens", unit := "-", base := log2str(vl_lGenNum) }, |
| {name := "nofExternalStatHandlers", unit := "-", base := log2str(pl_nofExternalStatHandlers) }, |
| {name := "pullModelEnabled", unit := "-", base := log2str(pl_usePullModeForStats) }, |
| {name := "maxStartUpTime", unit := "sec", base := log2str(vl_maxStartUpTime) }, |
| {name := "EPTF_DEBUG", unit := "-", base := log2str(c_EPTF_Common_debugSwitch) } |
| }; |
| vl_testResult.result_list := {}; |
| // var charstring vl_startTime := f_getTimeFormatted(f_time(), "%c"); |
| var charstring vl_start_time := f_TestResultGen_getCurrentTime(); |
| vl_testResult.start_time := vl_start_time; |
| |
| var float vl_startTimeSystem := f_EPTF_Base_getRelTimeInSecs(); |
| |
| var charstring vl_wndLayout := c_EPTF_ExecCtrl_Test_defaultMainWindow_str; |
| f_EPTF_UIHandlerXUL_init_CT("UIHandler", true, vl_wndLayout,self); |
| f_EPTF_HostAdmin_Base_init_CT(f_EPTF_Base_selfName()); |
| f_EPTF_DataSource_init_CT(f_EPTF_Base_selfName()); |
| f_EPTF_StatMeasure_init_CT(f_EPTF_Base_selfName()); |
| v_execCtrlCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_execCtrlMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_uiHandlerCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_uiHandlerMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| |
| v_hostCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_hostFreeMemoryStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| |
| |
| //initial free mem an CPU load on host: |
| var float vl_cpuLoad, vl_freeMem; |
| f_EPTF_HostAdmin_Base_update(); |
| vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad(); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad); |
| vl_freeMem := int2float(f_EPTF_HostAdmin_Base_getFreeMemory()); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_freeMem); |
| f_EPTF_HostAdmin_Base_update(); |
| vl_cpuLoad := f_EPTF_HostAdmin_Base_getTesterHostLoad(); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostCPULoadStat,vl_cpuLoad); |
| vl_freeMem := int2float(f_EPTF_HostAdmin_Base_getFreeMemory()); |
| f_EPTF_StatMeasure_addData_standardDev(v_hostFreeMemoryStat,vl_freeMem); |
| |
| var float vl_avgHostCPULoad, vl_stdDevHostCPULoad; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad); |
| action("**** Host avg cpu initial: ", vl_avgHostCPULoad); |
| action("**** Host stdev cpu initial: ", vl_stdDevHostCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host initial CPU load", |
| unit := "sec", |
| base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad) |
| } |
| }; |
| var float vl_avgHostFreeMemory, vl_stdDevHostFreeMemory; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory); |
| action("**** Host avg FreeMem initial: ", vl_avgHostFreeMemory); |
| action("**** Host stdev FreeMem initial: ", vl_stdDevHostFreeMemory); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host initial FreeMem", |
| unit := "kB", |
| base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory) |
| } |
| }; |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat); |
| |
| timer t_wait := 0.0, t_maxWait := 5.0; |
| var charstring vl_dataVarName; |
| t_maxWait.start; |
| t_wait.start; |
| alt { |
| [0==f_EPTF_DataSource_checkData( |
| pl_dataVarName := vl_dataVarName, |
| pl_source := "UIHandler", |
| pl_ptcName := "", |
| pl_element := "progressBar", |
| pl_params := {} |
| )] t_wait.timeout; // wait for UIHander DS registration |
| [] t_maxWait.timeout { |
| setverdict(fail,"Cannot display progress information, UIHandler DS registration timed out"); |
| //f_EPTF_Base_stop(none); |
| } |
| } |
| |
| // f_EPTF_UIHandler_createGUI(" |
| // <Widgets xmlns='http://ttcn.ericsson.se/protocolModules/xtdp/xtdl'> |
| // <hbox flex='0.0' id='' orientation='horizontal'> |
| // <label flex='0.0' value='Progress:' /> |
| // <spacer flex='0.0' /> |
| // <textbox id='ProgressBar' flex='1.0' readonly='true' value=''> |
| // <externaldata element='progressBar' source='UIHandler'> |
| // <params> |
| // </params> |
| // </externaldata> |
| // </textbox> |
| // </hbox> |
| // </Widgets>", |
| // "EPTF_Main_Window" |
| // ); |
| |
| action("**** Starting ExecCtrl..."); |
| f_EPTF_DataSource_registerReadyCallback(refers(f_EPTF_ExecCtrl_Test_DataSourceClientReady )); |
| |
| var float vl_startTimeExecCtrl := f_EPTF_Base_getRelTimeInSecs(); |
| var ExecCtrl_NewGUITest_CT vl_execCtrl := ExecCtrl_NewGUITest_CT.create; |
| vl_execCtrl.start(f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_execCtrlBehaviour(pl_nofExternalStatHandlers,pl_usePullModeForStats)); |
| //var ExecCtrl_NewGUITest_CT vl_execCtrl := self; |
| //f_ExecCtrl_DS_UIFromXUL_With_ExternalStatHandler_LotOfEGrps_main(); |
| |
| // start the regulators: |
| var PhaseRegulator_CT vl_regulator1 := PhaseRegulator_CT.create; |
| vl_regulator1.start(f_EPTF_ExecCtrl_Test_PhaseRegulator_behavior("Regulator 1",vl_execCtrl,1.0)); |
| var EPTF_LoadRegulator_CT vl_regulator2 := EPTF_LoadRegulator_CT.create; |
| vl_regulator2.start(f_ExecCtrl_Regulator_Test_RegulatorBehaviour("Regulator 3",vl_execCtrl,1.0)); |
| |
| t_wait.start(2.0); |
| t_wait.timeout; |
| v_execCtrlPID := f_EPTF_Base_getPidByName("ExecCtrl"); |
| v_uiHandlerPID := f_EPTF_Base_getPidByName("UIHandler"); |
| activate(as_EPTF_ExecCtrl_Test_measureCPU()); |
| action("**** All component info: ",f_EPTF_Base_getComponentInfoAll()); |
| action("**** ExecCtrl Pid: ", v_execCtrlPID); |
| action("**** UIHandler Pid: ", v_uiHandlerPID); |
| f_EPTF_HostAdmin_Base_addProcessStat(v_execCtrlPID); |
| f_EPTF_HostAdmin_Base_addProcessStat(v_uiHandlerPID); |
| |
| timer T_guard, T_alt; |
| T_guard.start( vl_maxStartUpTime ); |
| T_alt.start( 0.0 ); |
| alt{ |
| [] T_guard.timeout{ |
| setverdict(fail,"Timeout during config"); |
| // f_EPTF_Base_stopAll(); |
| } |
| [v_ready and f_EPTF_ExecCtrl_Test_checkReadyToRun()] T_alt.timeout{} |
| }; |
| // f_EPTF_ExecCtrl_startAllScenarios(); |
| //log(%definitionId&"--bubu-----------------------------------"&f_EPTF_UIHandler_snapshot()) |
| //f_EPTF_UIHandler_clearGUI(); //gui.xml contains window => should start with empty gui |
| |
| var float vl_endTimeExecCtrl := f_EPTF_Base_getRelTimeInSecs(); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl startup time", |
| unit := "sec", |
| base := log2str(vl_endTimeExecCtrl-vl_startTimeExecCtrl) |
| } |
| }; |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "System startup time", |
| unit := "sec", |
| base := log2str(vl_endTimeExecCtrl-vl_startTimeSystem) |
| } |
| }; |
| action("ExecCtrl startup time: ", vl_endTimeExecCtrl-vl_startTimeExecCtrl," secs"); |
| action("System startup time: ", vl_endTimeExecCtrl-vl_startTimeSystem," secs"); |
| |
| action("**** Building GUI..."); |
| t_cpuMeasure.start; |
| var float vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| f_EPTF_UIHandler_createGUIFromFile(tsp_ExecCtrl_DS_guiXmlName,""/*c_ExecCtrl_DS_customGUIHBox*/); |
| var float vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| action("GUI Build up time: ", vl_endTime-vl_startTime," secs"); |
| |
| t_cpuMeasure.stop; |
| |
| vl_testResult.end_time := f_TestResultGen_getCurrentTime(); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "GUI Build up time", |
| unit := "sec", |
| base := log2str(vl_endTime-vl_startTime) |
| } |
| }; |
| |
| var float vl_avgExecCtrlCPULoad, vl_stdDevExecCtrlCPULoad; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad); |
| action("**** ExecCtrl avg cpu createGUI: ", vl_avgExecCtrlCPULoad); |
| action("**** ExecCtrl stdev cpu createGUI: ", vl_stdDevExecCtrlCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl CPU load during GUI buildup", |
| unit := "%", |
| base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad) |
| } |
| }; |
| var float vl_avgExecCtrlMemUsage, vl_stdDevExecCtrlMemUsage; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage); |
| action("**** ExecCtrl avg MemUsage createGUI: ", vl_avgExecCtrlMemUsage); |
| action("**** ExecCtrl stdev MemUsage createGUI: ", vl_stdDevExecCtrlMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl MemUsage during GUI buildup", |
| unit := "kB", |
| base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage) |
| } |
| }; |
| |
| var float vl_avgUIHandlerCPULoad, vl_stdDevUIHandlerCPULoad; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad); |
| action("**** UIHandler avg cpu createGUI: ", vl_avgUIHandlerCPULoad); |
| action("**** UIHandler stdev cpu createGUI: ", vl_stdDevUIHandlerCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler CPU load during GUI buildup", |
| unit := "%", |
| base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad) |
| } |
| }; |
| var float vl_avgUIHandlerMemUsage, vl_stdDevUIHandlerMemUsage; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage); |
| action("**** UIHandler avg MemUsage createGUI: ", vl_avgUIHandlerMemUsage); |
| action("**** UIHandler stdev MemUsage createGUI: ", vl_stdDevUIHandlerMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler MemUsage during GUI buildup", |
| unit := "kB", |
| base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage) |
| } |
| }; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad); |
| action("**** Host avg cpu createGUI: ", vl_avgHostCPULoad); |
| action("**** Host stdev cpu createGUI: ", vl_stdDevHostCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host CPU load during GUI buildup", |
| unit := "%", |
| base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory); |
| action("**** Host avg FreeMem createGUI: ", vl_avgHostFreeMemory); |
| action("**** Host stdev FreeMem createGUI: ", vl_stdDevHostFreeMemory); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host FreeMem during GUI buildup", |
| unit := "kB", |
| base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory) |
| } |
| }; |
| |
| // wait until subscribe finishes (UIHandler load decreases below 10): |
| action("*** Waiting for UIHandler to be idle"); |
| vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat); |
| t_cpuMeasure.start; |
| timer T_measurePeriod := 10.0; |
| T_measurePeriod.start |
| alt { |
| [] T_measurePeriod.timeout { |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad); |
| if (vl_avgUIHandlerCPULoad>10.0) { |
| T_measurePeriod.start |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat); |
| repeat; |
| } |
| } |
| } |
| t_cpuMeasure.stop; |
| vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler time to idle", |
| unit := "sec", |
| base := log2str(vl_endTime-vl_startTime) |
| } |
| }; |
| action("*** UIHandler is idle"); |
| |
| // measure Idle state CPU: |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlMemUsageStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerMemUsageStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat); |
| |
| |
| t_cpuMeasure.start; |
| |
| timer T_g2; |
| T_g2.start( 10.0 ); // idle gen measure time |
| T_g2.timeout; |
| t_cpuMeasure.stop; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad); |
| action("**** ExecCtrl avg cpu idle: ", vl_avgExecCtrlCPULoad); |
| action("**** ExecCtrl stdev cpu idle: ", vl_stdDevExecCtrlCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl idle CPU load", |
| unit := "%", |
| base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage); |
| action("**** ExecCtrl avg MemUsage idle: ", vl_avgExecCtrlMemUsage); |
| action("**** ExecCtrl stdev MemUsage idle: ", vl_stdDevExecCtrlMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl idle MemUsage", |
| unit := "kB", |
| base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage) |
| } |
| }; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad); |
| action("**** UIHandler avg cpu idle: ", vl_avgUIHandlerCPULoad); |
| action("**** UIHandler stdev cpu idle: ", vl_stdDevUIHandlerCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler idle CPU load", |
| unit := "%", |
| base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage); |
| action("**** UIHandler avg MemUsage idle: ", vl_avgUIHandlerMemUsage); |
| action("**** UIHandler stdev MemUsage idle: ", vl_stdDevUIHandlerMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler idle MemUsage", |
| unit := "kB", |
| base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage) |
| } |
| }; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad); |
| action("**** Host avg cpu idle: ", vl_avgHostCPULoad); |
| action("**** Host stdev cpu idle: ", vl_stdDevHostCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host idle CPU load", |
| unit := "%", |
| base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory); |
| action("**** Host avg FreeMem idle: ", vl_avgHostFreeMemory); |
| action("**** Host stdev FreeMem idle: ", vl_stdDevHostFreeMemory); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host idle FreeMem", |
| unit := "kB", |
| base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory) |
| } |
| }; |
| |
| action("**** Starting load generation..."); |
| |
| // measure CPU load during load generation: |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlMemUsageStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_uiHandlerMemUsageStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat); |
| |
| var EPTF_Var_DirectContent vl_dataValue := {intVal := 1}; |
| f_EPTF_DataSource_setDataValue( |
| pl_dataValue := vl_dataValue, |
| pl_source := c_ExecCtrl_DataSource_sourceId, |
| pl_ptcName := "", |
| pl_element := c_ExecCtrl_dataElementStart, |
| pl_params := {} |
| ) |
| |
| t_cpuMeasure.start; |
| T_g2.start( 60.0 ); // load gen gen measure time |
| T_g2.timeout; |
| t_cpuMeasure.stop; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlCPULoadStat,vl_avgExecCtrlCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlCPULoadStat,vl_stdDevExecCtrlCPULoad); |
| action("**** ExecCtrl avg cpu during loadGen: ", vl_avgExecCtrlCPULoad); |
| action("**** ExecCtrl stdev cpu during loadGen: ", vl_stdDevExecCtrlCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl CPU load during load generation", |
| unit := "%", |
| base := log2str(vl_avgExecCtrlCPULoad)&"+-"&log2str(vl_stdDevExecCtrlCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlMemUsageStat,vl_avgExecCtrlMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlMemUsageStat,vl_stdDevExecCtrlMemUsage); |
| action("**** ExecCtrl avg MemUsage during loadGen: ", vl_avgExecCtrlMemUsage); |
| action("**** ExecCtrl stdev MemUsage during loadGen: ", vl_stdDevExecCtrlMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl MemUsage during load generation", |
| unit := "kB", |
| base := log2str(float2int(vl_avgExecCtrlMemUsage))&"+-"&log2str(vl_stdDevExecCtrlMemUsage) |
| } |
| }; |
| |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerCPULoadStat,vl_avgUIHandlerCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerCPULoadStat,vl_stdDevUIHandlerCPULoad); |
| action("**** UIHandler avg cpu during loadGen: ", vl_avgUIHandlerCPULoad); |
| action("**** UIHandler stdev cpu during loadGen: ", vl_stdDevUIHandlerCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler CPU load during load generation", |
| unit := "%", |
| base := log2str(vl_avgUIHandlerCPULoad)&"+-"&log2str(vl_stdDevUIHandlerCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_uiHandlerMemUsageStat,vl_avgUIHandlerMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_uiHandlerMemUsageStat,vl_stdDevUIHandlerMemUsage); |
| action("**** UIHandler avg MemUsage during loadGen: ", vl_avgUIHandlerMemUsage); |
| action("**** UIHandler stdev MemUsage during loadGen: ", vl_stdDevUIHandlerMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "UIHandler MemUsage during load generation", |
| unit := "kB", |
| base := log2str(float2int(vl_avgUIHandlerMemUsage))&"+-"&log2str(vl_stdDevUIHandlerMemUsage) |
| } |
| }; |
| |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostCPULoadStat,vl_avgHostCPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostCPULoadStat,vl_stdDevHostCPULoad); |
| action("**** Host avg cpu during loadGen: ", vl_avgHostCPULoad); |
| action("**** Host stdev cpu during loadGen: ", vl_stdDevHostCPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host CPU load during load generation", |
| unit := "%", |
| base := log2str(vl_avgHostCPULoad)&"+-"&log2str(vl_stdDevHostCPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_hostFreeMemoryStat,vl_avgHostFreeMemory); |
| f_EPTF_StatMeasure_getStat_standardDev(v_hostFreeMemoryStat,vl_stdDevHostFreeMemory); |
| action("**** Host avg FreeMem during loadGen: ", vl_avgHostFreeMemory); |
| action("**** Host stdev FreeMem during loadGen: ", vl_stdDevHostFreeMemory); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "Host FreeMem during load generation", |
| unit := "kB", |
| base := log2str(float2int(vl_avgHostFreeMemory))&"+-"&log2str(vl_stdDevHostFreeMemory) |
| } |
| }; |
| |
| vl_testResult.end_time := f_TestResultGen_getCurrentTime(); |
| f_TestResultGen_appendResult("ExecCtrl_PullModel_PerfTest_"&vl_start_time&".xml", vl_testResult); |
| |
| } |
| |
| |
| } //end of module EPTF_ExecCtrl_PullModel_PerfTest_Functions |