test/LGenBase/PerformanceTests/MemUsage/EPTF_LGenBasePerformTest_MemTestCases.ttcnpp

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// 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_LGenBasePerformTest_MemTestCases
//
//  Purpose:
//    This module provides functions for testing LGenBase
//
//  Module depends on:
//    -
//
//  Current Owner:
//    Laszlo Skumat (ELSZSKU)
//
//  Last Review Date:
//    2008-09-11
//
//  Detailed Comments:
//    Provide functions to test LGenBase
//
//
///////////////////////////////////////////////////////////////
module EPTF_LGenBasePerformTest_MemTestCases
{
import from EPTF_LGenBasePerformTest_MTASDefinitions all
import from EPTF_LGenBasePerformTest_MTASFunctions all
import from EPTF_LGenBasePerformTest_MemMTCDefinitions all
import from EPTF_LGenBasePerformTest_MemMTCFunctions all
import from EPTF_LGenBasePerformTest_MemLoadgenDefinitions all
import from EPTF_LGenBasePerformTest_MemLoadgenFunctions all
import from EPTF_LGenBasePerformTest_MemMessages all
import from EPTF_LGenBasePerformTest_MTCFunctions all
import from EPTF_CLL_LGenBase_Definitions all;
import from EPTF_LGenBasePerformTest_LoadMessages all

//import from EPTF_LGenBasePerformTest_TestCases all
import from EPTF_CLL_Base_Functions all
import from PIPEasp_Types all;
import from TCCFileIO_Functions all

#ifdef R3
import from EPTF_CLL_Common_Definitions all
import from EPTF_CLL_LGenBase_ConfigDefinitions all;
#endif
#ifdef R2
import from EPTF_CLL_Definitions all
import from EPTF_CLL_RBTScheduler_Functions all;
#endif

import from ttcn_ericsson_se_TitanSim_Perftest all;
import from TestResultGen all;

function f_LGenBasePerformTest_MTAS_prepareLGen(
  in charstring pl_lgenName)
runs on EPTF_LGenBasePerformTest_MemMTC_CT 
return EPTF_LGenBasePerformTest_CT{
  var EPTF_LGenBasePerformTest_CT vc_performTest_CT;
  vc_performTest_CT := EPTF_LGenBasePerformTest_CT.create;
  vc_performTest_CT.start(f_EPTF_LGenBasePerformTest_MTAS_start(pl_lgenName));
  connect(self:v_controlPort,vc_performTest_CT:v_controlPort);
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_pID := {""}})
  return vc_performTest_CT
}

function f_EPTF_LGenBasePerformTest_MTAS_start(in charstring pl_lgenName)
runs on EPTF_LGenBasePerformTest_CT{
  f_EPTF_LGenBasePerformTest_init(pl_lgenName);
  f_EPTF_LGenBasePerformTest_MTAS_initEvents()
  T_EPTF_componentClock.timeout;
}

