test/ExecCtrl/EPTF_ExecCtrl_PullModelDsRestAPI_PerfTest_Functions.ttcn

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Copyright (c) 2000-2017 Ericsson Telecom AB                               //
//                                                                           //
// All rights reserved. This program and the accompanying materials          //
// are made available under the terms of the Eclipse Public License v1.0     //
// which accompanies this distribution, and is available at                  //
// http://www.eclipse.org/legal/epl-v10.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