| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_PullModelDsRestAPI_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_DsRestAPI_WidgetFunctions> |
| // <EPTF_CLL_ExecCtrlDsRestAPI_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_PullModelDsRestAPI_PerfTest_Functions { |
| |
| import from EPTF_ExecCtrl_PullModelDsRestAPI_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_CLI_Functions all; |
| import from EPTF_CLL_StatManager_Functions all; |
| |
| import from EPTF_CLL_DsRestAPI_Functions all; |
| import from ttcn_ericsson_se_TitanSim_Perftest all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_DsRestAPI_DSServer_Functions all; |
| |
| import from TCCEnv_Functions all; |
| import from TCCFileIO_Functions all; |
| import from TCCConversion_Functions 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_PullModelDsRestAPI_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_PullModelDsRestAPI_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_PullModelDsRestAPI_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_PullModelDsRestAPI_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_DsRestAPIPID); |
| f_EPTF_StatMeasure_addData_standardDev(v_DsRestAPICPULoadStat,vl_cpuLoad); |
| //action("**** DsRestAPICPULoad: ", vl_cpuLoad); |
| vl_memUsage := int2float(f_EPTF_HostAdmin_Base_getProcessMemUsage(v_DsRestAPIPID)); |
| f_EPTF_StatMeasure_addData_standardDev(v_DsRestAPIMemUsageStat,vl_memUsage); |
| //action("**** DsRestAPIMemUsage: ", 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; |
| } |
| } |
| |
| altstep as_EPTF_ExecCtrl_Test_measureSingleReqTime() runs on ExecCtrl_PullModelPerfTest_CT { |
| [] t_singleReqTimeMeasure.timeout { |
| |
| var EPTF_Var_DirectContent vl_dataValue; |
| var float vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| |
| var integer vl_errorCode := f_EPTF_DataSource_getDataValue( |
| pl_dataValue := vl_dataValue, |
| pl_source := "ExecCtrl", |
| pl_ptcName := "", |
| pl_element := "TcStat", |
| pl_params := { |
| { |
| paramName := "EntityGroup", |
| paramValue := "DefaultEGrp" |
| }, |
| { |
| paramName := "Scenario", |
| paramValue := "DefaultSc" |
| }, |
| { |
| paramName := "TrafficCase", |
| paramValue := "DefaultTC1" |
| }, |
| { |
| paramName := "Statistic", |
| paramValue := "Starts" |
| } |
| } |
| ); |
| var float vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| |
| if (vl_errorCode!=0) { |
| // invalid request |
| t_singleReqTimeMeasure.start; |
| repeat; |
| } |
| |
| var float vl_singleReqTime := vl_endTime - vl_startTime; |
| f_EPTF_StatMeasure_addData_standardDev(v_execCtrlSingleReqTimeStat,vl_singleReqTime); |
| //action("**** ExecCtrlSingleReqTime: ", vl_singleReqTime); |
| |
| t_singleReqTimeMeasure.start; |
| repeat; |
| } |
| } |
| |
| external function ef_EPTF_DsRestAPI_Test_getJSON(in charstring pl_fileContent) return charstring; |
| |
| function f_EPTF_DsRestAPI_Test_getFileContent( |
| in charstring pl_path |
| ) return charstring{ |
| |
| var charstring vl_retVal := ""; |
| var integer vl_numOfReadedBytes := -1; |
| var integer vl_endOfFile := -1; |
| var integer vl_fd := -1; |
| |
| vl_fd := f_FIO_open_rdonly(pl_path); |
| vl_endOfFile := f_FIO_seek_end(vl_fd); |
| f_FIO_seek_home(vl_fd); |
| |
| if(vl_fd < 0){ |
| log("File: ", pl_path," cannot be opened, ignored."); |
| log (f_FIO_get_error_string()); |
| } |
| else{ |
| vl_numOfReadedBytes := f_FIO_read_text(vl_fd, vl_retVal, vl_endOfFile); |
| if(vl_numOfReadedBytes < 0) |
| { |
| log("File: ", pl_path," cannot be readed"); |
| log (f_FIO_get_error_string ()); |
| } |
| } |
| |
| return vl_retVal; |
| } |
| |
| altstep as_EPTF_ExecCtrl_Test_measureFullReqTime() runs on ExecCtrl_PullModelPerfTest_CT { |
| [] t_fullReqTimeMeasure.timeout { |
| |
| var float vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| var octetstring vl_getDataAnswer := f_EPTF_DsRestAPI_DSServer_processJSONRequest(v_requestOct); |
| var float vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| |
| //action("**** vl_getDataAnswer: ",oct2char(vl_getDataAnswer)); |
| |
| var float vl_fullReqTime := vl_endTime - vl_startTime; |
| f_EPTF_StatMeasure_addData_standardDev(v_execCtrlFullReqTimeStat,vl_fullReqTime); |
| //action("**** ExecCtrlFullReqTime: ", vl_fullReqTime); |
| |
| t_fullReqTimeMeasure.start; |
| repeat; |
| } |
| } |
| |
| altstep as_EPTF_ExecCtrl_Test_measureFullReqTimeHTTP() runs on ExecCtrl_PullModelPerfTest_CT { |
| [] t_fullReqTimeHTTPMeasure.timeout { |
| |
| var charstring vl_commandToExecute := "./"&tsp_DsRestAPI_Test_sendDSRequestScript&" "&int2str(tsp_EPTF_DsRestAPI_HTTPServer_RemotePort)&" '"&v_requestString&"'"; |
| //action("**** Executing command: ", vl_commandToExecute); |
| var charstring vl_stdout := ""; |
| var charstring vl_stderr := ""; |
| |
| var float vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| if(f_EPTF_Base_executeShell(vl_commandToExecute, vl_stdout, vl_stderr) != 0){ |
| log("STD ERROR: ",vl_stderr); |
| } |
| var float vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| |
| vl_stdout := f_stripWhitespaces(vl_stdout); // remove "\n" from the end of string |
| //action("**** response: ",vl_stdout); |
| //action("**** response err: ",vl_stderr); |
| |
| var float vl_FullReqTimeHTTP := vl_endTime - vl_startTime; |
| f_EPTF_StatMeasure_addData_standardDev(v_execCtrlFullReqTimeHTTPStat,vl_FullReqTimeHTTP); |
| //action("**** ExecCtrlFullReqTimeHTTP: ", vl_FullReqTimeHTTP); |
| |
| t_fullReqTimeHTTPMeasure.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 |
| { |
| |
| f_PutEnv("PYTHONDONTWRITEBYTECODE", "True"); |
| var charstring vl_requestFileContent := f_EPTF_DsRestAPI_Test_getFileContent("./FullReq.json"); |
| v_requestString := ef_EPTF_DsRestAPI_Test_getJSON(vl_requestFileContent); |
| v_requestOct := char2oct(v_requestString); |
| |
| var integer vl_startNumOfEGrps := tsp_EPTF_ExecCtrl_PullModelDsRestAPI_PerfTest_nofEGrps; //Number of egrps |
| var integer vl_lGenNum := tsp_EPTF_ExecCtrl_PullModelDsRestAPI_PerfTest_nofLgens; // Number of LGens |
| var float vl_maxStartUpTime := tsp_EPTF_ExecCtrl_PullModelDsRestAPI_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_DsRestAPI_init_CT("DsRestAPI"); |
| f_EPTF_DsRestAPI_start( |
| pl_hostIPAddress := tsp_EPTF_DsRestAPI_HTTPServer_RemoteAddress, |
| pl_hostPort := tsp_EPTF_DsRestAPI_HTTPServer_RemotePort, |
| pl_HTTPServer_dir := tsp_EPTF_DsRestAPI_HTTPServer_directory, |
| pl_customizableApp_dir := tsp_EPTF_DsRestAPI_customizableApp_directory, |
| pl_API_dir := tsp_EPTF_DsRestAPI_API_directory |
| ); |
| f_EPTF_CLI_init_CT(f_EPTF_Base_selfName()); |
| 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()); |
| f_EPTF_StatManager_init_CT(f_EPTF_Base_selfName()); |
| v_execCtrlCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_execCtrlMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_DsRestAPICPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_DsRestAPIMemUsageStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| |
| v_hostCPULoadStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_hostFreeMemoryStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| |
| v_execCtrlSingleReqTimeStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_execCtrlFullReqTimeStat := f_EPTF_StatMeasure_newStat_standardDev(); |
| v_execCtrlFullReqTimeHTTPStat := 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; |
| t_maxWait.start; |
| t_wait.start; |
| alt { |
| [] t_maxWait.timeout { |
| } |
| } |
| |
| 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_DsRestAPIPID := f_EPTF_Base_getPidByName("DsRestAPI"); |
| activate(as_EPTF_ExecCtrl_Test_measureCPU()); |
| action("**** All component info: ",f_EPTF_Base_getComponentInfoAll()); |
| action("**** ExecCtrl Pid: ", v_execCtrlPID); |
| action("**** DsRestAPI Pid: ", v_DsRestAPIPID); |
| f_EPTF_HostAdmin_Base_addProcessStat(v_execCtrlPID); |
| f_EPTF_HostAdmin_Base_addProcessStat(v_DsRestAPIPID); |
| |
| 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_DsRestAPI_snapshot()) |
| //f_EPTF_DsRestAPI_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(); |
| // no createGUI in DsRestAPI!! |
| 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_avgDsRestAPICPULoad, vl_stdDevDsRestAPICPULoad; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_DsRestAPICPULoadStat,vl_avgDsRestAPICPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPICPULoadStat,vl_stdDevDsRestAPICPULoad); |
| action("**** DsRestAPI avg cpu createGUI: ", vl_avgDsRestAPICPULoad); |
| action("**** DsRestAPI stdev cpu createGUI: ", vl_stdDevDsRestAPICPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI CPU load during GUI buildup", |
| unit := "%", |
| base := log2str(vl_avgDsRestAPICPULoad)&"+-"&log2str(vl_stdDevDsRestAPICPULoad) |
| } |
| }; |
| var float vl_avgDsRestAPIMemUsage, vl_stdDevDsRestAPIMemUsage; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_DsRestAPIMemUsageStat,vl_avgDsRestAPIMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPIMemUsageStat,vl_stdDevDsRestAPIMemUsage); |
| action("**** DsRestAPI avg MemUsage createGUI: ", vl_avgDsRestAPIMemUsage); |
| action("**** DsRestAPI stdev MemUsage createGUI: ", vl_stdDevDsRestAPIMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI MemUsage during GUI buildup", |
| unit := "kB", |
| base := log2str(float2int(vl_avgDsRestAPIMemUsage))&"+-"&log2str(vl_stdDevDsRestAPIMemUsage) |
| } |
| }; |
| |
| 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 (DsRestAPI load decreases below 10): |
| action("*** Waiting for DsRestAPI to be idle"); |
| vl_startTime := f_EPTF_Base_getRelTimeInSecs(); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_DsRestAPICPULoadStat); |
| t_cpuMeasure.start; |
| timer T_measurePeriod := 10.0; |
| T_measurePeriod.start |
| alt { |
| [] T_measurePeriod.timeout { |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_DsRestAPICPULoadStat,vl_avgDsRestAPICPULoad); |
| if (vl_avgDsRestAPICPULoad>10.0) { |
| T_measurePeriod.start |
| f_EPTF_StatMeasure_resetStat_standardDev(v_DsRestAPICPULoadStat); |
| repeat; |
| } |
| } |
| } |
| t_cpuMeasure.stop; |
| vl_endTime := f_EPTF_Base_getRelTimeInSecs(); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI time to idle", |
| unit := "sec", |
| base := log2str(vl_endTime-vl_startTime) |
| } |
| }; |
| action("*** DsRestAPI 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_DsRestAPICPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_DsRestAPIMemUsageStat); |
| 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_DsRestAPICPULoadStat,vl_avgDsRestAPICPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPICPULoadStat,vl_stdDevDsRestAPICPULoad); |
| action("**** DsRestAPI avg cpu idle: ", vl_avgDsRestAPICPULoad); |
| action("**** DsRestAPI stdev cpu idle: ", vl_stdDevDsRestAPICPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI idle CPU load", |
| unit := "%", |
| base := log2str(vl_avgDsRestAPICPULoad)&"+-"&log2str(vl_stdDevDsRestAPICPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_DsRestAPIMemUsageStat,vl_avgDsRestAPIMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPIMemUsageStat,vl_stdDevDsRestAPIMemUsage); |
| action("**** DsRestAPI avg MemUsage idle: ", vl_avgDsRestAPIMemUsage); |
| action("**** DsRestAPI stdev MemUsage idle: ", vl_stdDevDsRestAPIMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI idle MemUsage", |
| unit := "kB", |
| base := log2str(float2int(vl_avgDsRestAPIMemUsage))&"+-"&log2str(vl_stdDevDsRestAPIMemUsage) |
| } |
| }; |
| |
| 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..."); |
| activate(as_EPTF_ExecCtrl_Test_measureSingleReqTime()); |
| activate(as_EPTF_ExecCtrl_Test_measureFullReqTime()); |
| activate(as_EPTF_ExecCtrl_Test_measureFullReqTimeHTTP()); |
| |
| // 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_DsRestAPICPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_DsRestAPIMemUsageStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostCPULoadStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_hostFreeMemoryStat); |
| |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlSingleReqTimeStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlFullReqTimeStat); |
| f_EPTF_StatMeasure_resetStat_standardDev(v_execCtrlFullReqTimeHTTPStat); |
| |
| 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 := {} |
| ) |
| |
| action("**** Measuring single request time..."); |
| t_cpuMeasure.start; |
| t_singleReqTimeMeasure.start; |
| T_g2.start( 60.0 ); // load gen gen measure time |
| T_g2.timeout; |
| t_singleReqTimeMeasure.stop; |
| |
| action("**** Measuring full request time..."); |
| t_fullReqTimeMeasure.start; |
| T_g2.start( 60.0 ); // load gen gen measure time |
| T_g2.timeout; |
| t_fullReqTimeMeasure.stop; |
| |
| action("**** Measuring full request via HTTP time..."); |
| t_fullReqTimeHTTPMeasure.start; |
| T_g2.start( 60.0 ); // load gen gen measure time |
| T_g2.timeout; |
| t_cpuMeasure.stop; |
| t_fullReqTimeHTTPMeasure.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_DsRestAPICPULoadStat,vl_avgDsRestAPICPULoad); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPICPULoadStat,vl_stdDevDsRestAPICPULoad); |
| action("**** DsRestAPI avg cpu during loadGen: ", vl_avgDsRestAPICPULoad); |
| action("**** DsRestAPI stdev cpu during loadGen: ", vl_stdDevDsRestAPICPULoad); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI CPU load during load generation", |
| unit := "%", |
| base := log2str(vl_avgDsRestAPICPULoad)&"+-"&log2str(vl_stdDevDsRestAPICPULoad) |
| } |
| }; |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_DsRestAPIMemUsageStat,vl_avgDsRestAPIMemUsage); |
| f_EPTF_StatMeasure_getStat_standardDev(v_DsRestAPIMemUsageStat,vl_stdDevDsRestAPIMemUsage); |
| action("**** DsRestAPI avg MemUsage during loadGen: ", vl_avgDsRestAPIMemUsage); |
| action("**** DsRestAPI stdev MemUsage during loadGen: ", vl_stdDevDsRestAPIMemUsage); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "DsRestAPI MemUsage during load generation", |
| unit := "kB", |
| base := log2str(float2int(vl_avgDsRestAPIMemUsage))&"+-"&log2str(vl_stdDevDsRestAPIMemUsage) |
| } |
| }; |
| |
| 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) |
| } |
| }; |
| |
| var float vl_avgExecCtrlSingleReqTime,vl_stdDevExecCtrlSingleReqTime |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlSingleReqTimeStat,vl_avgExecCtrlSingleReqTime); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlSingleReqTimeStat,vl_stdDevExecCtrlSingleReqTime); |
| action("**** ExecCtrl avg singleReqTime loadGen: ", vl_avgExecCtrlSingleReqTime); |
| action("**** ExecCtrl stdev singleReqTime during loadGen: ", vl_stdDevExecCtrlSingleReqTime); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl Single Request Time during load generation", |
| unit := "sec", |
| base := log2str(vl_avgExecCtrlSingleReqTime)&"+-"&log2str(vl_stdDevExecCtrlSingleReqTime) |
| } |
| }; |
| |
| var float vl_avgExecCtrlFullReqTime,vl_stdDevExecCtrlFullReqTime |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlFullReqTimeStat,vl_avgExecCtrlFullReqTime); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlFullReqTimeStat,vl_stdDevExecCtrlFullReqTime); |
| action("**** ExecCtrl avg FullReqTime loadGen: ", vl_avgExecCtrlFullReqTime); |
| action("**** ExecCtrl stdev FullReqTime during loadGen: ", vl_stdDevExecCtrlFullReqTime); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl Full Request Time during load generation", |
| unit := "sec", |
| base := log2str(vl_avgExecCtrlFullReqTime)&"+-"&log2str(vl_stdDevExecCtrlFullReqTime) |
| } |
| }; |
| |
| var float vl_avgExecCtrlFullReqTimeHTTP,vl_stdDevExecCtrlFullReqTimeHTTP |
| f_EPTF_StatMeasure_getStat_standardDev_mean(v_execCtrlFullReqTimeHTTPStat,vl_avgExecCtrlFullReqTimeHTTP); |
| f_EPTF_StatMeasure_getStat_standardDev(v_execCtrlFullReqTimeHTTPStat,vl_stdDevExecCtrlFullReqTimeHTTP); |
| action("**** ExecCtrl avg FullReqTimeHTTP loadGen: ", vl_avgExecCtrlFullReqTimeHTTP); |
| action("**** ExecCtrl stdev FullReqTimeHTTP during loadGen: ", vl_stdDevExecCtrlFullReqTimeHTTP); |
| vl_testResult.result_list := vl_testResult.result_list & { |
| { |
| name := "ExecCtrl Full Request Time via HTTP during load generation", |
| unit := "sec", |
| base := log2str(vl_avgExecCtrlFullReqTimeHTTP)&"+-"&log2str(vl_stdDevExecCtrlFullReqTimeHTTP) |
| } |
| }; |
| |
| vl_testResult.end_time := f_TestResultGen_getCurrentTime(); |
| f_TestResultGen_appendResult("ExecCtrl_PullModelDsRestAPI_PerfTest_"&vl_start_time&".xml", vl_testResult); |
| |
| } |
| |
| |
| } //end of module EPTF_ExecCtrl_PullModelDsRestAPI_PerfTest_Functions |