function f_LGenBasePerformTest_MTAS_performEntitySize(
  in integer pl_eCount,
  out float pl_duration,
  out float pl_memUsage,
  in boolean pl_useTc)
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_EPTF_LGenBasePerformTest_sendControlMessage(
    {v_MeasureControl_initLGenBase := {"b1",-1}},
    refers(f_EPTF_LGenBasePerformanceTest_handleStart))
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareEntityType := {"e1","b1"}});
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_createEntityGroup := {"g1","e1",pl_eCount}});
  //TC types
  var EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList vl_tcTypes := {
  }
  for ( var integer vl_i := 0; vl_i < sizeof(c_FSMNames) ; vl_i := vl_i+1 ){
    vl_tcTypes[vl_i] := {
      name := c_FSMNames[vl_i],
      fsmName := c_FSMNames[vl_i],
      entityType := "e1",
      customEntitySucc := ""
    }
    f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareTrafficCases := {tcType := vl_tcTypes[vl_i]}})
  }
  
  var EPTF_LGenBase_TcMgmt_ScenarioDeclarator2 vl_sc := {
    name:="Sc1",
    tcList := {} 
  }
  for ( var integer vl_i := 0; vl_i < sizeof(c_FSMNames) ; vl_i := vl_i+1 ){
    vl_sc.tcList[vl_i] := c_EPTF_LGenBase_TcMgmt_emptyTcOfScenario2
    vl_sc.tcList[vl_i].tcName := c_FSMNames[vl_i]
  }
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareScenarios := {scenario := vl_sc}});
  if(pl_useTc){  
    f_EPTF_LGenBasePerformTest_sendControlMessage(
      {v_MeasureControl_startTraffic := {"g1","Sc1"}},
      pl_handleFinished := refers(f_EPTF_LGenBasePerformanceTest_handleFinished))
  }else{
    f_EPTF_LGenBasePerformTest_sendControlMessage(
      {v_MeasureControl_activateFsm := {}},
      pl_handleFinished := refers(f_EPTF_LGenBasePerformanceTest_handleFinished))
  }
  log(%definitionId,"Start time: ",v_LGenBasePerformTest_testStarted)
  log(%definitionId,"Finish time: ",v_LGenBasePerformTest_testFinished)
  log(%definitionId,"Mem usage before: ",v_LGenBasePerformTest_memBefore)
  log(%definitionId,"Mem usage after: ",v_LGenBasePerformTest_memAfter)
  pl_duration := v_LGenBasePerformTest_testFinished - v_LGenBasePerformTest_testStarted
  pl_memUsage := v_LGenBasePerformTest_memAfter-v_LGenBasePerformTest_memBefore
  log(%definitionId,"Mem usage: ",pl_memUsage)
  log(%definitionId,"Duration: ",pl_duration)
}

function f_LGenBasePerformTest_MTAS_entitySize(in boolean pl_useTc)
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  var Testresult vl_testResult;
  vl_testResult.name := "LGenBase MTAS EntitySize";
  vl_testResult.purpose := "To measure the Memory usage and the initialization time for creating MTAS entities";
  f_TestResultGen_getEnvironment(vl_testResult.environment);
  vl_testResult.parameter_list := {
    {name := "Use TC?", unit := "-", base := log2str(pl_useTc) },
    {name := "Number of entities", unit := "-", base := log2str(tsp_eCounts) }
  };
  // var charstring vl_startTime := f_getTimeFormatted(f_time(), "%c");
  var charstring vl_start_time := f_TestResultGen_getCurrentTime();
  vl_testResult.start_time := vl_start_time;

  f_EPTF_Base_init_CT("MTC");
  map(self:v_pipe_PCO, system:v_pipe_PCO)
  const ASP_PLineMode c_pLineMode := { lineMode := true };
  v_pipe_PCO.send(c_pLineMode);
  var EPTF_FloatList v_durations := {}
  var EPTF_FloatList v_memUsage := {}
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    var EPTF_LGenBasePerformTest_CT vc_performTest_CT := 
    f_LGenBasePerformTest_MTAS_prepareLGen("entitySizeLGen"&int2str(tsp_eCounts[vl_i]))
    f_LGenBasePerformTest_MTAS_performEntitySize(tsp_eCounts[vl_i],v_durations[vl_i],v_memUsage[vl_i],pl_useTc)
    f_LGenBasePerformTest_cleanupLGen(vc_performTest_CT)
  }

  vl_testResult.end_time := f_TestResultGen_getCurrentTime();

  unmap(self:v_pipe_PCO, system:v_pipe_PCO);
  var charstring vl_log := "\nNof entities: "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log  & "\t" & log2str(tsp_eCounts[vl_i])
  }
  vl_log := vl_log & "\nDurations (s): "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log & "\t"& log2str(v_durations[vl_i])
  }
  vl_log := vl_log & "\nMem usage (MB): "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log & "\t"& log2str(v_memUsage[vl_i])
  }
  log("-----MemUsageResult----")
  action(vl_log)
  var integer vl_f := f_FIO_open_append_wronly(tsp_resultFile)
  f_FIO_write_text_flush(vl_f, vl_log)
  f_FIO_close(vl_f)

  vl_testResult.result_list := {
    {
      name := "Durations",
      unit := "sec",
      base := log2str(v_durations)
    },
    {
      name := "Mem usage",
      unit := "MB",
      base := log2str(v_memUsage)
    }
  };
  f_TestResultGen_appendResult("LGenBase_MTAS_entitySize"&vl_start_time&".xml", vl_testResult);

  f_EPTF_Base_cleanup_CT()
}

function f_LGenBasePerformTest_prepareLGen(in charstring pl_lgenName)
runs on EPTF_LGenBasePerformTest_MemMTC_CT
return EPTF_LGenBasePerformTest_CT{
  var EPTF_LGenBasePerformTest_CT vc_performTest_CT;
  vc_performTest_CT := EPTF_LGenBasePerformTest_CT.create;
  vc_performTest_CT.start(f_EPTF_LGenBasePerformTest_start(pl_lgenName));
  connect(self:v_controlPort,vc_performTest_CT:v_controlPort);
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_pID := {""}})
  return vc_performTest_CT
}

function f_LGenBasePerformTest_cleanupLGen(in EPTF_LGenBasePerformTest_CT pl_performTest_CT)
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  v_controlPort.send( {v_MeasureControl_exit := {}} );
  disconnect(self:v_controlPort,pl_performTest_CT:v_controlPort);
  pl_performTest_CT.done
}

function f_EPTF_LGenBasePerformanceTest_handleStart(
  in EPTF_IntegerList pl_params,
  in float pl_time)
runs on EPTF_LGenBasePerformTest_MemMTC_CT{
  v_LGenBasePerformTest_testStarted := pl_time
  v_LGenBasePerformTest_memBefore := f_EPTF_LGenBasePerformanceTest_getMemUsage(v_mtc_lgenPID)
}

function f_EPTF_LGenBasePerformanceTest_handleFinished(
  in EPTF_IntegerList pl_params,
  in float pl_time)
runs on EPTF_LGenBasePerformTest_MemMTC_CT{
  v_LGenBasePerformTest_testFinished := pl_time
  v_LGenBasePerformTest_memAfter := f_EPTF_LGenBasePerformanceTest_getMemUsage(v_mtc_lgenPID)
}

function f_LGenBasePerformTest_performEntitySize(
  in integer pl_eCount,
  out float pl_duration,
  out float pl_memUsage,
  in boolean pl_hasEntityListeners)
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_EPTF_LGenBasePerformTest_sendControlMessage(
    {v_MeasureControl_initLGenBase := {"b1",-1}},
    refers(f_EPTF_LGenBasePerformanceTest_handleStart))
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareEntityType := {"e1","b1"}});
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_createEntityGroup := {"g1","e1",pl_eCount}});
  if(pl_hasEntityListeners){
    f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareFsms := {
          {
            name := c_LGenBasePerformTest_fsmNameSimpleResponseSucc,
            stateList:= {"idle"},
            timerList := {},
            table := {
              {
                eventToListen := {c_EPTF_LGenBase_behavior,c_EPTF_LGenBase_inputName_testMgmt_startTC,entity},
                cellRow := {
                  {{
                      {stepOrFunctionName := c_EPTF_LGenBase_StepFunction_trafficSuccess, contextArgs := omit}
                    }, omit, omit}
                }
              }
            }
          }
        }});
  }else{
    f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareFsms := {}});
  }
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareTrafficCases := {{
          name := "TC_Succ",
          fsmName := c_LGenBasePerformTest_fsmNameSimpleResponseSucc,
          entityType := "e1",
          customEntitySucc := ""
        }}});
  f_EPTF_LGenBasePerformTest_sendControlMessage({v_MeasureControl_declareScenarios := {{
          name:="Sc1",
          tcList := {{ 
              tcName := "TC_Succ",
              startDelay := 0.0,
              cpsToReach := 0.0,
              enableEntities := true,
              enable := false,
              ranges := omit,
              params := omit,
              //finishConditions
              groupFinishConditions := omit,
              entityFinishConditions := omit,
              //actionLists
              entityFinishActions := omit,
              tcFinishActions := omit
            }
          }
        }}});  
  f_EPTF_LGenBasePerformTest_sendControlMessage(
    {v_MeasureControl_startTraffic := {"g1","Sc1"}},
    pl_handleFinished := refers(f_EPTF_LGenBasePerformanceTest_handleFinished))
  log(%definitionId,"Start time: ",v_LGenBasePerformTest_testStarted)
  log(%definitionId,"Finish time: ",v_LGenBasePerformTest_testFinished)
  log(%definitionId,"Mem usage before: ",v_LGenBasePerformTest_memBefore)
  log(%definitionId,"Mem usage after: ",v_LGenBasePerformTest_memAfter)
  pl_duration := v_LGenBasePerformTest_testFinished - v_LGenBasePerformTest_testStarted
  pl_memUsage := v_LGenBasePerformTest_memAfter-v_LGenBasePerformTest_memBefore
}

function f_LGenBasePerformTest_entitySize(in boolean pl_hasEListeners)
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  var Testresult vl_testResult;
  vl_testResult.name := "LGenBase EntitySize";
  vl_testResult.purpose := "To measure the Memory usage and the initialization time for creating entities";
  f_TestResultGen_getEnvironment(vl_testResult.environment);
  vl_testResult.parameter_list := {
    {name := "Has entity listeners?", unit := "-", base := log2str(pl_hasEListeners) },
    {name := "Number of entities", unit := "-", base := log2str(tsp_eCounts) }
  };
  // var charstring vl_startTime := f_getTimeFormatted(f_time(), "%c");
  var charstring vl_start_time := f_TestResultGen_getCurrentTime();
  vl_testResult.start_time := vl_start_time;

  f_EPTF_Base_init_CT("MTC");
  map(self:v_pipe_PCO, system:v_pipe_PCO)
  const ASP_PLineMode c_pLineMode := { lineMode := true };
  v_pipe_PCO.send(c_pLineMode);
  var EPTF_FloatList v_durations := {}
  var EPTF_FloatList v_memUsage := {}
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    var EPTF_LGenBasePerformTest_CT vc_performTest_CT := 
    f_LGenBasePerformTest_prepareLGen("entitySizeLGen"&int2str(tsp_eCounts[vl_i]))
    f_LGenBasePerformTest_performEntitySize(tsp_eCounts[vl_i],v_durations[vl_i],v_memUsage[vl_i],pl_hasEListeners)
    f_LGenBasePerformTest_cleanupLGen(vc_performTest_CT)
  }

  vl_testResult.end_time := f_TestResultGen_getCurrentTime();

  unmap(self:v_pipe_PCO, system:v_pipe_PCO);
  var charstring vl_log := %definitionId&"\nNof entities: "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log  & "," & log2str(tsp_eCounts[vl_i])
  }
  vl_log := vl_log & "\nDurations (s): "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log & ","& log2str(v_durations[vl_i])
  }
  vl_log := vl_log & "\nMem usage (MB): "
  for ( var integer vl_i := 0; vl_i < sizeof(tsp_eCounts) ; vl_i := vl_i+1 ){
    vl_log := vl_log & ","& log2str(v_memUsage[vl_i])
  }
  log("-----MemUsageResult----")
  log(vl_log)

  vl_testResult.result_list := {
    {
      name := "Durations",
      unit := "sec",
      base := log2str(v_durations)
    },
    {
      name := "Mem usage",
      unit := "MB",
      base := log2str(v_memUsage)
    }
  };
  f_TestResultGen_appendResult("LGenBase_entitySize"&vl_start_time&".xml", vl_testResult);

  f_EPTF_Base_cleanup_CT()
}

testcase tc_LGenBasePerformTest_entitySize()
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_LGenBasePerformTest_entitySize(false)
}

testcase tc_LGenBasePerformTest_entitySizeWithEListeners()
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_LGenBasePerformTest_entitySize(true)
}

testcase tc_LGenBasePerformTest_MTAS_entitySize()
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_LGenBasePerformTest_MTAS_entitySize(true)
}

testcase tc_LGenBasePerformTest_MTAS_entitySizeActivateFSM()
runs on EPTF_LGenBasePerformTest_MemMTC_CT {
  f_LGenBasePerformTest_MTAS_entitySize(false)
}

}  // end of module