| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // Copyright (c) 2000-2019 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_CLL_LGenBase_TrafficFunctions |
| // |
| // Purpose: |
| // This module provides functions for traffic management in TitanSim |
| // load generators |
| // |
| // Module Parameters: |
| // - |
| // |
| // Module depends on: |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_LGenBase_Definitions> |
| // <EPTF_CLL_LGenBase_ConfigDefinitions> |
| // <EPTF_CLL_LGenBase_ConfigFunctions> |
| // <EPTF_CLL_LGenBase_PhaseDefinitions> |
| // <EPTF_CLL_LGenBase_PhaseFunctions> |
| // <EPTF_CLL_LGenBase_EventHandlingFunctions> |
| // <EPTF_CLL_Scheduler_Definitions> |
| // <EPTF_CLL_RBTScheduler_Functions> |
| // <EPTF_CLL_FBQ_Definitions> |
| // <EPTF_CLL_FBQ_Functions> |
| // <EPTF_CLL_RNA_Definitions> |
| // <EPTF_CLL_RNA_Functions> |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // <EPTF_CLL_LGenBaseTrafficMixer_Definitions> |
| // <EPTF_CLL_LGenBaseTrafficMixer_Functions> |
| // <TCCMaths_Functions> |
| // |
| // Current Owner: |
| // ELSZSKU |
| // |
| // Last Review Date: |
| // 2008- |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| module EPTF_CLL_LGenBase_TrafficFunctions |
| { |
| import from EPTF_CLL_Base_Functions all; |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_LGenBase_Definitions all; |
| import from EPTF_CLL_LGenBase_ConfigDefinitions all; |
| import from EPTF_CLL_LGenBase_ConfigFunctions all; |
| import from EPTF_CLL_LGenBase_EventHandlingFunctions all; |
| import from EPTF_CLL_Scheduler_Definitions all; |
| import from EPTF_CLL_RBTScheduler_Functions all; |
| import from EPTF_CLL_FBQ_Definitions all; |
| import from EPTF_CLL_FBQ_Functions all; |
| import from EPTF_CLL_RNA_Definitions all; |
| import from EPTF_CLL_RNA_Functions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_LGenBaseTrafficMixer_Definitions all; |
| import from EPTF_CLL_LGenBaseTrafficMixer_Functions all; |
| import from EPTF_CLL_LGenBaseStats_Definitions all; |
| import from TCCMaths_Functions all; |
| import from EPTF_CLL_LGenBase_TemplateFunctions all; |
| import from EPTF_CLL_LGenBase_LoggingFunctions all; |
| import from EPTF_CLL_Variable_Functions all; |
| import from EPTF_CLL_Variable_Definitions all |
| import from EPTF_CLL_StatMeasure_Functions all |
| |
| import from EPTF_CLL_LGenBase_ILog_Functions all; |
| |
| friend module EPTF_CLL_LGenBase_Functions; |
| friend module EPTF_CLL_LGenBase_StepFunctions; |
| friend module EPTF_CLL_ExecCtrlClient_Functions; |
| |
| /////////////////////////////////////////////////////////// |
| // Group: BurstCalculation |
| // |
| // Purpose: |
| // The EPTF_LGenBase functions related to the traffic calculation |
| /////////////////////////////////////////////////////////// |
| group BurstCalculation{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setBurstCalcAlgByIdx |
| // |
| // Purpose: |
| // Assign a burst calculation method to the traffic cases or weighted scenarios |
| // |
| // Parameters: |
| // pl_burstIdx - *in* *integer* - The index of the burst function |
| // pl_idx - *in* - <EPTF_LGenBase_TcMgmt_AbsIdx> - Union of a traffic case index or a weighted scenario index |
| // |
| // Return Value: |
| // *boolean* - If there is a running traffic case, returns false. |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // This function can be used to assign the burst calculation method to a specified traffic case or a weighted scenario. |
| // The parameter <pl_burstIdx> is the index of the burst calculation algorithm. It can be a predefined algorithm such as orig, imst2, imst2, cs, poisson |
| // or a user defined one, defined by <f_EPTF_LGenBase_addBurstCalcFunction>. |
| // The traffic case index or the weighted scenario index should set. |
| // The normal traffic case can be referred by its traffic case index. The weighted scenario can be referred by its global scenario index. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setBurstCalcAlgByIdx( |
| in integer pl_burstIdx, |
| in EPTF_LGenBase_TcMgmt_AbsIdx pl_idx) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| |
| var boolean vl_isWeighted := false; |
| //var boolean vl_returnValue := true; |
| |
| |
| if(ischosen(pl_idx.tcIdx)) { // normal traffic case |
| vl_isWeighted := false; |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",pl_idx.tcIdx > -1 and pl_idx.tcIdx < sizeof(v_LGenBase_trafficCases)); |
| if(f_EPTF_LGenBase_checkSchedulingTimerIsRunning(pl_idx.tcIdx)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"Traffic case is running. The burst calculation method can not be set."); |
| return false; |
| } |
| f_EPTF_LGenBase_setBurstCalcAlgInternal(pl_burstIdx, pl_idx.tcIdx, vl_isWeighted); |
| |
| } else if(ischosen(pl_idx.scIdx)){ // weighted scenario |
| vl_isWeighted := true; |
| f_EPTF_LGenBase_setBurstCalcAlgInternal(pl_burstIdx, pl_idx.scIdx, vl_isWeighted); |
| } else { |
| // a bit paranoia |
| return false; |
| } |
| |
| return true //vl_returnValue; |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setBurstCalcAlgByName |
| // |
| // Purpose: |
| // Assign a burst calculation method to the traffic cases or weighted scenarios |
| // |
| // Parameters: |
| // pl_funcName - *in* - *charstring* - The name of burst calculation |
| // pl_eGrpName - *in* - *charstring* - entity group name |
| // pl_scName - *in* - *charstring* - scenario name |
| // pl_tcName - *in* - *charstring* - traffic case name(optional) |
| // |
| // Return Value: |
| // *boolean* - If there is a running traffic case, returns false. |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // This function can be used to assign the burst calculation method to a specified traffic case or a weighted scenario. |
| // The parameter <pl_funcName> is the name of the burst calculation algorithm. It can be a predefined algorithm such as orig, imst2, imst2, cs, poisson |
| // or a user defined one, defined by <f_EPTF_LGenBase_addBurstCalcFunction>. |
| // The traffic case can be referred by its entity group name, scenario name and traffic case name. |
| // If traffic case name is not set, then we are assume that the method should be assigned to a weighted scenario. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setBurstCalcAlgByName( |
| in charstring pl_funcName, |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName := "") |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| |
| var integer vl_burstIdx := f_EPTF_LGenBase_getBurstCalcFunctionId(pl_funcName); |
| var boolean vl_isWeighted := false; |
| var boolean vl_returnValue := true; |
| |
| if(vl_burstIdx == -1) { |
| f_EPTF_LGenBase_loggingError(%definitionId&"This burst calculation method "&pl_funcName&" cannot be found. "); |
| //f_EPTF_Base_assert(%definitionId&"This burst calculation method cannot be found.",false); |
| return false; |
| } |
| |
| var integer vl_idx; |
| if("" != pl_tcName) { // normal traffic case |
| vl_idx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| vl_isWeighted := false; |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",vl_idx > -1 and vl_idx < sizeof(v_LGenBase_trafficCases)); |
| if(f_EPTF_LGenBase_checkSchedulingTimerIsRunning(vl_idx)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"Traffic case is running. The burst calculation method can not be set."); |
| return false; |
| } |
| } else { // weighted scenario |
| vl_isWeighted := true; |
| vl_idx := f_EPTF_LGenBase_scenarioAbsIdxByName(pl_eGrpName, pl_scName); |
| } |
| |
| f_EPTF_LGenBase_setBurstCalcAlgInternal(vl_burstIdx,vl_idx,vl_isWeighted); |
| |
| return vl_returnValue; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getBurstCalcAlgByIdx |
| // |
| // Purpose: |
| // Gets the bust calculation method of a traffic case or a weighted scenario |
| // |
| // Parameters: |
| // pl_idx - *in* - <EPTF_LGenBase_TcMgmt_AbsIdx> - Union of a traffic case index or a weighted scenario index |
| // |
| // Return Value: |
| // *integer* - The index of the used burst function |
| // |
| // Detailed Comments: |
| // This function returns the index of the burst calculation function assigned to a traffic case. |
| // The normal traffic case can be referred by its traffic case index, the weighted scenario can be referred by its global scenario index. |
| // If traffic case ID is -1, then it returns the global burst calculation method. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getBurstCalcAlgByIdx ( |
| in EPTF_LGenBase_TcMgmt_AbsIdx pl_idx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer |
| { |
| if(ischosen(pl_idx.tcIdx)) { // normal traffic case |
| if(pl_idx.tcIdx == -1) { |
| return f_EPTF_LGenBase_getBurstCalcFunctionId( v_LGenBase_burstCalcMode ); |
| } else { |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",pl_idx.tcIdx > -1 and pl_idx.tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return f_EPTF_LGenBase_getBurstCalcFunctionId( v_LGenBase_trafficCases[pl_idx.tcIdx].schedulerData.burstFuncRef.burstCalcMode ); |
| } |
| |
| } else if(ischosen(pl_idx.scIdx)){ // weighted scenario |
| var integer vl_eGrpIdx; |
| var integer vl_scInGrpIdx; |
| f_EPTF_LGenBase_scenarioRelIdx(pl_idx.scIdx, vl_eGrpIdx, vl_scInGrpIdx); |
| return f_EPTF_LGenBase_getBurstCalcFunctionId( v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstCalcMode ); |
| } |
| // a bit paranoia |
| return -1; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getBurstCalcAlgByName |
| // |
| // Purpose: |
| // Gets the bust calculation method of a traffic case or a weighted scenario |
| // |
| // Parameters: |
| // pl_eGrpName - *in* - *charstring* - entity group name |
| // pl_scName - *in* - *charstring* - scenario name |
| // pl_tcName - *in* - *charstring* - traffic case name(optional) |
| // |
| // Return Value: |
| // *integer* - The index of the used burst function |
| // |
| // Detailed Comments: |
| // This function returns the index of the burst calculation function assigned to a traffic case. |
| // The traffic case can be referred by its entity group name, scenario name and traffic case name. |
| // If traffic case name is not set, then we are assume that the method should be assigned to a weighted scenario. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getBurstCalcAlgByName ( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName := "") |
| runs on EPTF_LGenBase_Private_CT |
| return integer |
| { |
| if("" != pl_tcName) { // normal traffic case |
| var integer vl_idx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",vl_idx > -1 and vl_idx < sizeof(v_LGenBase_trafficCases)); |
| return f_EPTF_LGenBase_getBurstCalcFunctionId( v_LGenBase_trafficCases[vl_idx].schedulerData.burstFuncRef.burstCalcMode ); |
| } else { // weighted scenario |
| var integer vl_eGrpIdx; |
| var integer vl_scInGrpIdx; |
| var integer vl_idx := f_EPTF_LGenBase_scenarioAbsIdxByName(pl_eGrpName, pl_scName); |
| f_EPTF_LGenBase_scenarioRelIdx(vl_idx, vl_eGrpIdx, vl_scInGrpIdx); |
| return f_EPTF_LGenBase_getBurstCalcFunctionId( v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstCalcMode ); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_addBurstCalcFunction |
| // |
| // Purpose: |
| // Saves a user defined burst calculation method and its function references to a list. |
| // |
| // Parameters: |
| // pl_funcName - *in* - *charstring* - The name of burst calculation |
| // pl_preCalcFunc - *in* <EPTF_LGenBase_burstPreCalc_FT> - The burst precalculation function reference |
| // pl_postCalcFunc - *in* <EPTF_LGenBase_burstPostCalc_FT> - The burst postcalculation function reference |
| // |
| // Return Value: |
| // *integer* - The index of the burst calculation function |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // The function saves a user defined burst calculation method and its function references. |
| // The burst calculation method won't be assigned to any traffic case. |
| // This saved method can be accessed by its name or ID later, so the name of the method must be unique. |
| // If there is an error occurred the return value will be -1. |
| // Note: We assume there will be only a few user defined methods, so defined methods cannot be deleted later. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_addBurstCalcFunction( |
| in charstring pl_funcName, |
| in EPTF_LGenBase_burstPreCalc_FT pl_preCalcFunc, |
| in EPTF_LGenBase_burstPostCalc_FT pl_postCalcFunc) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| |
| var integer vl_listSize := sizeof(v_LGenBase_burstFuncRefList); |
| for ( var integer vl_i := 0; vl_i < vl_listSize ; vl_i := vl_i+1 ) |
| { |
| if(v_LGenBase_burstFuncRefList[vl_i].burstCalcMode == pl_funcName){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"This "&pl_funcName&" burst calculation method is already defined: "); |
| return -1; |
| } |
| } |
| |
| v_LGenBase_burstFuncRefList[vl_listSize].burstCalcMode := pl_funcName; |
| v_LGenBase_burstFuncRefList[vl_listSize].burstPreCalc := pl_preCalcFunc; |
| v_LGenBase_burstFuncRefList[vl_listSize].burstPostCalc := pl_postCalcFunc; |
| |
| return vl_listSize; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getBurstCalcFunctionId |
| // |
| // Purpose: |
| // Gets the index of ther user defined burst calculation method. |
| // |
| // Parameters: |
| // pl_funcName - *in* - *charstring* - The name of burst calculation |
| // |
| // Return Value: |
| // *integer* - The index of the burst calculation function |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // The function gets the index of the user defined burst calculation method. |
| // If the method cannot be found, it returns -1. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getBurstCalcFunctionId( |
| in charstring pl_funcName) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_burstFuncRefList) ; vl_i := vl_i+1 ) |
| { |
| if(v_LGenBase_burstFuncRefList[vl_i].burstCalcMode == pl_funcName){ |
| return vl_i; |
| } |
| } |
| |
| return -1; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getBurstCalcFunction |
| // |
| // Purpose: |
| // Gets a user defined burst calculation method and its function references from a list. |
| // |
| // Parameters: |
| // pl_funcName - *in* - *charstring* - The name of burst calculation |
| // pl_preCalcFunc - *out* <EPTF_LGenBase_burstPreCalc_FT> - The burst precalculation function reference |
| // pl_postCalcFunc - *out* <EPTF_LGenBase_burstPostCalc_FT> - The burst postcalculation function reference |
| // |
| // Return Value: |
| // *integer* - The index of the burst calculation function |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // The function gets a user defined burst calculation method and its function references. |
| // If the method cannot be found, it returns -1. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getBurstCalcFunction( |
| in charstring pl_funcName, |
| inout EPTF_LGenBase_burstPreCalc_FT pl_preCalcFunc, |
| inout EPTF_LGenBase_burstPostCalc_FT pl_postCalcFunc) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| |
| var integer vl_returnValue := -1; |
| |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_burstFuncRefList) ; vl_i := vl_i+1 ) |
| { |
| if(v_LGenBase_burstFuncRefList[vl_i].burstCalcMode == pl_funcName){ |
| pl_preCalcFunc := v_LGenBase_burstFuncRefList[vl_i].burstPreCalc; |
| pl_postCalcFunc := v_LGenBase_burstFuncRefList[vl_i].burstPostCalc; |
| vl_returnValue := vl_i; |
| } |
| } |
| |
| return vl_returnValue; |
| } |
| |
| //////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_adjustSchedulerData4NewCps |
| // |
| // Purpose: adjust roundedCpsUpdateInterval, idealBurstSize and moduloOperand for new cps |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_adjustSchedulerData4NewCps( |
| inout EPTF_LGenBase_SchedulerData pl_schData |
| ) runs on EPTF_LGenBase_Private_CT { |
| var float vl_interval; |
| |
| f_EPTF_Base_assert( |
| %definitionId&": CPS, or weight must be non-negative", |
| not ischosen(pl_schData.target.dummy) |
| and ((ischosen(pl_schData.target.cpsToReach) and pl_schData.target.cpsToReach>=0.0) |
| or (ischosen(pl_schData.target.trafficWeight) and pl_schData.target.trafficWeight>=0.0)) |
| ); |
| pl_schData.burstCalcNeeded := true; |
| |
| var float vl_cpsToReach := pl_schData.target.cpsToReach; |
| |
| if (pl_schData.burstFuncRef.burstCalcMode == c_EPTF_LGenBase_BurstCalc_poisson) { |
| pl_schData.idealBurstSize := 0.0; |
| pl_schData.currentBurstSize := 0; |
| pl_schData.roundedCpsUpdateInterval := 0.0; |
| } else { |
| if (vl_cpsToReach<=0.0) { |
| pl_schData.idealBurstSize := 0.0 |
| vl_interval := 0.0 |
| } else { |
| if (1.0/vl_cpsToReach<tsp_EPTF_LGenBase_CPS_minUpdateInterval) { |
| vl_interval:= tsp_EPTF_LGenBase_CPS_minUpdateInterval |
| } else { |
| vl_interval := 1.0/vl_cpsToReach |
| } |
| //round it down to a multiple of tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM |
| vl_interval := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM * int2float(float2int(vl_interval/tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM)); |
| if (vl_interval<tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM) { |
| vl_interval := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM |
| } |
| pl_schData.idealBurstSize := vl_cpsToReach * vl_interval; |
| pl_schData.currentBurstSize := float2int(pl_schData.idealBurstSize+0.50000001); // +0.500001 is needed to overcome numerical errors |
| } |
| pl_schData.roundedCpsUpdateInterval := vl_interval; |
| } |
| |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Using scheduler data:"&log2str(pl_schData)) |
| } |
| } |
| |
| } //BurstCalculation |
| |
| /////////////////////////////////////////////////////////// |
| // Group: Conversion |
| // |
| // Purpose: |
| // Conversion functions |
| // |
| // Detailed Comments: |
| // LGenBase stores the state of the entity in integer form. These functions |
| // convert these value types |
| /////////////////////////////////////////////////////////// |
| group EntityStateConversion{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_eState2integer |
| // |
| // Purpose: |
| // Converts an <EPTF_LGenBase_EntityState> value to integer. |
| // |
| // Detailed Comments: |
| // LGenBase stores the state of the entity in integer form. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_eState2integer(in EPTF_LGenBase_EntityState pl_verdict) return integer{ |
| select( pl_verdict ) |
| { |
| case ( none ) |
| { |
| return c_EPTF_LGenBase_eStateNone; |
| } |
| case ( pass ) |
| { |
| return c_EPTF_LGenBase_eStatePass; |
| } |
| } |
| return c_EPTF_LGenBase_eStateFail; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_integer2eState |
| // |
| // Purpose: |
| // Converts an integer value to <EPTF_LGenBase_EntityState>. |
| // |
| // Detailed Comments: |
| // LGenBase stores the state of the entity in integer form. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_integer2eState(in integer pl_int) return EPTF_LGenBase_EntityState{ |
| select( pl_int ) |
| { |
| case ( c_EPTF_LGenBase_eStateNone ) |
| { |
| return none; |
| } |
| case ( c_EPTF_LGenBase_eStatePass ) |
| { |
| return pass; |
| } |
| } |
| return fail; |
| } |
| |
| }//EntityStateConversion |
| |
| /////////////////////////////////////////////////////////// |
| // Group: GetSet |
| // |
| // Purpose: |
| // Get/Set functions |
| /////////////////////////////////////////////////////////// |
| group GetSet{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setEntityState |
| // |
| // Purpose: |
| // Sets the state of an entity in a traffic case. |
| // |
| // Detailed Comments: |
| // This state has no relation to the enabled/disabled state of the |
| // entity. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setEntityState( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_EntityState pl_state) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].entityState := |
| f_EPTF_LGenBase_eState2integer(pl_state); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityState |
| // |
| // Purpose: |
| // Returns the state of an entity in a traffic case. |
| // |
| // Detailed Comments: |
| // This state has no relation to the enabled/disabled state of the |
| // entity. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getEntityState( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_EntityState{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return f_EPTF_LGenBase_integer2eState(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].entityState); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityStarts |
| // |
| // Purpose: |
| // Returns the nr of starts of an entity in a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getEntityStarts( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].nrOfStarts; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityFails |
| // |
| // Purpose: |
| // Returns the nr of fails of an entity in a traffic case. |
| public function f_EPTF_LGenBase_getEntityFails( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].nrOfFails; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityErrors |
| // |
| // Purpose: |
| // Returns the nr of errors of an entity in a traffic case. |
| public function f_EPTF_LGenBase_getEntityErrors( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].nrOfErrors; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityTimeouts |
| // |
| // Purpose: |
| // Returns the nr of timeouts of an entity in a traffic case. |
| public function f_EPTF_LGenBase_getEntityTimeouts( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].nrOfTimeouts; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntitySuccesses |
| // |
| // Purpose: |
| // Returns the nr of successes of an entity in a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getEntitySuccesses( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index.",pl_entityRelIdx > -1 and pl_entityRelIdx < sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList)); |
| return v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_entityRelIdx].nrOfSuccesses; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resetTrafficStats |
| // |
| // Purpose: |
| // Resets the nrOfSuccesses, nrOfFails, nrOfErrors, nrOfTimeouts values |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_resetTrafficStats() |
| runs on EPTF_LGenBase_Private_CT{ |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_trafficCases) ; vl_tc := vl_tc+1 ){ |
| var integer vl_eCount := sizeof(v_LGenBase_trafficCases[vl_tc].entityInfo.itemList) |
| for ( var integer vl_e := 0; vl_e < vl_eCount ; vl_e := vl_e+1 ){ |
| v_LGenBase_trafficCases[vl_tc].entityInfo.itemList[vl_e].nrOfSuccesses := 0 |
| } |
| v_LGenBase_trafficCases[vl_tc].nrOfStarts := 0 |
| v_LGenBase_trafficCases[vl_tc].nrOfSuccesses := 0 |
| f_EPTF_LGenBaseStats_trafficSucces( vl_tc ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshSuccFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshSuccFnList[vl_cb].apply( vl_tc ) |
| } |
| v_LGenBase_trafficCases[vl_tc].nrOfFails := 0 |
| f_EPTF_LGenBaseStats_trafficFail( vl_tc ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshFailFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshFailFnList[vl_cb].apply( vl_tc ) |
| } |
| v_LGenBase_trafficCases[vl_tc].nrOfErrors := 0 |
| f_EPTF_LGenBaseStats_trafficError( vl_tc ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshErrorFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshErrorFnList[vl_cb].apply( vl_tc ) |
| } |
| v_LGenBase_trafficCases[vl_tc].nrOfTimeouts := 0 |
| f_EPTF_LGenBaseStats_trafficTimeout( vl_tc ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshTimeoutFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshTimeoutFnList[vl_cb].apply( vl_tc ) |
| } |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEntityFSMCtxIdx |
| // |
| // Purpose: |
| // Public function to get the FSM context index of the entity in a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getEntityFSMCtxIdx( |
| in integer pl_entityRelIdx, |
| in integer pl_tcIdx, |
| in integer pl_siblingIdx := 0) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| return f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(pl_entityRelIdx, pl_tcIdx, pl_siblingIdx) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcStarts |
| // |
| // Purpose: |
| // Returns the nr of starts of an Tc in a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getTcStarts( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfStarts; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcFails |
| // |
| // Purpose: |
| // Returns the nr of fails of an Tc in a traffic case. |
| public function f_EPTF_LGenBase_getTcFails( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfFails; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcErrors |
| // |
| // Purpose: |
| // Returns the nr of errors of an Tc in a traffic case. |
| public function f_EPTF_LGenBase_getTcErrors( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfErrors; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcTimeouts |
| // |
| // Purpose: |
| // Returns the nr of timeouts of an Tc in a traffic case. |
| public function f_EPTF_LGenBase_getTcTimeouts( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfTimeouts; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcAvailable |
| // |
| // Purpose: |
| // Returns the nr of available entities in a traffic case. |
| public function f_EPTF_LGenBase_getTcAvailable( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcAllEntities |
| // |
| // Purpose: |
| // Returns the nr of entities in a traffic case. |
| public function f_EPTF_LGenBase_getTcAllEntities( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfAllEntities |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcNotFinishedEntities |
| // |
| // Purpose: |
| // Returns the nr of entities in a traffic case. |
| public function f_EPTF_LGenBase_getTcNotFinishedEntities( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfNotFinishedEntities |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcRunningEntities |
| // |
| // Purpose: |
| // Returns the nr of entities in a traffic case. |
| public function f_EPTF_LGenBase_getTcRunningEntities( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfRunningEntities |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcSuccesses |
| // |
| // Purpose: |
| // Returns the nr of successes of an Tc in a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getTcSuccesses( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].nrOfSuccesses; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setTCStartDelay |
| // |
| // Purpose: |
| // Sets the start delay of a traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setTCStartDelay( |
| in integer pl_tcIdx, |
| in float pl_newDelay) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| v_LGenBase_trafficCases[pl_tcIdx].startDelay := pl_newDelay; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_addScenarioCreatedCallBack |
| // |
| // Purpose: |
| // Registers a callback function to call when a scenario is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_addScenarioCreatedCallback(in EPTF_LGenBase_scenarioCreated_FT pl_LGenBase_scenarioCreatedCbf) |
| runs on EPTF_LGenBase_Private_CT return integer |
| { |
| var integer i:= sizeof(v_LGenBase_scenarioCreated); |
| v_LGenBase_scenarioCreated[i] := pl_LGenBase_scenarioCreatedCbf; |
| return i; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_removeScenarioCreatedCallBack |
| // |
| // Purpose: |
| // Removes a callback function to call when a scenario is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_removeScenarioCreatedCallback(in integer pl_idx) runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Error: attempting to delete fcb. at invalid idx:" & int2str(pl_idx), pl_idx>-1 and pl_idx<sizeof(v_LGenBase_scenarioCreated)); |
| |
| var EPTF_LGenBase_scenarioCreated_FTList vl_list := v_LGenBase_scenarioCreated; |
| |
| v_LGenBase_scenarioCreated:= {}; |
| for (var integer i:=0; i<pl_idx; i:= i+1) { |
| v_LGenBase_scenarioCreated[i] := vl_list[i]; |
| } |
| |
| for (var integer i:=pl_idx; i<sizeof(vl_list)-1; i:= i+1) { |
| v_LGenBase_scenarioCreated[i] := vl_list[i+1]; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_addEntityGroupCreatedCallback |
| // |
| // Purpose: |
| // Registers a callback function to call when a entityGroup is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_addEntityGroupCreatedCallback(in EPTF_LGenBase_entityGroupCreated_FT pl_LGenBase_entityGroupCreatedCbf) |
| runs on EPTF_LGenBase_Private_CT return integer |
| { |
| var integer i:= sizeof(v_LGenBase_entityGroupCreated); |
| v_LGenBase_entityGroupCreated[i] := pl_LGenBase_entityGroupCreatedCbf; |
| return i; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_removeEntityGroupCreatedCallBack |
| // |
| // Purpose: |
| // Removes a callback function to call when a entityGroup is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_removeEntityGroupCreatedCallback(in integer pl_idx) runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Error: attempting to delete fcb. at invalid idx:" & int2str(pl_idx), pl_idx>-1 and pl_idx<sizeof(v_LGenBase_entityGroupCreated)); |
| |
| var EPTF_LGenBase_entityGroupCreated_FTList vl_list := v_LGenBase_entityGroupCreated; |
| |
| v_LGenBase_entityGroupCreated:= {}; |
| for (var integer i:=0; i<pl_idx; i:= i+1) { |
| v_LGenBase_entityGroupCreated[i] := vl_list[i]; |
| } |
| |
| for (var integer i:=pl_idx; i<sizeof(vl_list)-1; i:= i+1) { |
| v_LGenBase_entityGroupCreated[i] := vl_list[i+1]; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_addtrafficCaseCreatedCallBack |
| // |
| // Purpose: |
| // Registers a callback function to call when a scenario is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_addtrafficCaseCreatedCallback(in EPTF_LGenBase_trafficCaseCreated_FT pl_LGenBase_trafficCaseCreatedCbf) |
| runs on EPTF_LGenBase_Private_CT return integer |
| { |
| var integer i:= sizeof(v_LGenBase_trafficCaseCreated); |
| v_LGenBase_trafficCaseCreated[i] := pl_LGenBase_trafficCaseCreatedCbf; |
| return i; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_removetrafficCaseCreatedCallBack |
| // |
| // Purpose: |
| // Removes a callback function to call when a scenario is created |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_removetrafficCaseCreatedCallback(in integer pl_idx) runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Error: attempting to delete fcb. at invalid idx:" & int2str(pl_idx), pl_idx>-1 and pl_idx<sizeof(v_LGenBase_trafficCaseCreated)); |
| |
| var EPTF_LGenBase_trafficCaseCreated_FTList vl_list := v_LGenBase_trafficCaseCreated; |
| |
| v_LGenBase_trafficCaseCreated:= {}; |
| for (var integer i:=0; i<pl_idx; i:= i+1) { |
| v_LGenBase_trafficCaseCreated[i] := vl_list[i]; |
| } |
| |
| for (var integer i:=pl_idx; i<sizeof(vl_list)-1; i:= i+1) { |
| v_LGenBase_trafficCaseCreated[i] := vl_list[i+1]; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_addBurstGeneratedCallBack |
| // |
| // Purpose: |
| // Registers a callback function to call after a burst generation occurred (after postproc) |
| // |
| // Parameters: |
| // pl_burstGenerated - *in* - <EPTF_LGenBase_burstPostCalc_FT> - the callback function |
| // |
| // Return Value: |
| // *integer* - Index of the function reference in the list |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_addBurstGeneratedCallBack(in EPTF_LGenBase_burstPostCalc_FT pl_burstGenerated) |
| runs on EPTF_LGenBase_Private_CT return integer |
| { |
| var integer i:= sizeof(v_LGenBase_burstGenerated); |
| v_LGenBase_burstGenerated[i] := pl_burstGenerated; |
| return i; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_removeBurstGeneratedCallBack |
| // |
| // Purpose: |
| // Removes a callback function to call after a burst generation occurred (after postproc) |
| // |
| // Parameters: |
| // pl_idx - *in* - *integer* - Index of the function reference in the list |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_removeBurstGeneratedCallback(in integer pl_idx) runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Error: attempting to delete fcb. at invalid idx:" & int2str(pl_idx), pl_idx>-1 and pl_idx<sizeof(v_LGenBase_burstGenerated)); |
| |
| var EPTF_LGenBase_burstPostCalc_FTList vl_list := v_LGenBase_burstGenerated; |
| |
| v_LGenBase_burstGenerated := {}; |
| for (var integer i:=0; i<pl_idx; i:= i+1) { |
| v_LGenBase_burstGenerated[i] := vl_list[i]; |
| } |
| |
| for (var integer i:=pl_idx; i<sizeof(vl_list)-1; i:= i+1) { |
| v_LGenBase_burstGenerated[i] := vl_list[i+1]; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_checkSchedulingTimerIsRunning |
| // |
| // Purpose: |
| // Checks whether the scheduling timer is running in a traffic case |
| // |
| // Parameters: |
| // pl_tcIdx - *in* - *integer* - traffic case index (relative) |
| // |
| // Return Value: |
| // *boolean* - If scheduling timer is running. |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_checkSchedulingTimerIsRunning(in integer pl_tcIdx) runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var boolean vl_returnValue := false; |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",pl_tcIdx > -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| if(not f_EPTF_LGenBase_isWeightedScenario( |
| v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref, |
| v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef)){ //normal scenario |
| if(-1 != v_LGenBase_trafficCases[pl_tcIdx].schedulingTimer){ |
| vl_returnValue := true; |
| } |
| } else { //weighted scenario |
| |
| if(ispresent(v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].scenarios[v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef].schedulerData)) |
| { |
| if(-1 != v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].scenarios[v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef].schedulerData.schedulingTimer){ |
| vl_returnValue := true; |
| } |
| } |
| } |
| return vl_returnValue; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_checkName |
| // |
| // Purpose: |
| // Checks whether the given name contains the name separator specified in a component variable |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_checkName(in charstring pl_name) return boolean{ |
| template charstring tl_separator := pattern "*{tsp_LGenBase_nameSeparator}*"; |
| return not match(pl_name, tl_separator); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_registerCPSChangedCallback_TC |
| // |
| // Purpose: |
| // Registers a CPS changed callback for the given traffic case instance |
| // |
| // Parameters: |
| // pl_eGrpName - *in charstring* - the entity group name |
| // pl_scName - *in charstring* - the scenario name |
| // pl_tcName - *in charstring* - the traffic case name |
| // pl_cpsChangedCallback - *in* <EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT> - the traffic case CPS changed callback |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_registerCPSChangedCallback_TC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT pl_cpsChangedCallback |
| ) runs on EPTF_LGenBase_Private_CT { |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 < vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 < vl_scIdx); |
| f_EPTF_Base_assert(%definitionId&": CPS change callback cannot be set to weighted scenario: " |
| &v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].uniqueName, |
| not f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)); |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| v_LGenBase_trafficCases[vl_tcIdx].cpsChangedCallbackList[sizeof(v_LGenBase_trafficCases[vl_tcIdx].cpsChangedCallbackList)] := pl_cpsChangedCallback; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_deregisterCPSChangedCallback_TC |
| // |
| // Purpose: |
| // DeRegisters a CPS changed callback for the given traffic case instance |
| // |
| // Parameters: |
| // pl_eGrpName - *in charstring* - the entity group name |
| // pl_scName - *in charstring* - the scenario name |
| // pl_tcName - *in charstring* - the traffic case name |
| // pl_cpsChangedCallback - *in* <EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT> - the traffic case CPS changed callback |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_deregisterCPSChangedCallback_TC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT pl_cpsChangedCallback |
| ) runs on EPTF_LGenBase_Private_CT { |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| |
| for(var integer i:=0; i<sizeof(v_LGenBase_trafficCases[vl_tcIdx].cpsChangedCallbackList); i:=i+1) { |
| if(v_LGenBase_trafficCases[vl_tcIdx].cpsChangedCallbackList[i]==pl_cpsChangedCallback) { |
| v_LGenBase_trafficCases[vl_tcIdx].cpsChangedCallbackList[i] := null; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_callCPSChangedCallbacks_TC |
| // |
| // Purpose: |
| // Calls the CPS changed callbacks for the given traffic case instance |
| // |
| // Parameters: |
| // pl_tcIdx - *in integer* - the id of the traffic case in the instance DB |
| // pl_cps - *in float* - the new CPS value |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_callCPSChangedCallbacks_TC(in float pl_cps, in integer pl_tcIdx) runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_LGenBase_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| |
| for (var integer i:=0; i<sizeof(v_LGenBase_trafficCases[pl_tcIdx].cpsChangedCallbackList); i:=i+1) { |
| if (v_LGenBase_trafficCases[pl_tcIdx].cpsChangedCallbackList[i]!=null) { |
| v_LGenBase_trafficCases[pl_tcIdx].cpsChangedCallbackList[i].apply(pl_cps,pl_tcIdx); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setCPSByNames |
| // |
| // Purpose: |
| // Sets the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setCPSByNames( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in float pl_newCps |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| //We don't handle the previous value |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setCPS(f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName), pl_newCps); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcCpsToReachByName |
| // |
| // Purpose: |
| // Retrieves the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getTcCpsToReachByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var integer vl_tc_idx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName) |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case name: "& |
| pl_eGrpName&tsp_LGenBase_nameSeparator&pl_scName&tsp_LGenBase_nameSeparator&pl_tcName, |
| -1 < vl_tc_idx) |
| return f_EPTF_LGenBase_getTcCpsToReachByIdx(vl_tc_idx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcCpsToReachByIdx |
| // |
| // Purpose: |
| // Retrieves the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getTcCpsToReachByIdx( |
| in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| f_EPTF_Base_assert(%definitionId&": The traffic case "&v_LGenBase_trafficCases[pl_tcAbsIdx].uniqueName& |
| " is in a weighted scenario.",ischosen(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach)); |
| return v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach; |
| //pl_tc.schedulerData.target.cpsToReach |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setCpsOrWeightOfTcByNames |
| // |
| // Purpose: |
| // Sets the required CPS or Weight of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setCpsOrWeightOfTcByNames( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in float pl_newCps |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| if (ischosen(v_LGenBase_trafficCases[vl_tcIdx].schedulerData.target.cpsToReach)) |
| { |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setCPS(vl_tcIdx, pl_newCps); |
| } else if (ischosen(v_LGenBase_trafficCases[vl_tcIdx].schedulerData.target.trafficWeight)) |
| { |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setTcWeight(vl_tcIdx, pl_newCps); |
| } else { |
| //This code shouldn't be reached, because the configuration reader function should prevent |
| f_EPTF_Base_assert(%definitionId&": There is neither cpsToReach, nor trafficWeight defined for the traffic case.",false) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getNrOfTCs |
| // |
| // Purpose: |
| // Retrieves the number of the traffic cases |
| /////////////////////////////////////////////////////////// |
| |
| public function f_EPTF_LGenBase_getNrOfTCs() runs on EPTF_LGenBase_Private_CT return integer{ |
| return sizeof(v_LGenBase_trafficCases); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setCPS |
| // |
| // Purpose: |
| // Sets the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setCPS( |
| in integer pl_tcAbsIdx, |
| in float pl_newCps |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float |
| { |
| if(not ischosen(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach)){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": CPS cannot set to weighted TC: " |
| &v_LGenBase_trafficCases[pl_tcAbsIdx].uniqueName) |
| return 0.0 |
| } |
| if(originating == v_LGenBase_trafficCases[pl_tcAbsIdx].trafficType and |
| -1 < v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer){ |
| f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer) |
| v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer := -1 |
| } |
| var float vl_ret := v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach ; |
| v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach := pl_newCps |
| f_EPTF_LGenBase_callCPSChangedCallbacks_TC(pl_newCps,pl_tcAbsIdx); |
| if(originating == v_LGenBase_trafficCases[pl_tcAbsIdx].trafficType){ |
| //set modulo,roundedUpdateInterval, idealBurstSize |
| f_EPTF_LGenBase_adjustSchedulerData4NewCps(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData); |
| var EPTF_LGenBase_tcState vl_statePrev := v_LGenBase_trafficCases[pl_tcAbsIdx].state; |
| if(c_EPTF_LGenBase_tcStateRunning != vl_statePrev){ |
| return vl_ret; // do not schedule event if TC is not running |
| } |
| |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcAbsIdx].eGroupBackref |
| v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[vl_eGrpIdx].trafficCorrigation; |
| |
| if(0.0 < pl_newCps){ |
| // calculate the remaining time from start_delay |
| var float vl_execTime := f_EPTF_Base_getRelTimeInSecs() - v_LGenBase_trafficCases[pl_tcAbsIdx].startTime |
| var float vl_remainingTime := v_LGenBase_trafficCases[pl_tcAbsIdx].startDelay - vl_execTime; |
| //HL48155 In any case the timer must be rescheduled, even if there is a running scheduled timer action. |
| //Otherwise the CPS change won't take action untill the scheduled action timed out. |
| //if( -1 == v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer ) // if an event exists already we don't need to reschedule |
| { |
| if ( tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM > vl_remainingTime) { |
| vl_remainingTime := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM |
| } |
| // set different start time for different LGens => smooth out synchronous call generation (far small CPS): |
| var float vl_stTrafficCorrigation := v_LGenBase_entityGroups[vl_eGrpIdx].trafficCorrigation/v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.cpsToReach; |
| vl_remainingTime := vl_remainingTime + vl_stTrafficCorrigation; |
| f_EPTF_LGenBase_restartActionTimer(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer, |
| refers(f_EPTF_LGenBase_doTrafficCaseTimerAction), |
| {pl_tcAbsIdx}, |
| vl_remainingTime); |
| } |
| /*}else{ |
| if(-1 < v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer){ |
| f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer) |
| v_LGenBase_trafficCases[pl_tcAbsIdx].schedulingTimer := -1 |
| }*/ |
| } |
| } |
| return vl_ret; |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setScenarioCPS |
| // |
| // Purpose: |
| // Sets the required CPS of the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setScenarioCPS( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in float pl_newCps |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 < vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 < vl_scIdx); |
| var float vl_ret := f_EPTF_LGenBase_setScenarioCPSByIdx(vl_eGrpIdx, vl_scIdx, pl_newCps); |
| return vl_ret; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getEGrpName |
| // |
| // Purpose: |
| // Public function to get the size of the entity group based on the index of the entity group |
| // |
| // Detailed Comments: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getEGrpName( |
| in integer pl_eGrpIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return charstring{ |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group index.",pl_eGrpIdx > -1 and pl_eGrpIdx < sizeof(v_LGenBase_entityGroups)); |
| return v_LGenBase_entityGroups[pl_eGrpIdx].name; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_registerCPSChangedCallback_SC |
| // |
| // Purpose: |
| // Registers a CPS changed callback for the given scenario instance |
| // |
| // Parameters: |
| // pl_eGrpName - *in charstring* - the entity group name |
| // pl_scName - *in charstring* - the scenario name |
| // pl_cpsChangedCallback - *in* <EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT> - the scenario CPS changed callback |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_registerCPSChangedCallback_SC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in EPTF_LGenBase_ScenarioCPSChangedCallbackFn_FT pl_cpsChangedCallback |
| ) runs on EPTF_LGenBase_Private_CT { |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 < vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 < vl_scIdx); |
| f_EPTF_Base_assert(%definitionId&": CPS change callback cannot be set to non-weighted scenario: " |
| &v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].uniqueName, |
| f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)); |
| |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].cpsChangedCallbackList[sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].cpsChangedCallbackList)] := pl_cpsChangedCallback; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_deregisterCPSChangedCallback_SC |
| // |
| // Purpose: |
| // DeRegisters a CPS changed callback for the given scenario instance |
| // |
| // Parameters: |
| // pl_eGrpName - *in charstring* - the entity group name |
| // pl_scName - *in charstring* - the scenario name |
| // pl_cpsChangedCallback - *in* <EPTF_LGenBase_TrafficCaseCPSChangedCallbackFn_FT> - the scenario CPS changed callback |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_deregisterCPSChangedCallback_SC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in EPTF_LGenBase_ScenarioCPSChangedCallbackFn_FT pl_cpsChangedCallback |
| ) runs on EPTF_LGenBase_Private_CT { |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 < vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 < vl_scIdx); |
| |
| for(var integer i:=0; i<sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].cpsChangedCallbackList); i:=i+1) { |
| if(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].cpsChangedCallbackList[i]==pl_cpsChangedCallback) { |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].cpsChangedCallbackList[i] := null; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_callCPSChangedCallbacks_SC |
| // |
| // Purpose: |
| // Calls the CPS changed callbacks for the given scenario instance |
| // |
| // Parameters: |
| // pl_cps - *in float* - the new CPS value |
| // pl_eGrpIdx - *in integer* - the entity group instance idx |
| // pl_scIdx - *in integer* - the scenario instance idx in entity group |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_callCPSChangedCallbacks_SC(in float pl_cps, in integer pl_eGrpIdx, in integer pl_scIdx) runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group index: "&int2str(pl_eGrpIdx),-1 < pl_eGrpIdx and pl_eGrpIdx < sizeof(v_LGenBase_entityGroups)); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index: "&int2str(pl_scIdx),-1 < pl_scIdx and pl_scIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios)); |
| f_EPTF_Base_assert(%definitionId&": CPS cannot set to non-weighted scenario: " |
| &v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].uniqueName, |
| f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scIdx)); |
| |
| for (var integer i:=0; i<sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].cpsChangedCallbackList); i:=i+1) { |
| if (v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].cpsChangedCallbackList[i]!=null) { |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].cpsChangedCallbackList[i].apply(pl_cps,pl_eGrpIdx,pl_scIdx); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setScenarioCPSByIdx |
| // |
| // Purpose: |
| // Sets the required CPS of the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setScenarioCPSByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx, |
| in float pl_newCps, |
| in boolean pl_forceAdjust := false |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group index: "&int2str(pl_eGrpIdx),-1 < pl_eGrpIdx and pl_eGrpIdx < sizeof(v_LGenBase_entityGroups)); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index: "&int2str(pl_scIdx),-1 < pl_scIdx and pl_scIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios)); |
| f_EPTF_Base_assert(%definitionId&": CPS cannot set to non-weighted scenario: " |
| &v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].uniqueName, |
| f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scIdx)); |
| var float vl_ret := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.target.cpsToReach; |
| if(pl_forceAdjust or v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.target.cpsToReach == pl_newCps) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": setting the same CPS value ignored."); |
| return vl_ret; |
| } |
| if(originating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].trafficType and |
| -1 < v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer){ |
| f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer) |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer := -1 |
| } |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.target.cpsToReach := pl_newCps; |
| f_EPTF_LGenBase_callCPSChangedCallbacks_SC(pl_newCps,pl_eGrpIdx,pl_scIdx); |
| if(originating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].trafficType){ |
| f_EPTF_LGenBase_adjustSchedulerData4NewCps(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData); |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation; |
| var EPTF_LGenBase_tcState vl_statePrev := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].state; |
| if(c_EPTF_LGenBase_tcStateRunning != vl_statePrev){ |
| return vl_ret; // do not schedule event if SC is not running |
| } |
| if(0.0 < pl_newCps){ |
| // set different start time for different LGens => smooth out synchronous call generation (far small CPS): |
| var float vl_stTrafficCorrigation := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation/v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.target.cpsToReach; |
| f_EPTF_LGenBase_restartActionTimer( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer, |
| refers(f_EPTF_LGenBase_doWeightedScenarioTimerAction), |
| {pl_eGrpIdx, pl_scIdx}, |
| vl_stTrafficCorrigation |
| ); |
| /*}else{ |
| if(-1 < v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer){ |
| f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer) |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.schedulingTimer := -1 |
| }*/ |
| } |
| } |
| return vl_ret; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcCpsToReachByName |
| // |
| // Purpose: |
| // Retrieves the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getScCpsToReachByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scName) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| var integer vl_scRelIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| return f_EPTF_LGenBase_getScCpsToReachByIdx(vl_eGrpIdx, vl_scRelIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Wrapper function for backward compatibility |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getScCpsSoReachByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scName) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| return f_EPTF_LGenBase_getScCpsToReachByName(pl_eGrpName, pl_scName) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getScCpsToReachByIdx |
| // |
| // Purpose: |
| // Retrieves the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getScCpsToReachByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scRelIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| f_EPTF_Base_assert(%definitionId&": The "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scRelIdx].uniqueName& |
| " scenario is not a weighted scenario.", |
| f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scRelIdx)); |
| return v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scRelIdx].schedulerData.target.cpsToReach; |
| //pl_tc.schedulerData.target.cpsToReach |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setTcWeight |
| // |
| // Purpose: |
| // Sets the required CPS of the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setTcWeight( |
| in integer pl_tcAbsIdx, |
| in float pl_newWeight) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| f_EPTF_Base_assert(%definitionId&": Weight cannot set to normal TC: " |
| &v_LGenBase_trafficCases[pl_tcAbsIdx].uniqueName, |
| ischosen(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.trafficWeight)); |
| |
| var float vl_ret := v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.trafficWeight ; |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcAbsIdx].eGroupBackref; |
| var integer vl_scInGrpIdx := v_LGenBase_trafficCases[pl_tcAbsIdx].eScenarioBackRef; |
| |
| v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData.target.trafficWeight := pl_newWeight |
| |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scInGrpIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| |
| //set modulo,roundedUpdateInterval, idealBurstSize |
| //f_EPTF_LGenBase_adjustSchedulerData4NewCps(v_LGenBase_trafficCases[pl_tcAbsIdx].schedulerData); |
| |
| return vl_ret; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getCPSByNames |
| // |
| // Purpose: |
| // Retrieves the last reached CPS of the traffic case |
| // |
| // Detailed Comments: |
| // This function retrives the content of the lastCPS field |
| // of the traffic case descriptor. To retrieve the measured |
| // last CPS use the <f_EPTF_LGenBase_getMeasuredCPSByNames> |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getCPSByNames( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| return f_EPTF_LGenBase_getCPS(vl_tcAbsIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getCPS |
| // |
| // Purpose: |
| // Retrieves the last reached CPS of the traffic case |
| // |
| // Detailed Comments: |
| // This function retrives the content of the lastCPS field |
| // of the traffic case descriptor. To retrieve the measured |
| // last CPS use the <f_EPTF_LGenBase_getMeasuredCPSByIdx> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getCPS( |
| in integer pl_tcAbsIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| return v_LGenBase_trafficCases[pl_tcAbsIdx].lastCPS; |
| } |
| |
| //TODO comment |
| public function f_EPTF_LGenBase_getMeasuredCPSByNames( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var charstring vl_varName := |
| f_EPTF_LGenBase_getNamePrefix(pl_eGrpName, pl_scName, pl_tcName) & c_EPTF_LGenBaseStats_nameOfTcLastCps |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName) |
| if(0 > vl_varIdx){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Invalid traffic case names: "&pl_eGrpName&","&pl_scName&","&pl_tcName) |
| return 0.0 |
| } |
| var EPTF_Var_DirectContent vl_content |
| f_EPTF_Var_getContent(vl_varIdx, vl_content) |
| return vl_content.floatVal |
| } |
| |
| //TODO comment |
| public function f_EPTF_LGenBase_getMeasuredCPSByIdx( |
| in integer pl_tcAbsIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return float{ |
| var charstring vl_eGrpName, vl_scName, vl_tcName |
| f_EPTF_LGenBase_trafficCaseIdNames(pl_tcAbsIdx, vl_eGrpName, vl_scName, vl_tcName) |
| return f_EPTF_LGenBase_getMeasuredCPSByNames(vl_eGrpName, vl_scName, vl_tcName) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_tcTimerIsRunning |
| // |
| // Purpose: |
| // Retrieves whether a named timer is running |
| // in the FSM of the traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_tcTimerIsRunning( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in charstring pl_timerName, |
| in integer pl_eRelIdx, |
| in integer pl_siblingIdx := 0 |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| var integer vl_grpIdx := v_LGenBase_trafficCases[vl_tcAbsIdx].eGroupBackref; |
| f_EPTF_Base_assert(%definitionId& "Invalid entity index.",pl_eRelIdx<v_LGenBase_entityGroups[vl_grpIdx].eCount and pl_eRelIdx > -1); |
| var integer vl_eAbsIdx := v_LGenBase_entityGroups[vl_grpIdx].eOffset+pl_eRelIdx; |
| var integer vl_fsmCtxIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(pl_eRelIdx, vl_tcAbsIdx, pl_siblingIdx); |
| if(0 > vl_fsmCtxIdx){ |
| return false; |
| } |
| var integer vl_timerIdx := -1; |
| var integer vl_i := 0; |
| var integer vl_fsmIdx := v_LGenBase_trafficCases[vl_tcAbsIdx].fsmIdx; |
| while ( vl_timerIdx < 0 and vl_i < sizeof(v_LGenBase_fsmTables[vl_fsmIdx].timerList) ) |
| { |
| if(pl_timerName == v_LGenBase_fsmTables[vl_fsmIdx].timerList[vl_i].name){ |
| vl_timerIdx := vl_i; |
| } |
| vl_i := vl_i + 1; |
| } |
| f_EPTF_Base_assert(%definitionId& "Invalid timer name: "&pl_timerName,-1 < vl_timerIdx); |
| return f_EPTF_LGenBase_fsmTimerIsRunning(vl_eAbsIdx,vl_fsmCtxIdx,vl_timerIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_nrOfBusyEntities |
| // |
| // Purpose: |
| // Returns the count of busy entities in a traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_nrOfBusyEntities( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return integer |
| { |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| return f_EPTF_FBQ_getLengthOfBusyChain(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq); |
| } else { |
| return f_EPTF_RNA_getLengthOfBusyList(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getTcState |
| // |
| // Purpose: |
| // Returns the state of a traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getTcState( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_tcState |
| { |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| return v_LGenBase_trafficCases[pl_tcIdx].state |
| } |
| |
| //TODO comment |
| public function f_EPTF_LGenBase_getScStateByNames( |
| in charstring pl_eGrpName, |
| in charstring pl_scName |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_tcState |
| { |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx); |
| return f_EPTF_LGenBase_getScState(vl_eGrpIdx, vl_scIdx) |
| } |
| |
| //TODO comment |
| public function f_EPTF_LGenBase_getScState( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdxInGrp |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_tcState |
| { |
| return v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].state |
| } |
| }//GetSet |
| |
| /////////////////////////////////////////////////////////// |
| // Group: StartStop |
| // |
| // Purpose: |
| // Functions to start, stop, pause, etc. the traffic cases and scenarios |
| /////////////////////////////////////////////////////////// |
| group StartStop{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopTrafficCase |
| // |
| // Purpose: |
| // Calls f_EPTF_LGenBase_stopTrafficCaseByIdx and stops the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_stopTrafficCase( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_stopTrafficCaseByIdx(f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startTrafficCase |
| // |
| // Purpose: |
| // Calls f_EPTF_LGenBase_enableTrafficCaseInternal and starts the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startTrafficCase( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| f_EPTF_LGenBase_startTrafficCaseByIdx(vl_tcAbsIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startTrafficCaseByIdx |
| // |
| // Purpose: |
| // Calls f_EPTF_LGenBase_enableTrafficCaseInternal and starts the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startTrafficCaseByIdx( |
| in integer pl_tcAbsIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcAbsIdx].eGroupBackref |
| var integer vl_scInGrpIdx := v_LGenBase_trafficCases[pl_tcAbsIdx].eScenarioBackRef |
| if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scInGrpIdx)){ |
| // if scenario is weighted and it is not running, start it: |
| if (v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].state != c_EPTF_LGenBase_tcStateRunning) { |
| f_EPTF_LGenBase_enableScenarioOnEntityGroup(vl_eGrpIdx, vl_scInGrpIdx, true); |
| if (v_LGenBase_trafficCases[pl_tcAbsIdx].state == c_EPTF_LGenBase_tcStateRunning) { |
| return; // traffic case is already running, do not need to start it |
| } |
| } |
| } |
| |
| f_EPTF_LGenBase_enableTrafficCaseInternal(pl_tcAbsIdx, true); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startWeightedScenario |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_stopTC> to the |
| // entities in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startWeightedScenario( |
| in charstring pl_eGrpName, |
| in charstring pl_scName) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| var integer vl_scInGrpIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName) |
| if (f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx,vl_scInGrpIdx)) { |
| f_EPTF_LGenBase_enableScenarioOnEntityGroup(vl_eGrpIdx, vl_scInGrpIdx, true) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishLaunchTC |
| // |
| // Purpose: |
| // Calls the <f_EPTF_LGenBase_disableTrafficCaseInternal> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_finishLaunchTC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| f_EPTF_LGenBase_finishLaunchTCByIdx(vl_tcAbsIdx) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishLaunchTCByIdx |
| // |
| // Purpose: |
| // Calls the <f_EPTF_LGenBase_disableTrafficCaseInternal> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_finishLaunchTCByIdx( |
| in integer pl_tcAbsIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index: "&int2str(pl_tcAbsIdx),-1 < pl_tcAbsIdx and pl_tcAbsIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_LGenBase_disableTrafficCaseInternal(pl_tcAbsIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishTCByName |
| // |
| // Purpose: |
| // Stops the traffic case like the custom finish condition |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_finishTCByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcAbsIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| f_EPTF_LGenBase_finishTCByIdx(vl_tcAbsIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishTCByIdx |
| // |
| // Purpose: |
| // Stops the traffic case like the custom finish condition |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_finishTCByIdx( |
| in integer pl_tcAbsIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index: "&int2str(pl_tcAbsIdx),-1 < pl_tcAbsIdx and pl_tcAbsIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_LGenBase_groupFinishedDetected(pl_tcAbsIdx, c_EPTF_LGenBase_customConditionTrue) |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopTrafficCaseByIdx |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_stopTC> to the |
| // entities in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_stopTrafficCaseByIdx( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(terminating == v_LGenBase_trafficCases[pl_tcIdx].trafficType){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Stop called for terminating tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName& |
| ". The feature is not implemented yet."); |
| return; |
| } |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index: "&int2str(pl_tcIdx),-1 < pl_tcIdx and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": StopTrafficCaseByIdx called for tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| v_LGenBase_trafficCases[pl_tcIdx].stopped := true |
| f_EPTF_LGenBase_disableTrafficCaseInternal(pl_tcIdx); |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateStopping; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| var integer vl_maxEntity := v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].eCount; |
| f_EPTF_FBQ_initFreeBusyQueue(v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| //var integer vl_maxEntities := sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList); |
| //f_EPTF_FBQ_createFreeSlots(vl_maxEntities, v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| f_EPTF_FBQ_createFreeSlots(vl_maxEntity, v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| |
| //cancel timer first: |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer){ |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling stop timeout timer failed."); |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer := -1; |
| } |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| T_EPTF_componentClock.read + tsp_EPTF_LGenBase_abortStopProcess, |
| refers(f_EPTF_LGenBase_stopProcessTimedOut), |
| {pl_tcIdx,0}, |
| v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingError(%definitionId&" can not schedule the timer event to abort the stop process."); |
| f_EPTF_Base_stop(); |
| } |
| for ( var integer vl_i := 0; vl_i < vl_maxEntity ; vl_i := vl_i+1 ) |
| { |
| if(not f_EPTF_FBQ_itemIsBusy(f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,0), v_LGenBase_entities[v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[vl_i].entityIdx].fsmCtxQueue) |
| or v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[vl_i].disabled){ |
| continue; // fsm is inactive or entity is disabled **** |
| } |
| |
| var EPTF_LGenBase_ReportedEventDescriptor vl_stopTcOfFsmEvent := c_EPTF_LGenBase_emptyReportedEventDescriptor; |
| vl_stopTcOfFsmEvent.event.bIdx := c_EPTF_LGenBase_bIdx; |
| vl_stopTcOfFsmEvent.event.iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_stopTC; |
| vl_stopTcOfFsmEvent.event.target := { |
| eIdx := v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[vl_i].entityIdx, |
| fsmCtxIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,0) |
| }; |
| vl_stopTcOfFsmEvent.reportedArgs := {pl_tcIdx}; |
| f_EPTF_LGenBase_dispatchEvent(vl_stopTcOfFsmEvent); |
| } |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId& |
| ": Timer: "&log2str(v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer)) |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].lastCPS := 0.0; |
| |
| // if in weighted scenario: recalculate the traffic mix: |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref |
| var integer vl_scInGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef |
| if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scInGrpIdx)) |
| { |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scInGrpIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopProcessTimedOut |
| // |
| // Purpose: |
| // This function is called when the traffic case had been stopped, but |
| // not all the entities handled the stop event in a predefined interval. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_stopProcessTimedOut( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| var integer vl_tcIdx := pl_action.actionId[0]; |
| var charstring vl_msg := ""; |
| v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer := -1; |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": StopProcessTimedOut called for tc "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": State of tc: "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]); |
| select( v_LGenBase_trafficCases[vl_tcIdx].state ) |
| { |
| case ( c_EPTF_LGenBase_tcStateAborting ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStateAborted; |
| vl_msg :=%definitionId&": WARNING: "&"Abort the entities of the traffic case "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" has been timed out."; |
| f_EPTF_LGenBase_logNotRespondedEntities(vl_tcIdx, "abort") |
| } |
| case ( c_EPTF_LGenBase_tcStateStopping ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStateStopped; |
| if(null != v_LGenBase_detectPhaseFinishFn){v_LGenBase_detectPhaseFinishFn.apply( vl_tcIdx )} |
| //f_EPTF_LGenBase_callPhaseFinishConditions(vl_tcIdx); |
| vl_msg :=%definitionId&": WARNING: "&"Stop the entities of the traffic case "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" has been timed out."; |
| f_EPTF_LGenBase_logNotRespondedEntities(vl_tcIdx, "stop") |
| } |
| case ( c_EPTF_LGenBase_tcStateFinished, c_EPTF_LGenBase_tcStateTerminated ) |
| { |
| vl_msg := %definitionId&": Stop the entities of the traffic case "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" has been timed out."; |
| f_EPTF_LGenBase_logNotRespondedEntities(vl_tcIdx, "stop or abort") |
| } |
| case else |
| { |
| if(2 > sizeof(pl_action.actionId) or 1 != pl_action.actionId[1]){ |
| vl_msg :=%definitionId&": WARNING: "&": The traffic case is in invalid "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]&" state!"; |
| }else{ |
| vl_msg :=%definitionId&": WARNING: "&": Not all the entities answered to the stop or abort event. State: "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]; |
| } |
| f_EPTF_LGenBase_logNotRespondedEntities(vl_tcIdx, "stop or abort") |
| } |
| } |
| f_EPTF_FBQ_initFreeBusyQueue(v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo); |
| f_EPTF_LGenBase_tcStateChanged(vl_tcIdx); |
| f_EPTF_LGenBase_loggingWarning(vl_msg); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_singleShotTc |
| // |
| // Purpose: |
| // Starts a traffic on the first available entity in the traffic case. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_singleShotTc( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in integer pl_eIdx := -1 |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName) |
| f_EPTF_LGenBase_singleShotTcByIdx(vl_tcIdx,pl_eIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_singleShotTcByIdx |
| // |
| // Purpose: |
| // Starts a traffic on the first available or the selected entity in the traffic case. |
| // |
| // Detailed Comment: |
| // The index of the entity is realtive index in the entity group |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_singleShotTcByIdx( |
| in integer pl_tcIdx, |
| in integer pl_eIdx := -1, |
| in boolean pl_singleShotDebug := false |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index: "&int2str(pl_eIdx),pl_eIdx < v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].eCount) |
| var integer vl_eIdxInTC := pl_eIdx |
| if(0 > vl_eIdxInTC){ |
| vl_eIdxInTC := f_EPTF_LGenBase_getNextFreeEntity(pl_tcIdx) |
| }else{ |
| } |
| if (vl_eIdxInTC >=0) { |
| var integer vl_logBufferVar := -1 |
| var integer vl_eAbsIdx := vl_eIdxInTC+v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].eOffset |
| if(pl_singleShotDebug){ |
| f_EPTF_Var_newCharstring(c_EPTF_LGenBase_fsmSingleShotVarPrefix&f_EPTF_LGenBase_getEntityName(vl_eAbsIdx), "", vl_logBufferVar) |
| for ( var integer vl_postproc := 0; vl_postproc < sizeof(v_LGenBase_singleShotDebugPostprocList) ; vl_postproc := vl_postproc+1 ){ |
| f_EPTF_Var_addPostProcFn(vl_logBufferVar, v_LGenBase_singleShotDebugPostprocList[vl_postproc]) |
| } |
| } |
| v_LGenBase_dummyBool := f_EPTF_LGenBase_doStartStep(vl_eIdxInTC, pl_tcIdx, true, pl_singleShotDebug, vl_logBufferVar); |
| }else{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": There is no free entity in traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_singleShotSc |
| // |
| // Purpose: |
| // Starts a traffic on the first available entity in the |
| // enabled traffic cases of the scenario. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_singleShotSc( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in integer pl_eIdx := -1 |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx); |
| f_EPTF_LGenBase_singleShotScByIdx(vl_eGrpIdx, vl_scIdx, pl_eIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_singleShotScByIdx |
| // |
| // Purpose: |
| // Starts a traffic on the first available entity in the |
| // enabled traffic cases of the scenario. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_singleShotScByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx, |
| in integer pl_eIdx := -1 |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group index: "&int2str(pl_eGrpIdx),-1 < pl_eGrpIdx and pl_eGrpIdx < sizeof(v_LGenBase_entityGroups)); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index: "&int2str(pl_scIdx),-1 < pl_scIdx and pl_scIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity index: "&int2str(pl_eIdx),pl_eIdx < v_LGenBase_entityGroups[pl_eGrpIdx].eCount) |
| var integer vl_tcCount := sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList) |
| for ( var integer vl_i := 0; vl_i < vl_tcCount ; vl_i := vl_i+1 ) |
| { |
| if(v_LGenBase_trafficCases[v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList[vl_i]].enabled){ |
| f_EPTF_LGenBase_singleShotTcByIdx(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList[vl_i], pl_eIdx); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_createScenarios2EntityGroup |
| // |
| // Purpose: |
| // Adds a traffic case list to the entity group |
| // |
| // Detailed Comments: |
| // This function creates the |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_TcMgmt_createScenarios2EntityGroup( |
| in EPTF_LGenBase_TcMgmt_Scenarios2GrpList pl_list) |
| runs on EPTF_LGenBase_Private_CT{ |
| for ( var integer vl_i := 0; vl_i < sizeof(pl_list) ; vl_i := vl_i+1 ) |
| { |
| for ( var integer vl_sc := 0; vl_sc < sizeof(pl_list[vl_i].scenarioNames) ; vl_sc := vl_sc+1 ) |
| { |
| f_EPTF_LGenBase_createScenario2EntityGroup({pl_list[vl_i].eGrpName, pl_list[vl_i].scenarioNames[vl_sc]},false); |
| } |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_createScenario2EntityGroup |
| // |
| // Purpose: |
| // Adds a traffic case list to the entity group |
| // |
| // Detailed Comments: |
| // This function creates the scenario to an entity group |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_createScenario2EntityGroup( |
| in EPTF_LGenBase_Scenario2Grp pl_scenarioDesc, |
| in boolean pl_autoStart := true) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_scenarioDesc.eGrpName); |
| if(vl_eGrpIdx == -1){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": Invalid entity group: "&pl_scenarioDesc.eGrpName); |
| } |
| var integer vl_scIdx := f_EPTF_LGenBase_scenarioNameIndex(pl_scenarioDesc.scenarioName); |
| if(vl_scIdx == -1){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": Invalid scenario name: "&pl_scenarioDesc.scenarioName); |
| } |
| if(-1 != f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scenarioDesc.scenarioName)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": Scenario "&pl_scenarioDesc.scenarioName&" already exists in group "&pl_scenarioDesc.eGrpName); |
| } |
| var EPTF_LGenBase_ScenarioOfGrp vl_sc := c_EPTF_LGenBase_emptyScenarioOfGrp; |
| vl_sc.name := pl_scenarioDesc.scenarioName; |
| vl_sc.uniqueName := pl_scenarioDesc.eGrpName&tsp_LGenBase_nameSeparator&pl_scenarioDesc.scenarioName; |
| vl_sc.weightedScData := v_LGenBase_scenarioTypes[vl_scIdx].weightedScData;//EGBOZIE: new, is omit for weighted scenario |
| vl_sc.phaseData := v_LGenBase_scenarioTypes[vl_scIdx].phaseData;// phase data |
| var integer vl_scIdxInGrp := sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios); |
| var integer vl_tcCount := sizeof(v_LGenBase_scenarioTypes[vl_scIdx].tcList); |
| var boolean vl_isWeightedSc := ispresent(vl_sc.weightedScData);//EGBOZIE |
| var EPTF_ProbabilityList vl_new_wList := {};//EGBOZIE used only for weighted SC |
| var integer vl_tcAbsIdx := -1; |
| vl_sc.absIdx := f_EPTF_FBQ_getOrCreateFreeSlot(v_LGenBase_scenarios); |
| vl_sc.trafficType := v_LGenBase_scenarioTypes[vl_scIdx].trafficType |
| f_EPTF_FBQ_setQueueDidx(vl_sc.absIdx, {vl_eGrpIdx,vl_scIdxInGrp}, v_LGenBase_scenarios); |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_sc.absIdx, v_LGenBase_scenarios); |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp] := vl_sc; |
| //Create and initialize all the traffic case specimen |
| for(var integer vl_i := 0; vl_i < vl_tcCount; vl_i := vl_i + 1){ |
| vl_tcAbsIdx := f_EPTF_LGenBase_createTc2EntityGroup( |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i], |
| vl_eGrpIdx, |
| vl_scIdxInGrp, |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp]); |
| f_EPTF_Base_assert(%definitionId&": Error assigning the traffic case "& |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].tcPrivateName&" to group "& |
| pl_scenarioDesc.eGrpName, -1 != v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_i]); |
| //vl_tcAbsIdx := vl_sc.tcIdxList[vl_i]; |
| |
| } |
| for(var integer vl_i := 0; vl_i < vl_tcCount; vl_i := vl_i + 1){ |
| vl_tcAbsIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_i]; |
| v_LGenBase_trafficCases[vl_tcAbsIdx].trafficStartFinishConditionsAndActions := c_EPTF_LGenBase_emptyTrafficStartFinishConditionsAndActionsDesc; |
| if(v_LGenBase_scenarioTypes[vl_scIdx].conditionsFromTc){ |
| //Use conditions and actions declared in the tc type declaration |
| f_EPTF_LGenBase_convertTrafficStartFinishConditionsInternalDeclarator2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_trafficCaseTypes[v_LGenBase_trafficCases[vl_tcAbsIdx].tcTypeIdx].trafficStartFinishConditions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].trafficStartFinishConditionsAndActions) |
| f_EPTF_LGenBase_convertEntityFinishConditionsInternalDeclarator2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_trafficCaseTypes[v_LGenBase_trafficCases[vl_tcAbsIdx].tcTypeIdx].entityFinishConditions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].entityFinishConditions) |
| f_EPTF_Base_assert(%definitionId&": There is range loop condition without range", |
| (not ispresent(v_LGenBase_trafficCases[vl_tcAbsIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop))or |
| v_LGenBase_trafficCases[vl_tcAbsIdx].v_sizeofRanges > 0); |
| f_EPTF_LGenBase_convertTcEntityFinishActions2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_trafficCaseTypes[v_LGenBase_trafficCases[vl_tcAbsIdx].tcTypeIdx].entityFinishActions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].entityFinishActions); |
| f_EPTF_LGenBase_convertGroupActionsList2GroupActionsDescList( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_trafficCaseTypes[v_LGenBase_trafficCases[vl_tcAbsIdx].tcTypeIdx].trafficFinishedActions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].trafficFinishedActions); |
| }else{ |
| //Use conditions and actions declared in the tcOfScenario |
| f_EPTF_LGenBase_convertEntityFinishConditionsInternalDeclarator2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].entityFinishConditions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].entityFinishConditions); |
| f_EPTF_LGenBase_convertTrafficStartFinishConditionsInternalDeclarator2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].trafficStartFinishConditionsAndActions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].trafficStartFinishConditionsAndActions); |
| f_EPTF_LGenBase_convertTcEntityFinishActions2Desc( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].entityFinishActions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].entityFinishActions); |
| f_EPTF_LGenBase_convertGroupActionsList2GroupActionsDescList( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp], |
| v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].trafficFinishedActions, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].trafficFinishedActions); |
| } |
| v_LGenBase_trafficCases[vl_tcAbsIdx].paramRanges := v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].ranges; |
| v_LGenBase_trafficCases[vl_tcAbsIdx].v_sizeofRanges := sizeof(v_LGenBase_trafficCases[vl_tcAbsIdx].paramRanges); |
| |
| v_LGenBase_trafficCases[vl_tcAbsIdx].customParams := v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].params; |
| |
| v_LGenBase_trafficCases[vl_tcAbsIdx].restoreTCAtStartTC := v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_i].restoreTCAtStartTC; |
| |
| var integer vl_paramCount := sizeof(v_LGenBase_trafficCases[vl_tcAbsIdx].customParams); |
| for ( var integer vl_par := 0; vl_par < vl_paramCount ; vl_par := vl_par+1 ) |
| { |
| f_EPTF_str2int_HashMap_Insert(v_LGenBase_trafficCases[vl_tcAbsIdx].paramHashMap, |
| v_LGenBase_trafficCases[vl_tcAbsIdx].customParams[vl_par].aName& |
| tsp_LGenBase_nameSeparator& |
| v_LGenBase_trafficCases[vl_tcAbsIdx].customParams[vl_par].pName, |
| vl_par); |
| } |
| |
| |
| if (vl_isWeightedSc){ |
| var integer vl_tcIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_i]; |
| f_EPTF_Base_assert(%definitionId&": collecting traffic weights: TC["&int2str(vl_i)&"] in weighted SC shall have a weight instead of cpsToReach!", |
| ischosen(v_LGenBase_trafficCases[vl_tcIdx].schedulerData.target.trafficWeight)); |
| if (v_LGenBase_trafficCases[v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_i]].enabled) { |
| vl_new_wList[vl_i] := v_LGenBase_trafficCases[vl_tcIdx].schedulerData.target.trafficWeight; |
| } else { |
| vl_new_wList[vl_i] := 0.0; |
| } |
| } |
| } |
| //now take care for extra data in case of weighted scenario |
| if (vl_isWeightedSc) { |
| |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData := c_EPTF_LGenBase_emptySchedulerData4TcWeight |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.target.cpsToReach := v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.cpsToReach |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.roundedCpsUpdateInterval := tsp_EPTF_cpsUpdateInterval |
| //{{"cs", null, null}, false, {cpsToReach:= v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.cpsToReach},0,0,0.0,tsp_EPTF_cpsUpdateInterval,0.0,-1,0,{false,0.0,{}}} |
| // setting burst calc for weighted |
| var charstring vl_burstName; |
| if(ispresent(v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.scheduler)) { |
| if(ischosen(v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.scheduler.preDefinedName)){ |
| vl_burstName := f_EPTF_LGenBase_BurstFuncName2Char(v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.scheduler.preDefinedName); |
| } else { |
| vl_burstName := v_LGenBase_scenarioTypes[vl_scIdx].weightedScData.scheduler.userDefinedName; |
| } |
| } else { |
| if("" != v_LGenBase_burstCalcMode) { |
| vl_burstName := v_LGenBase_burstCalcMode; |
| } else { |
| f_EPTF_Base_assert(%definitionId&"No Global or Local burst calculation method is set.",false); |
| } |
| } |
| |
| var integer vl_burstId := f_EPTF_LGenBase_getBurstCalcFunctionId(vl_burstName); |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.burstFuncRef.burstCalcMode := v_LGenBase_burstFuncRefList[vl_burstId].burstCalcMode; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.burstFuncRef.burstPreCalc := v_LGenBase_burstFuncRefList[vl_burstId].burstPreCalc; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.burstFuncRef.burstPostCalc := v_LGenBase_burstFuncRefList[vl_burstId].burstPostCalc; |
| |
| |
| f_EPTF_LGenBase_adjustSchedulerData4NewCps(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData); |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[vl_eGrpIdx].trafficCorrigation; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].trafficMixData := { |
| wList := vl_new_wList, // initial weight of each traffic |
| pList := {}, // probability of each traffic ( == eloszlas-Fv), will be inited later |
| currentBurst := {}, |
| burstList := {}, |
| burstListIdx := 0 |
| } |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].trafficMixData, |
| vl_new_wList, |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].weightedScData.deterministicMix |
| ); |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&pl_scenarioDesc.scenarioName& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| } |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugConfig)){ |
| f_EPTF_LGenBase_loggingDebugConfig(%definitionId&": constructed scenario:"&log2str(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp])) |
| } |
| f_EPTF_LGenBaseStats_createScenarioVars(vl_eGrpIdx, vl_scIdxInGrp); |
| for (var integer x:= 0; x<sizeof(v_LGenBase_scenarioCreated); x:= x+1) |
| { |
| v_LGenBase_scenarioCreated[x].apply( vl_eGrpIdx, vl_scIdxInGrp ); |
| } |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList) ; vl_i := vl_i+1 ) |
| { |
| f_EPTF_LGenBase_tcStateChanged(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_i]); |
| } |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| vl_tcAbsIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_tc] |
| for (var integer x:= 0; x<sizeof(v_LGenBase_trafficCaseCreated); x:= x+1) |
| { |
| v_LGenBase_trafficCaseCreated[x].apply( vl_tcAbsIdx ); |
| } |
| } |
| |
| var boolean vl_autoStart := pl_autoStart; |
| if(ispresent(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].phaseData)){ |
| vl_autoStart := false; // if phase information exists disabling automatic scenario generation |
| } |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugConfig)){ |
| f_EPTF_LGenBase_loggingDebugConfig(%definitionId&": The created scenario: "&log2str( v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp] )) |
| f_EPTF_LGenBase_loggingDebugConfig(%definitionId&": The traffic cases: ") |
| for ( var integer vl_t := 0; vl_t < sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList) ; vl_t := vl_t+1 ) |
| { |
| f_EPTF_LGenBase_loggingDebugConfig(%definitionId&": "&log2str(v_LGenBase_trafficCases[v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdxInGrp].tcIdxList[vl_t]])) |
| } |
| } |
| //EGBOZIE: code refactored into a standalone function |
| f_EPTF_LGenBase_enableScenarioOnEntityGroup( |
| vl_eGrpIdx, //entity group |
| vl_scIdxInGrp, //scenario index in group |
| vl_autoStart or terminating == vl_sc.trafficType) |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_restoreScenario |
| // |
| // Purpose: |
| // Initializes the entities and the statistics of a traffic cases of the scenario. |
| // |
| // Detailed Comments: |
| // This function is used to reset the entities and the statistics |
| // of the traffic casees of a scenario before restart. If pl_autoStart |
| // and the enabled field of the declarator of the traffic case is true, starts the affected traffic cases |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_restoreScenario( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in boolean pl_autoStart := true |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx); |
| return f_EPTF_LGenBase_restoreScenarioByIdx(vl_eGrpIdx, vl_scIdx, pl_autoStart); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resetStats |
| // |
| // Purpose: |
| // Initializes the statistics of all traffic cases. |
| // |
| // Detailed Comments: |
| // This function is used to reset the the statistics |
| // of all traffic cases. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_resetStats() |
| runs on EPTF_LGenBase_Private_CT |
| { |
| var integer vl_nOfTcs := sizeof(v_LGenBase_trafficCases); |
| for(var integer vl_tcIdx:=0; vl_tcIdx<vl_nOfTcs; vl_tcIdx:=vl_tcIdx+1) { |
| f_EPTF_LGenBase_resetTcStatsData(vl_tcIdx, v_LGenBase_trafficCases[vl_tcIdx]); |
| } |
| return; |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_restoreScenarioByIdx |
| // |
| // Purpose: |
| // Initializes the entities and the statistics of a traffic cases of the scenario. |
| // |
| // Detailed Comments: |
| // This function is used to reset the entities and the statistics |
| // of the traffic casees of a scenario before restart. If pl_autoStart |
| // and the enabled field of the declarator of the traffic case is true, starts the affected traffic cases |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_restoreScenarioByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx, |
| in boolean pl_autoStart := true |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_max := sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList); |
| for ( var integer vl_i := 0; vl_i < vl_max ; vl_i := vl_i+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList[vl_i]; |
| if(c_EPTF_LGenBase_tcStateRunning == v_LGenBase_trafficCases[vl_tcIdx].state){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": The running traffic case "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" can not be restored!"); |
| return false; |
| } |
| } |
| var boolean vl_ret := true; |
| for ( var integer vl_i := 0; vl_i < vl_max ; vl_i := vl_i+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList[vl_i]; |
| if(not f_EPTF_LGenBase_restoreTCbyIdx(vl_tcIdx)) { vl_ret := false; } |
| if(v_LGenBase_trafficCases[vl_tcIdx].enabledAtStartup){ |
| f_EPTF_LGenBase_enableTrafficCaseInternal( |
| vl_tcIdx, |
| pl_autoStart); |
| }else{ |
| v_LGenBase_trafficCases[vl_tcIdx].enabled := false; |
| } |
| } |
| return vl_ret; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_get_restoreTCAtStartTC |
| // |
| // Purpose: |
| // Returns the restoreTCAtStartTC flag |
| // |
| // Detailed Comments: |
| // This function is used to get the restoreTCAtStartTC flag. |
| // If this flag is true, ExecCtrl will restore the TC before |
| // the TC is started. Otherwise restoreTC is not called. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_get_restoreTCAtStartTC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| return v_LGenBase_trafficCases[vl_tcIdx].restoreTCAtStartTC; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_restoreTC |
| // |
| // Purpose: |
| // Initializes the entities and the statistics of a traffic case |
| // |
| // Detailed Comments: |
| // This function is used to reset the entities and the statistics |
| // of a traffic case before restart. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_restoreTC( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| return f_EPTF_LGenBase_restoreTCbyIdx(vl_tcIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_restoreTCbyIdx |
| // |
| // Purpose: |
| // Initializes the entities and the statistics of a traffic case |
| // |
| // Detailed Comments: |
| // This function is used to reset the entities and the statistics |
| // of a traffic case before restart. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_restoreTCbyIdx( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index",pl_tcIdx> -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| if(c_EPTF_LGenBase_tcStateRunning == v_LGenBase_trafficCases[pl_tcIdx].state){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": The running traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" can not be restored!"); |
| return false; |
| } |
| if(-1 != v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer){ |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling stop timeout timer failed."); |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer := -1; |
| v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo := c_EPTF_emptyFreeBusyQueue; |
| } |
| f_EPTF_LGenBase_initTCInternal( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| pl_tcIdx, |
| v_LGenBase_trafficCases[pl_tcIdx].enableEntitiesAtStartup, |
| false |
| ) |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateIdle; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_abortTrafficCase |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_abortTC> to the |
| // entities in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_abortTrafficCase( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_eGrpIdx := f_EPTF_LGenBase_entityGrpNameIndex(pl_eGrpName); |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group name: "&pl_eGrpName,-1 != vl_eGrpIdx); |
| var integer vl_scIdx := f_EPTF_LGenBase_scNameIndexInEG(vl_eGrpIdx, pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario name: "&pl_scName,-1 != vl_scIdx); |
| var integer vl_tcIdx := f_EPTF_LGenBase_tcOfScenario(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx], pl_tcName); |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case name: "&pl_scName,-1 != vl_tcIdx); |
| f_EPTF_LGenBase_abortTrafficCaseByIdx(f_EPTF_LGenBase_trafficCaseAbsIdx(vl_eGrpIdx, vl_scIdx, vl_tcIdx)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopWeightedScenarioByIdx |
| // |
| // Purpose: |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_stopWeightedScenarioByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer>-1) { |
| f_EPTF_LGenBase_stopScTimerInternal(pl_eGrpIdx,pl_scInGrpIdx); |
| } |
| f_EPTF_LGenBase_stopScenarioByIdx(pl_eGrpIdx,pl_scInGrpIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopScenarioByIdx |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_abortTC> to the |
| // entities in the traffic cases of the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_stopScenarioByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(terminating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].trafficType){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Stop called for terminating scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName& |
| ". The feature is not implemented yet."); |
| return; |
| } |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList[vl_tc]; |
| f_EPTF_LGenBase_stopTrafficCaseByIdx(vl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_abortWeightedScenarioByIdx |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_abortTC> to the |
| // entities in the traffic cases of the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_abortWeightedScenarioByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer>-1) { |
| f_EPTF_LGenBase_stopScTimerInternal(pl_eGrpIdx,pl_scInGrpIdx); |
| } |
| f_EPTF_LGenBase_abortScenarioByIdx(pl_eGrpIdx,pl_scInGrpIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_abortScenarioByIdx |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_abortTC> to the |
| // entities in the traffic cases of the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_abortScenarioByIdx( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(terminating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].trafficType){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Abort called for terminating scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName& |
| ". The feature is not implemented yet."); |
| return; |
| } |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList[vl_tc]; |
| f_EPTF_LGenBase_abortTrafficCaseByIdx(vl_tcIdx); |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_abortTrafficCaseByIdx |
| // |
| // Purpose: |
| // Sends <c_EPTF_LGenBase_inputIdx_testMgmt_abortTC> to the |
| // entities in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_abortTrafficCaseByIdx( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index: "&int2str(pl_tcIdx),-1 < pl_tcIdx and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| v_LGenBase_trafficCases[pl_tcIdx].stopped := true |
| f_EPTF_LGenBase_disableTrafficCaseInternal(pl_tcIdx); |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateAborting; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| f_EPTF_FBQ_initFreeBusyQueue(v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| //var integer vl_maxEntities := sizeof(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList); |
| //f_EPTF_FBQ_createFreeSlots(vl_maxEntities, v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| var integer vl_maxEntity := v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].eCount; |
| f_EPTF_FBQ_createFreeSlots(vl_maxEntity, v_LGenBase_trafficCases[pl_tcIdx].stoppingEntityInfo); |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| T_EPTF_componentClock.read + tsp_EPTF_LGenBase_abortStopProcess, |
| refers(f_EPTF_LGenBase_stopProcessTimedOut), |
| {pl_tcIdx,0}, |
| v_LGenBase_trafficCases[pl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingError(%definitionId&" Can not schedule the timer event to abort the stop process."); |
| f_EPTF_Base_stop(); |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].lastCPS := 0.0; |
| for ( var integer vl_i := 0; vl_i < vl_maxEntity ; vl_i := vl_i+1 ) |
| { |
| var EPTF_LGenBase_ReportedEventDescriptor vl_abortTcOfFsmEvent := c_EPTF_LGenBase_emptyReportedEventDescriptor; |
| vl_abortTcOfFsmEvent.event.bIdx := c_EPTF_LGenBase_bIdx; |
| vl_abortTcOfFsmEvent.event.iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_abortTC; |
| vl_abortTcOfFsmEvent.event.target := { |
| eIdx := v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[vl_i].entityIdx, |
| fsmCtxIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i, pl_tcIdx, 0) |
| }; |
| vl_abortTcOfFsmEvent.reportedArgs := {pl_tcIdx}; |
| f_EPTF_LGenBase_dispatchEvent(vl_abortTcOfFsmEvent); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startLaunchTC |
| // |
| // Purpose: |
| // Initializes and starts a traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startLaunchTC( |
| in integer pl_tcIdx, |
| in boolean pl_silentIfRunning := false) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Start traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| var EPTF_LGenBase_tcState vl_statePrev := v_LGenBase_trafficCases[pl_tcIdx].state; |
| if(c_EPTF_LGenBase_tcStatePaused != vl_statePrev and |
| c_EPTF_LGenBase_tcStateStopped != vl_statePrev and |
| c_EPTF_LGenBase_tcStateAborted != vl_statePrev and |
| c_EPTF_LGenBase_tcStateIdle != vl_statePrev and |
| c_EPTF_LGenBase_tcStateTerminated != vl_statePrev){ |
| if(c_EPTF_LGenBase_tcStateRunning != vl_statePrev or not pl_silentIfRunning){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Start launch called for tc "& |
| v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" in state "&c_EPTF_LGenBase_stateNames[vl_statePrev]); |
| } |
| return; |
| } |
| if(not v_LGenBase_trafficCases[pl_tcIdx].enabled){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Start launch called for the disabled tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| return; |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateRunning; |
| |
| // check if conditions are fulfilled at start: |
| var EPTF_IntegerList vl_counters := {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfExecStart)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfExecStart); |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfSuccesses)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfSuccesses); |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfFails)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfFails); |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfTimeouts)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfTimeouts); |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfErrors)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfErrors); |
| vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfRangeLoop)] := f_EPTF_LGenBase_getTrafficStartFinishConditionCounter(pl_tcIdx,nrOfRangeLoop); |
| |
| var EPTF_LGenBase_ConditionTrue vl_condition := c_EPTF_LGenBase_emptyConditionTrue; |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfExecStart)]==0) { |
| vl_condition.nrOfExecStart := true; |
| vl_condition.anythingFinished := true; |
| } |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfSuccesses)]==0) { |
| vl_condition.nrOfSuccesses := true; |
| vl_condition.anythingFinished := true; |
| } |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfFails)]==0) { |
| vl_condition.nrOfFails := true; |
| vl_condition.anythingFinished := true; |
| } |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfTimeouts)]==0) { |
| vl_condition.nrOfTimeouts := true; |
| vl_condition.anythingFinished := true; |
| } |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfErrors)]==0) { |
| vl_condition.nrOfErrors := true; |
| vl_condition.anythingFinished := true; |
| } |
| if (vl_counters[f_EPTF_LGenBase_TrafficStartFinishConditions_2int(nrOfRangeLoop)]==0) { |
| vl_condition.nrOfRangeLoop := true; |
| vl_condition.anythingFinished := true; |
| } |
| if(f_EPTF_LGenBase_checkGroupFinishConditionFiredAny(vl_condition)) { |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| f_EPTF_LGenBase_groupFinishedDetected(pl_tcIdx, vl_condition); |
| return; |
| } |
| |
| //~TR |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref |
| var integer vl_scInGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef |
| var float vl_stTimeDelay := v_LGenBase_trafficCases[pl_tcIdx].startDelay; |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| v_LGenBase_trafficCases[pl_tcIdx].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[vl_eGrpIdx].trafficCorrigation; |
| |
| if( 0.0 == vl_stTimeDelay ){ vl_stTimeDelay := 0.01;} // FIXME: magic number again |
| |
| if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scInGrpIdx)){ |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scInGrpIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| |
| //TR: MTTSM00016010 |
| f_EPTF_SchedulerComp_refreshSnapshotTime(); |
| v_LGenBase_trafficCases[pl_tcIdx].startTime := f_EPTF_SchedulerComp_snapshotTime(); |
| f_EPTF_LGenBase_startExecTimeTimer(pl_tcIdx); // starts execTime timer if needed, not part of the TR correction |
| |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| return; |
| } |
| if(c_EPTF_LGenBase_tcStatePaused != vl_statePrev){ |
| f_EPTF_LGenBase_resetTcStats(pl_tcIdx, v_LGenBase_trafficCases[pl_tcIdx]); |
| Inc(v_LGenBase_entityGroups[v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref].scenarios[v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef].startedTcs); |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_tcStartedOrStoppedCallbacks) ; vl_i := vl_i+1 ) |
| { |
| v_LGenBase_tcStartedOrStoppedCallbacks[vl_i].apply( pl_tcIdx, true ); |
| } |
| |
| // the function f_EPTF_LGenBase_resetTcStats becomes slow for huge number of entities => the event should be scheduled after it has been called, |
| // also the time of start should be calculated after that |
| |
| //TR: MTTSM00016010 |
| f_EPTF_SchedulerComp_refreshSnapshotTime(); |
| v_LGenBase_trafficCases[pl_tcIdx].startTime := f_EPTF_SchedulerComp_snapshotTime(); |
| f_EPTF_LGenBase_startExecTimeTimer(pl_tcIdx); // starts execTime timer if needed, not part of the TR correction |
| |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_trafficCaseStarted, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| } |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| // scheduling the event here to avoid overload after start in case of huge entity number (initializing takes a lof of time) |
| if(not f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scInGrpIdx)){ |
| if(originating == v_LGenBase_trafficCases[pl_tcIdx].trafficType and |
| ischosen(v_LGenBase_trafficCases[pl_tcIdx].schedulerData.target.cpsToReach) and |
| 0.0 < v_LGenBase_trafficCases[pl_tcIdx].schedulerData.target.cpsToReach){ |
| // set different start time for different LGens => smooth out synchronous call generation (far small CPS): |
| var float vl_stTrafficCorrigation := v_LGenBase_entityGroups[vl_eGrpIdx].trafficCorrigation/v_LGenBase_trafficCases[pl_tcIdx].schedulerData.target.cpsToReach; |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| v_LGenBase_trafficCases[pl_tcIdx].startTime+vl_stTimeDelay+vl_stTrafficCorrigation, |
| refers(f_EPTF_LGenBase_doTrafficCaseTimerAction), |
| {pl_tcIdx}, |
| v_LGenBase_trafficCases[pl_tcIdx].schedulingTimer)) { |
| f_EPTF_LGenBase_loggingError(%definitionId&" Can not schedule timer event to delay the start of the traffic case ."); |
| f_EPTF_Base_stop(); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startLaunchWeightedScenario |
| // |
| // Purpose: |
| // Initializes and starts a traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startLaunchWeightedScenario( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx, |
| in boolean pl_checkRunningState := true) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Start weighted scenario "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].name |
| & " of group " & v_LGenBase_entityGroups[pl_eGrpIdx].name); |
| f_EPTF_Base_assert(%definitionId&": The scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName&" is not weighted.", |
| f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scInGrpIdx)) |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.lastBurstSize := 0; |
| f_EPTF_LGenBase_adjustSchedulerData4NewCps( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData) |
| |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation; |
| |
| var EPTF_LGenBase_tcState vl_scStatePrev := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].state; |
| if(pl_checkRunningState and |
| c_EPTF_LGenBase_tcStatePaused != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateStopped != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateAborted != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateIdle != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateTerminated != vl_scStatePrev){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Start launch called for weighted scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName& |
| " in state "&c_EPTF_LGenBase_stateNames[vl_scStatePrev]& |
| "\nThe command can not be executed."); |
| if(c_EPTF_LGenBase_tcStateRunning != vl_scStatePrev or |
| -1 != v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer){ |
| return |
| } |
| } |
| if(not v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].enabled){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Start launch called for the disabled scenario "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName); |
| return; |
| } |
| if(c_EPTF_LGenBase_tcStateStopped == vl_scStatePrev or |
| c_EPTF_LGenBase_tcStateAborted == vl_scStatePrev or |
| c_EPTF_LGenBase_tcStateTerminated == vl_scStatePrev) { |
| var boolean vl_ret := f_EPTF_LGenBase_restoreScenarioByIdx(pl_eGrpIdx, pl_scInGrpIdx, false); |
| // f_EPTF_LGenBase_restoreScenarioByIdx should fail only if the scenario is running. |
| f_EPTF_Base_assert(%definitionId&": restore scenario failed. eGrpIdx: " & int2str(pl_eGrpIdx) & |
| ", scInGrpIdx: " & int2str(pl_scInGrpIdx) & ", scState: " &int2str(vl_scStatePrev), vl_ret); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": generating new traffic mix."); |
| if(f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scInGrpIdx)) |
| { |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(pl_eGrpIdx,pl_scInGrpIdx), |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| } |
| } |
| |
| var float vl_now := T_EPTF_componentClock.read; |
| var boolean vl_paused := c_EPTF_LGenBase_tcStatePaused == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].state; |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList[vl_tc]; |
| if(v_LGenBase_trafficCases[vl_tcIdx].enabled){ |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStateRunning; |
| |
| //TR: MTTSM00016010 |
| if(c_EPTF_LGenBase_tcStatePaused != vl_scStatePrev) { |
| v_LGenBase_trafficCases[vl_tcIdx].startTime := vl_now; |
| f_EPTF_LGenBase_startExecTimeTimer(vl_tcIdx); // starts execTime timer if needed, not part of the TR correction |
| } |
| //~TR |
| |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation; |
| if(not vl_paused){ |
| Inc(v_LGenBase_entityGroups[v_LGenBase_trafficCases[vl_tcIdx].eGroupBackref].scenarios[v_LGenBase_trafficCases[vl_tcIdx].eScenarioBackRef].startedTcs); |
| f_EPTF_LGenBase_resetTcStats(vl_tcIdx, v_LGenBase_trafficCases[vl_tcIdx]); |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_trafficCaseStarted, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {vl_tcIdx} |
| }); |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_tcStartedOrStoppedCallbacks) ; vl_i := vl_i+1 ) |
| { |
| v_LGenBase_tcStartedOrStoppedCallbacks[vl_i].apply( vl_tcIdx, true ); |
| } |
| f_EPTF_LGenBase_tcStateChanged(vl_tcIdx); |
| } |
| } |
| } |
| if(originating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].trafficType and |
| ischosen(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.target.cpsToReach) and |
| 0.0 < v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.target.cpsToReach){ |
| // set different start time for different LGens => smooth out synchronous call generation (far small CPS): |
| var float vl_stTrafficCorrigation := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation/v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.target.cpsToReach; |
| // if event is not scheduled, schedule it: |
| if(-1 == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer and |
| not f_EPTF_SchedulerComp_scheduleAction( |
| vl_now/*+vl_stTimeDelay*/+vl_stTrafficCorrigation, |
| refers(f_EPTF_LGenBase_doWeightedScenarioTimerAction), |
| {pl_eGrpIdx,pl_scInGrpIdx}, |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer)) { |
| f_EPTF_LGenBase_loggingError(%definitionId&" Can not schedule scenario timer event."); |
| } |
| } |
| f_EPTF_LGenBase_setScNewState(pl_eGrpIdx, pl_scInGrpIdx, c_EPTF_LGenBase_tcStateRunning); |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_pauseWeightedScenario |
| // |
| // Purpose: |
| // Initializes and starts a traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_pauseWeightedScenario( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Pausing weighted weighted scenario "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].name |
| & " of group " & v_LGenBase_entityGroups[pl_eGrpIdx].name); |
| if (v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer>-1) { |
| f_EPTF_LGenBase_stopScTimerInternal(pl_eGrpIdx,pl_scInGrpIdx); |
| } |
| f_EPTF_LGenBase_setScNewState(pl_eGrpIdx, pl_scInGrpIdx, c_EPTF_LGenBase_tcStatePaused); |
| |
| // MTTSM00016748 - if a traffic case is finished (launchFinish) while the scenario is paused but there are still active TCs, |
| // checkTcState would put the scenario state back to "Running" (without re-starting the timer-action) |
| // fix: also set the state of the TCs to "Paused" |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList[vl_tc]; |
| if(v_LGenBase_trafficCases[vl_tcIdx].state == c_EPTF_LGenBase_tcStateRunning){ |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStatePaused; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_pauseScenario |
| // |
| // Purpose: |
| // Hangs up running the scenario |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_pauseScenario( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(terminating == v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].trafficType){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Abort called for terminating scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName& |
| ". The feature is not implemented yet."); |
| return; |
| } |
| for ( var integer vl_tc := 0; vl_tc < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList) ; vl_tc := vl_tc+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].tcIdxList[vl_tc]; |
| if(-1 != v_LGenBase_trafficCases[vl_tcIdx].schedulingTimer and |
| originating == v_LGenBase_trafficCases[vl_tcIdx].trafficType){ |
| f_EPTF_LGenBase_pauseTrafficCaseByIdx(vl_tcIdx); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_pauseTrafficCase |
| // |
| // Purpose: |
| // Stops the periodic timer events of a traffic case and sets its |
| // state to Paused |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_pauseTrafficCase( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| //Remove next timer event, if exists |
| f_EPTF_LGenBase_pauseTrafficCaseByIdx(vl_tcIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_pauseTrafficCaseByIdx |
| // |
| // Purpose: |
| // Stops the periodic timer events of a traffic case and sets its |
| // state to Paused |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_pauseTrafficCaseByIdx( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",pl_tcIdx > -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| } |
| if(terminating == v_LGenBase_trafficCases[pl_tcIdx].trafficType){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Pause called for terminating tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName& |
| ". The feature is not implemented yet."); |
| return; |
| } |
| var EPTF_LGenBase_tcState vl_statePrev := v_LGenBase_trafficCases[pl_tcIdx].state; |
| if(c_EPTF_LGenBase_tcStateRunning != vl_statePrev){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Pause called for tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" in state "&c_EPTF_LGenBase_stateNames[vl_statePrev]); |
| return; |
| } |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref; |
| var integer vl_scIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef; |
| if (f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) { |
| v_LGenBase_trafficCases[pl_tcIdx].enabled := false; |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| } else { |
| //Remove next timer event, if exists |
| if(not f_EPTF_LGenBase_stopTcTimerInternal(v_LGenBase_trafficCases[pl_tcIdx])) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Could not stop traffic case timer for traffic case "& v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStatePaused; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resumeTrafficCaseByIdx |
| // |
| // Purpose: |
| // Resumes a traffic case after <f_EPTF_LGenBase_pauseTrafficCaseByIdx> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_resumeTrafficCaseByIdx( |
| in integer pl_tcIdx |
| ) runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index.",pl_tcIdx > -1 and pl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| } |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Resume traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref; |
| var integer vl_scIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef; |
| if(f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) { |
| v_LGenBase_trafficCases[pl_tcIdx].enabled := true; |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateRunning; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| } else { |
| f_EPTF_LGenBase_startLaunchTC(pl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startEntity |
| // |
| // Purpose: |
| // Starts a traffic on the entity of a traffic case |
| // |
| // Return Value: |
| // Returns false if the entity is busy |
| // |
| // Detailed Comments: |
| // Calls the <f_EPTF_LGenBase_doStartStep> function |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_startEntity( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in integer pl_eRelIdx, |
| in boolean pl_dispatchStartEvent := true |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_tcIdx := f_EPTF_LGenBase_trafficCaseId(pl_eGrpName, pl_scName, pl_tcName); |
| return f_EPTF_LGenBase_doStartStep(pl_eRelIdx, vl_tcIdx, pl_dispatchStartEvent) |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_createTc2EntityGroup |
| // |
| // Purpose: |
| // Creates a specimen of traffic case to the entity group |
| // and initializes it. |
| // |
| // Detailed Comments: |
| // The finish actions will be empty after executing the function. |
| // They must be filled from its caller <f_EPTF_LGenBase_createScenario2EntityGroup> |
| // function after all the traffic cases had been created. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_createTc2EntityGroup( |
| in EPTF_LGenBase_TcOfScenarioInternalDeclarator pl_tcDecl, |
| in integer pl_eGrpIdx, |
| in integer pl_scIdxInGrp, |
| inout EPTF_LGenBase_ScenarioOfGrp pl_sc) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| var EPTF_LGenBase_TcDescriptor vl_tc := c_EPTF_LGenBase_TcMgmt_emptytcDescriptor; |
| var integer vl_newTcIdx := sizeof(v_LGenBase_trafficCases); |
| vl_tc.privateName := pl_tcDecl.tcPrivateName; |
| vl_tc.tcTypeIdx := f_EPTF_LGenBase_tcTypeNameIndex(pl_tcDecl.tcTypeName); |
| if(-1 != vl_tc.tcTypeIdx){ |
| //Check behavior types |
| //TODO Test it |
| if(v_LGenBase_entityGroups[pl_eGrpIdx].eTypeIdx != v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].entityTypeIdx and |
| not f_EPTF_LGenBase_areETypesCompatible(v_LGenBase_entityGroups[pl_eGrpIdx].eTypeIdx, v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].entityTypeIdx)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": Incompatible entity types in tc "&v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].name& |
| " and entity group "&v_LGenBase_entityGroups[pl_eGrpIdx].name&"!"); |
| } |
| vl_tc.fsmIdx := v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].fsmIdx; |
| //Compared with the TC type FSM in f_EPTF_LGenBase_validateScenarioType |
| vl_tc.fsmList[0].fsmTypeIdx := vl_tc.fsmIdx; |
| vl_tc.fsmList[0].siblingName := v_LGenBase_fsmTables[v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].fsmIdx].name |
| vl_tc.customEntitySuccPrev := v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].customEntitySuccPrev; |
| vl_tc.customEntitySucc2 := v_LGenBase_trafficCaseTypes[vl_tc.tcTypeIdx].customEntitySucc2; |
| } |
| //customEntitySuccPrev can be declared only in tc type, but |
| //customEntitySucc2 can be declared even as a tcParam |
| if("" != pl_tcDecl.customEntitySucc){ |
| var EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup2_FT vl_prev := vl_tc.customEntitySucc2; |
| f_EPTF_LGenBase_getCustomEntitySuccFn(pl_tcDecl.customEntitySucc, vl_tc.customEntitySucc2); |
| if(null != vl_prev and vl_tc.customEntitySucc2 != vl_prev){ |
| f_EPTF_LGenBase_loggingError(%definitionId& |
| ": The entity success calculation function of traffic case "&vl_tc.uniqueName& |
| " is defined in both the traffic case description and its type declaration, and they are different.") |
| } |
| } |
| for ( var integer vl_fsm := 0; vl_fsm < sizeof(pl_tcDecl.fsmList) ; vl_fsm := vl_fsm+1 ) { |
| vl_tc.fsmList[vl_fsm].fsmTypeIdx := pl_tcDecl.fsmList[vl_fsm].fsmTypeIndex |
| vl_tc.fsmList[vl_fsm].siblingName := pl_tcDecl.fsmList[vl_fsm].siblingName |
| } |
| vl_tc.eGroupBackref := pl_eGrpIdx; //back-reference to the entity group that owns this descriptor |
| vl_tc.eScenarioBackRef := pl_scIdxInGrp; //The index of the scenario of the tc in the entity group |
| vl_tc.eTcRelIdx := sizeof(pl_sc.tcIdxList); |
| vl_tc.schedulerData.target := pl_tcDecl.target; //EGBOZIE:cps or weight |
| vl_tc.templateSetIdx := f_EPTF_LGenBase_initTemplateSet(pl_tcDecl.templateSet); |
| vl_tc.trafficType := pl_sc.trafficType |
| if (originating == vl_tc.trafficType and ischosen(vl_tc.schedulerData.target.cpsToReach)) { |
| f_EPTF_LGenBase_adjustSchedulerData4NewCps(vl_tc.schedulerData); |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| vl_tc.schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_eGrpIdx].trafficCorrigation; |
| } |
| vl_tc.entityInfo := c_EPTF_LGenBase_emptyEntityInfo; |
| if(ispresent(pl_tcDecl.entitySelection)) { |
| vl_tc.entityInfo.entitySelection := pl_tcDecl.entitySelection; |
| } else { |
| vl_tc.entityInfo.entitySelection := round_robin; |
| } |
| vl_tc.startDelay := pl_tcDecl.startDelay; |
| |
| vl_tc.schedulingTimer := -1; //event queue Idx of the traffic-start peridodic event |
| vl_tc.enableEntitiesAtStartup := pl_tcDecl.enableEntities or terminating == vl_tc.trafficType; |
| vl_tc.enabledAtStartup := pl_tcDecl.enable; |
| vl_tc.v_sizeofRanges := sizeof(pl_tcDecl.ranges); |
| //f_EPTF_LGenBase_initTCInternal(vl_tc, vl_newTcIdx, pl_tcDecl.enableEntities, true); |
| vl_tc.enabled := pl_tcDecl.enable; |
| |
| vl_tc.uniqueName := f_EPTF_LGenBaseStats_getTCName(v_LGenBase_entityGroups[pl_eGrpIdx].name,pl_sc.name, vl_tc.privateName); |
| vl_tc.paramHashMap := f_EPTF_str2int_HashMap_New(vl_tc.uniqueName&c_EPTF_LGenBase_tcParamsHasmapPostfix); |
| //Book in traffic case specimen list |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugConfig)){ |
| f_EPTF_LGenBase_loggingDebugConfig(log2str(%definitionId&": ",vl_tc)) |
| } |
| v_LGenBase_trafficCases[vl_newTcIdx] := vl_tc; |
| //Initialize |
| f_EPTF_LGenBase_initTCInternal(v_LGenBase_trafficCases[vl_newTcIdx], vl_newTcIdx, vl_tc.enableEntitiesAtStartup, true); |
| //Book in entity group's scenario |
| pl_sc.tcIdxList[vl_tc.eTcRelIdx] := vl_newTcIdx; |
| |
| // setting burst calc method for every traffic cases |
| var charstring vl_burstName := ""; |
| if(ispresent(pl_tcDecl.scheduler)) // setting scheduler by traffic case config parameter |
| { |
| vl_burstName := pl_tcDecl.scheduler; |
| } else { // setting scheduler by global parameter |
| if("" != v_LGenBase_burstCalcMode) { |
| vl_burstName := v_LGenBase_burstCalcMode; |
| } else { |
| f_EPTF_Base_assert(%definitionId&"No Global or Local burst calculation method is set.",false); |
| } |
| } |
| var integer vl_burstId; |
| vl_burstId := f_EPTF_LGenBase_getBurstCalcFunctionId(vl_burstName); |
| if(vl_burstId != -1) { |
| f_EPTF_LGenBase_setBurstCalcAlgInternal(vl_burstId, vl_newTcIdx, false); |
| } else { |
| //TODO Test it |
| f_EPTF_LGenBase_loggingError(%definitionId&"No calculation method is set with this name."); |
| } |
| |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&log2str(vl_tc)) |
| } |
| return vl_newTcIdx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_TrafficStartFinishConditions_2int |
| // |
| // Purpose: |
| // converts the <EPTF_LGenBase_TrafficStartFinishConditions> enum value to integer |
| // |
| // Detailed Comments: |
| // introduced to avoid using unnecessary valueof, example: |
| // vl_counters[enum2int(valueof(EPTF_LGenBase_TrafficStartFinishConditions:nrOfExecStart))] |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_TrafficStartFinishConditions_2int(in EPTF_LGenBase_TrafficStartFinishConditions pl_enumVal) |
| runs on EPTF_LGenBase_Private_CT return integer{ |
| return enum2int(pl_enumVal); |
| } |
| |
| } //StartStop |
| |
| /////////////////////////////////////////////////////////// |
| // Group: EnableDisable |
| // |
| // Purpose: |
| // Functions to enable and disable entities, traffic cases and scenarios |
| /////////////////////////////////////////////////////////// |
| group EnableDisable{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_enableScenarioOnEntityGroup |
| // |
| // Purpose: |
| // Enables a scenario on an Entity Group and optonally starts |
| // |
| // Detailed Comments: |
| // This function creates the |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_enableScenarioOnEntityGroup( |
| in integer pl_eGrpIdx, //entity group |
| in integer pl_scIdxInGrp, //scenario index in group |
| in boolean pl_autoStart := true) |
| runs on EPTF_LGenBase_Private_CT{ |
| var EPTF_LGenBase_tcState vl_scStatePrev := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].state; |
| if(c_EPTF_LGenBase_tcStatePaused != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateStopped != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateAborted != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateIdle != vl_scStatePrev and |
| c_EPTF_LGenBase_tcStateTerminated != vl_scStatePrev){ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Start launch called for scenario "& |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].uniqueName& |
| " in state "&c_EPTF_LGenBase_stateNames[vl_scStatePrev]); |
| return; |
| } |
| if(pl_autoStart){ |
| var integer vl_scAbsIdx := f_EPTF_LGenBase_scenarioAbsIdx(pl_eGrpIdx, pl_scIdxInGrp) |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_scenarioStarted, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_eGrpIdx, pl_scIdxInGrp, vl_scAbsIdx} |
| }); |
| } |
| var integer vl_tcCount := sizeof( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].tcIdxList); |
| for(var integer vl_i := 0; vl_i < vl_tcCount; vl_i := vl_i + 1){ |
| if ( v_LGenBase_trafficCases[ |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].tcIdxList[vl_i]].enabled or |
| terminating == v_LGenBase_trafficCases[ |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].tcIdxList[vl_i]].trafficType) |
| { |
| f_EPTF_LGenBase_enableTrafficCaseInternal( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].tcIdxList[vl_i], pl_autoStart); |
| } |
| else |
| { |
| f_EPTF_LGenBase_disableTrafficCaseInternal( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].tcIdxList[vl_i]); |
| } |
| |
| } |
| if (pl_autoStart and ispresent(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdxInGrp].weightedScData)) |
| {//EGBOZIE: new for weighted sc. |
| f_EPTF_LGenBase_startLaunchWeightedScenario(pl_eGrpIdx,pl_scIdxInGrp,false) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_enableEntityInTrafficCase |
| // |
| // Purpose: |
| // Enables an entity in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_enableEntityInTrafficCase( |
| in integer pl_tcIdx, |
| in integer pl_eRelIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Enable entity #"&int2str(pl_eRelIdx)&" in traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| //HN33148 Unnecessary warning removed |
| //HN15601 |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eRelIdx].disabled := false; |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eRelIdx].finished){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Enable finished entity #"&int2str(pl_eRelIdx)&" in traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| return; |
| } |
| if(not v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eRelIdx].isRunning){ |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| if(f_EPTF_FBQ_itemIsBusy(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq)){ |
| //Not running, not finished, busy -> disabled |
| f_EPTF_FBQ_moveFromBusyToFreeTail(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq); |
| Inc(v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| } |
| } else { |
| if(f_EPTF_RNA_itemIsBusy(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna)){ |
| //Not running, not finished, busy -> disabled |
| if(not f_EPTF_RNA_moveFromBusyToFreeSlot(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromBusyToFreeSlot",false) |
| } |
| Inc(v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_disableEntityInTrafficCase |
| // |
| // Purpose: |
| // Disables an entity in the traffic case |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_disableEntityInTrafficCase( |
| in integer pl_tcIdx, |
| in integer pl_eRelIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Disable entity #"&int2str(pl_eRelIdx)&" in traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| //HN15601 |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eRelIdx].disabled := true; |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eRelIdx].finished){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Disable finished entity #"&int2str(pl_eRelIdx)&" in traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| return; |
| } |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| if(f_EPTF_FBQ_itemIsFree(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq)){ |
| f_EPTF_FBQ_moveFromFreeToBusyTail(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq); |
| Dec(v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| SetIfLt(v_LGenBase_trafficCases[pl_tcIdx].minAvailable, v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| SetIfGt(v_LGenBase_trafficCases[pl_tcIdx].maxBusy,f_EPTF_FBQ_getLengthOfBusyChain(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq)); |
| } |
| } else { |
| if(f_EPTF_RNA_itemIsFree(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna)){ |
| if(not f_EPTF_RNA_moveFromFreeToBusySlot(pl_eRelIdx, v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromFreeToBusySlot",false) |
| } |
| Dec(v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| SetIfLt(v_LGenBase_trafficCases[pl_tcIdx].minAvailable, v_LGenBase_trafficCases[pl_tcIdx].nrOfAvailableEntities); |
| SetIfGt(v_LGenBase_trafficCases[pl_tcIdx].maxBusy,f_EPTF_RNA_getLengthOfBusyList(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna)); |
| } |
| } |
| } |
| }//EnableDisable |
| |
| /////////////////////////////////////////////////////////// |
| // Group: EvaluateSuccess4EntityAtEntityGroupFunctions |
| // |
| // Purpose: |
| // Predefined methods to return the new state of the entity after a traffic |
| /////////////////////////////////////////////////////////// |
| group EvaluateSuccess4EntityAtEntityGroupFunctions{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_successSucNoFail |
| // |
| // Purpose: |
| // This preregistered function returns pass if the entity had |
| // never reported failed finish of any traffic. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_successSucNoFail( |
| in integer pl_tcIdx, |
| in integer pl_eIdxInTc, |
| in boolean pl_lastSuccess |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_EntityState{ |
| var EPTF_LGenBase_EntityItem vl_dataidx := v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eIdxInTc]; |
| if(0 == vl_dataidx.nrOfSuccesses and 0 == vl_dataidx.nrOfFails and |
| 0 == vl_dataidx.nrOfErrors and 0 == vl_dataidx.nrOfTimeouts){ |
| return none; |
| }else{ |
| if(0 == vl_dataidx.nrOfFails and 0 == vl_dataidx.nrOfErrors and 0 == vl_dataidx.nrOfTimeouts){ |
| return pass; |
| } |
| return fail; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_successIfOnceSuccess |
| // |
| // Purpose: |
| // This preregistered function returns pass if the entity had |
| // reported successful finish of a traffic at least once. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_successIfOnceSuccess( |
| in integer pl_tcIdx, |
| in integer pl_eIdxInTc, |
| in boolean pl_lastSuccess |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_EntityState{ |
| if(0 < v_LGenBase_trafficCases[pl_tcIdx].entityInfo.itemList[pl_eIdxInTc].nrOfSuccesses){ |
| return pass; |
| } |
| return fail; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_successIfLastSuccess |
| // |
| // Purpose: |
| // This preregistered function returns pass if the last traffic on the |
| // entity successfully finished. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_successIfLastSuccess( |
| in integer pl_tcIdx, |
| in integer pl_eIdxInTc, |
| in boolean pl_lastSuccess |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_EntityState{ |
| if(pl_lastSuccess){ |
| return pass; |
| } |
| return fail; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Group: ObsoleteFunctions |
| // |
| // Purpose: |
| // The obsolete functions of the EPTF_LGenBase TrafficFunctions feature |
| // Please try not to use them. |
| // |
| /////////////////////////////////////////////////////////// |
| group ObsoleteFunctions{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setBurstCalcMode |
| // |
| // Purpose: |
| // Sets the method of bust calculation |
| // |
| // Parameters: |
| // pl_EPTF_LGenBase_burstFunc - *in* <EPTF_LGenBase_burstFunc> - The type of method of bust calculation |
| // |
| // Return Value: |
| // If there is a running traffic case, returns false. |
| // |
| // Errors & assertions: |
| // - The method must not be "userDefined". |
| // |
| // Detailed Comments: |
| // If there is a running traffic case, the burst calculation method can not be |
| // set, then the function returns false, and does nothing. |
| // The method must be one of the valid predefined values. |
| // Note: This function is obsoleted. Use <f_EPTF_LGenBase_setBurstCalcAlgByName> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setBurstCalcMode( |
| in EPTF_LGenBase_burstFunc pl_EPTF_LGenBase_burstFunc) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": This is an obsolete function. Use f_EPTF_LGenBase_setBurstCalcAlgByName."); |
| |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_trafficCases) ; vl_i := vl_i+1 ) |
| { |
| if(-1 != v_LGenBase_trafficCases[vl_i].schedulingTimer){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"The "&v_LGenBase_trafficCases[vl_i].uniqueName&" traffic case is a running. The burst calculation method can not be set."); |
| return false |
| } |
| } |
| v_LGenBase_burstCalcMode := f_EPTF_LGenBase_BurstFuncName2Char(pl_EPTF_LGenBase_burstFunc); |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setBurstCalcFunctions |
| // |
| // Purpose: |
| // Sets the bust calculation functions |
| // |
| // Return Value: |
| // If there is a running traffic case, returns false. |
| // |
| // Errors & assertions: |
| // - The method must not be "userDefined" |
| // |
| // Detailed Comments: |
| // If the predefined calculation methodes don't fit requirements, users can write their own methods. |
| // If there is a running traffic case, the burst calculation method can not be |
| // set, then the function returns false, and does nothing. |
| // Function sets the burst calculation method to "userDefined". |
| // Note: This function is obsoleted. Use <f_EPTF_LGenBase_setBurstCalcAlgByName> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setBurstCalcFunctions( |
| in EPTF_LGenBase_burstPreCalc_FT pl_preFunc, |
| in EPTF_LGenBase_burstPostCalc_FT pl_postFunc) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": This is an obsolete function. Use f_EPTF_LGenBase_setBurstCalcAlgByName."); |
| |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_trafficCases) ; vl_i := vl_i+1 ) |
| { |
| if(-1 != v_LGenBase_trafficCases[vl_i].schedulingTimer){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"The "&v_LGenBase_trafficCases[vl_i].uniqueName&" traffic case is a running. The burst calculation method can not be set."); |
| return false |
| } |
| } |
| v_LGenBase_dummyInt := f_EPTF_LGenBase_addBurstCalcFunction("userDefined",pl_preFunc,pl_postFunc); |
| v_LGenBase_burstCalcMode := "userDefined"; |
| return true; |
| } |
| |
| |
| } //group ObsoleteFunctions |
| |
| /////////////////////////////////////////////////////////// |
| // Group: PrivateFunctions |
| // |
| // Purpose: |
| // The private functions of the EPTF_LGenBase feature |
| // Don't use them from outside of EPTF_LGenBase |
| // |
| /////////////////////////////////////////////////////////// |
| group PrivateFunctions{ |
| group conditionsAndActions{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_checkGroupFinishConditionFired |
| // |
| // Purpose: |
| // Filters the finish conditions already fired |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_checkGroupFinishConditionFired( |
| in EPTF_LGenBase_ConditionTrue pl_fired, |
| in EPTF_LGenBase_ConditionTrue pl_source, |
| out EPTF_LGenBase_ConditionTrue pl_dest) |
| runs on EPTF_LGenBase_Private_CT{ |
| pl_dest := c_EPTF_LGenBase_emptyConditionTrue |
| pl_dest.nrOfExecStart := pl_source.nrOfExecStart and not pl_fired.nrOfExecStart |
| pl_dest.nrOfSuccesses := pl_source.nrOfSuccesses and not pl_fired.nrOfSuccesses |
| pl_dest.nrOfFails := pl_source.nrOfFails and not pl_fired.nrOfFails |
| pl_dest.nrOfErrors := pl_source.nrOfErrors and not pl_fired.nrOfErrors |
| pl_dest.nrOfTimeouts := pl_source.nrOfTimeouts and not pl_fired.nrOfTimeouts |
| pl_dest.nrOfRangeLoop := pl_source.nrOfRangeLoop and not pl_fired.nrOfRangeLoop |
| pl_dest.execTime := pl_source.execTime and not pl_fired.execTime |
| pl_dest.entitiesFinished := pl_source.entitiesFinished and not pl_fired.entitiesFinished |
| pl_dest.availableEntitiesFinished := pl_source.availableEntitiesFinished and not pl_fired.availableEntitiesFinished |
| pl_dest.customFinishCondition := pl_source.customFinishCondition and not pl_fired.customFinishCondition |
| pl_dest.anythingFinished := pl_source.anythingFinished and not pl_fired.anythingFinished |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": New finish conditions: "&log2str(pl_dest)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_checkGroupFinishConditionFiredAny |
| // |
| // Purpose: |
| // Checks if any of the finish conditions given in the pl_source are true |
| // Ignores anythingFinished |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_checkGroupFinishConditionFiredAny( |
| in EPTF_LGenBase_ConditionTrue pl_source |
| ) return boolean { |
| return pl_source.nrOfExecStart |
| or pl_source.nrOfSuccesses |
| or pl_source.nrOfFails |
| or pl_source.nrOfErrors |
| or pl_source.nrOfTimeouts |
| or pl_source.nrOfRangeLoop |
| or pl_source.execTime |
| or pl_source.entitiesFinished |
| or pl_source.availableEntitiesFinished |
| or pl_source.customFinishCondition |
| //or pl_source.anythingFinished |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setGroupFinishConditionFired |
| // |
| // Purpose: |
| // Registers the finish conditions fired |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_setGroupFinishConditionFired( |
| in EPTF_LGenBase_ConditionTrue pl_source, |
| inout EPTF_LGenBase_ConditionTrue pl_dest) |
| runs on EPTF_LGenBase_Private_CT{ |
| pl_dest.nrOfExecStart := pl_dest.nrOfExecStart or pl_source.nrOfExecStart |
| pl_dest.nrOfSuccesses := pl_dest.nrOfSuccesses or pl_source.nrOfSuccesses |
| pl_dest.nrOfFails := pl_dest.nrOfFails or pl_source.nrOfFails |
| pl_dest.nrOfErrors := pl_dest.nrOfErrors or pl_source.nrOfErrors |
| pl_dest.nrOfTimeouts := pl_dest.nrOfTimeouts or pl_source.nrOfTimeouts |
| pl_dest.nrOfRangeLoop := pl_dest.nrOfRangeLoop or pl_source.nrOfRangeLoop |
| pl_dest.execTime := pl_dest.execTime or pl_source.execTime |
| pl_dest.entitiesFinished := pl_dest.entitiesFinished or pl_source.entitiesFinished |
| pl_dest.availableEntitiesFinished := pl_source.availableEntitiesFinished or pl_source.availableEntitiesFinished |
| pl_dest.customFinishCondition := pl_dest.customFinishCondition or pl_source.customFinishCondition |
| pl_dest.anythingFinished := pl_dest.anythingFinished or pl_source.anythingFinished |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_execFinishActions |
| // |
| // Purpose: |
| // Executes the group finish actions of a traffic case |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_execFinishActions( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_ConditionTrue pl_conditions := c_EPTF_LGenBase_emptyConditionTrue) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Finish conditions to be executed: "&log2str(pl_conditions)); |
| } |
| f_EPTF_LGenBase_setGroupFinishConditionFired( |
| pl_conditions, |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionProcessed); |
| if( pl_conditions.customFinishCondition and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.customFinishConditionFuncRef) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.customFinishConditionFuncRef.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.customFinishConditionFuncRef.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.entitiesFinished and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.entitiesFinished) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.entitiesFinished.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.entitiesFinished.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.availableEntitiesFinished and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.availableEntitiesFinished) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.availableEntitiesFinished.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.availableEntitiesFinished.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.execTime and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.execTime) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.execTime.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.execTime.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfExecStart and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfFails and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfErrors and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfTimeouts and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfRangeLoop and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.nrOfSuccesses and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.actions, |
| pl_tcIdx) |
| } |
| if( pl_conditions.anythingFinished and |
| ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.anythingFinished) and |
| 0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.anythingFinished.actions)){ |
| f_EPTF_LGenBase_execGroupActions( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.anythingFinished.actions, |
| pl_tcIdx) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startExecTimeTimer |
| // |
| // Purpose: |
| // Starts an "execution time expired" event if needed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_startExecTimeTimer(in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| // there is no need for execTime timer setting, quit |
| if ( not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.execTime) or |
| not v_LGenBase_groupFinishConditionMask.execTime ) { return; } |
| |
| // cancel event if it is running: |
| if (v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer != -1) { |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling execTime timer failed."); |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer := -1; |
| } |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| v_LGenBase_trafficCases[pl_tcIdx].startTime + v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.execTime.time, |
| refers(f_EPTF_LGenBase_handleExecTimeExpired), |
| {pl_tcIdx}, // EPTF_ScheduledAction |
| v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer)) |
| { |
| f_EPTF_LGenBase_loggingError(%definitionId&": Can not schedule timer event."); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_handleExecTimeExpired |
| // |
| // Purpose: |
| // When the "execution time expired" event arrives this function handles it. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_handleExecTimeExpired( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer pl_tcIdx := pl_action.actionId[0]; |
| v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer := -1; |
| var EPTF_LGenBase_ConditionTrue pl_execTimeFired := c_EPTF_LGenBase_emptyConditionTrue; |
| pl_execTimeFired.execTime := true; |
| pl_execTimeFired.anythingFinished := true; |
| |
| f_EPTF_LGenBase_groupFinishedDetected(pl_tcIdx, pl_execTimeFired); |
| return true; // needed because this function is an actionHandler, must return boolean |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Group: PrivatePredefinedBurstCal |
| // |
| // Purpose: |
| // The predefined burst calculation functions |
| // |
| /////////////////////////////////////////////////////////// |
| group PrivatePredefinedBurstCal{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_BurstCalc_init |
| // |
| // Purpose: |
| // Stores predefined burst calculation functions in the list of LGenBase |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // *boolean* |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_BurstCalc_init() |
| runs on EPTF_LGenBase_Private_CT |
| { |
| //FIXME The terminating needs own pre/post functions |
| var integer vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_terminating,refers(f_EPTF_LGenBase_burstPreCalcCS),refers(f_EPTF_LGenBase_burstPostCalcOrig)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_terminating , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_terminating ) |
| vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_orig,refers(f_EPTF_LGenBase_burstPreCalcCS),refers(f_EPTF_LGenBase_burstPostCalcOrig)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_orig , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_orig ) |
| vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_imst,refers(f_EPTF_LGenBase_burstPreCalcCS),refers(f_EPTF_LGenBase_burstPostCalcOrig)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_imst , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_imst ) |
| vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_imst2,refers(f_EPTF_LGenBase_burstPreCalcCS),refers(f_EPTF_LGenBase_burstPostCalcOrig)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_imst2 , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_imst2 ) |
| vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_cs,refers(f_EPTF_LGenBase_burstPreCalcCS),refers(f_EPTF_LGenBase_burstPostCalcOrig)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_cs , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_cs ) |
| vl_temp := f_EPTF_LGenBase_addBurstCalcFunction(c_EPTF_LGenBase_BurstCalc_poisson,refers(f_EPTF_LGenBase_burstPreCalcPoisson),refers(f_EPTF_LGenBase_burstPostCalcPoisson)); |
| f_EPTF_Base_assert(%definitionId&" Error registering the burst calculation function "&c_EPTF_LGenBase_BurstCalc_poisson , vl_temp == c_EPTF_LGenBase_BurstCalcFnIdx_poisson ) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setBurstCalcAlgInternal |
| // |
| // Purpose: |
| // Internal function for setting Burst Function Reference for a traffic case |
| // |
| // Parameters: |
| // pl_burstIdx - *in* *integer* - The index of the burst function |
| // pl_idx - *in* - *integer* - traffic case index or a weighted scenario index |
| // pl_isWeighted - *in* - *boolean* - if the algorithm is assigned to a weighted scenario or a normal traffic case |
| // |
| // Return Value: |
| // *boolean* |
| // |
| // Detailed Comments: |
| // The function sets the burst calculation algorithm to a normal traffic case or a weighted scenario. |
| // If pl_isWeighted is true the algorithm is assigned to a weighted scenario. Default value is false. |
| // This internal function does not checks if the indexes are valid or the traffic case is running -> |
| // it is because when we initializing a scenario, the scenario indices are not set and we cannot check their validity. |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_setBurstCalcAlgInternal( |
| in integer pl_burstIdx, |
| in integer pl_tcIdx, //FIXME Sometimes tc idx, sometimes sc idx?! |
| in boolean pl_isWeighted := false) //FIXME this should be retrieved from the TC |
| runs on EPTF_LGenBase_Private_CT{ |
| |
| var integer vl_eGrpIdx; |
| var integer vl_scInGrpIdx; |
| |
| if(pl_isWeighted) { // weighted scenario |
| |
| f_EPTF_LGenBase_scenarioRelIdx(pl_tcIdx, vl_eGrpIdx, vl_scInGrpIdx); |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstCalcMode := v_LGenBase_burstFuncRefList[pl_burstIdx].burstCalcMode; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstPreCalc := v_LGenBase_burstFuncRefList[pl_burstIdx].burstPreCalc; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstPostCalc := v_LGenBase_burstFuncRefList[pl_burstIdx].burstPostCalc; |
| |
| } else { // normal traffic case |
| if(pl_tcIdx == -1){ |
| v_LGenBase_burstCalcMode := v_LGenBase_burstFuncRefList[pl_burstIdx].burstCalcMode; // setting component variable |
| } else { |
| v_LGenBase_trafficCases[pl_tcIdx].schedulerData.burstFuncRef.burstCalcMode := v_LGenBase_burstFuncRefList[pl_burstIdx].burstCalcMode; |
| v_LGenBase_trafficCases[pl_tcIdx].schedulerData.burstFuncRef.burstPreCalc := v_LGenBase_burstFuncRefList[pl_burstIdx].burstPreCalc; |
| v_LGenBase_trafficCases[pl_tcIdx].schedulerData.burstFuncRef.burstPostCalc := v_LGenBase_burstFuncRefList[pl_burstIdx].burstPostCalc; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPreCalcOrig |
| // |
| // Purpose: |
| // The burst precalculation function for EPTF traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_when - *in* - *float* - time of scheduled event |
| // pl_maxSend - *out* - *integer* - maximum number of send |
| // pl_nextCallTime - *out* - *float* - the next call time |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Obsolete function, calls the CS |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPreCalcOrig( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in float pl_when, |
| out integer pl_maxSend, |
| out float pl_nextCallTime) runs on EPTF_LGenBase_Private_CT |
| { |
| f_EPTF_LGenBase_burstPreCalcCS(pl_schData,pl_when,pl_maxSend,pl_nextCallTime) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPreCalcCS |
| // |
| // Purpose: |
| // The burst precalculation function for EPTF traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_when - *in* - *float* - time of scheduled event |
| // pl_maxSend - *out* - *integer* - maximum number of send |
| // pl_nextCallTime - *out* - *float* - the next call time |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPreCalcCS( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in float pl_when, |
| out integer pl_maxSend, |
| out float pl_nextCallTime) runs on EPTF_LGenBase_Private_CT |
| { |
| var float vl_currentBurstSizeAsFloat := int2float(pl_schData.currentBurstSize); |
| var integer vl_currentBurstSizeAsInt := float2int(vl_currentBurstSizeAsFloat) |
| var float vl_idealBurstSize := pl_schData.idealBurstSize |
| var integer vl_cumulativeBurstSize := 0; |
| //pl_schData.idealBurstSize := pl_schData.cpsToReach * pl_schData.roundedCpsUpdateInterval; |
| pl_nextCallTime := pl_when + pl_schData.roundedCpsUpdateInterval; |
| // Step#1: |
| // if we are late (i.e., timer lag grows beyond CpsUpdateInterval) |
| // or if last burst was less than ideal |
| if(pl_nextCallTime < f_EPTF_SchedulerComp_snapshotTime() or |
| vl_currentBurstSizeAsInt < float2int(vl_idealBurstSize) |
| ){ |
| f_EPTF_LGenBase_loggingDebugTraffic(log2str(%definitionId&": OVERLOAD DETECTED! vl_currentBurstSizeAsInt: ", vl_currentBurstSizeAsInt, " vl_idealBurstSize: ", float2int(vl_idealBurstSize) |
| , "pl_nextCallTime: ", pl_nextCallTime, " snapshotTime: ", f_EPTF_SchedulerComp_snapshotTime())); |
| // increase currentBurstSize towards the idealBurstSize: |
| // Overload factor: (f_EPTF_SchedulerComp_snapshotTime() - pl_when)/CpsUpdateInterval |
| // 0.0 ... 1.0 shall mean "full size burst", since burst is not delayed beyond the CpsUpdateInterval |
| // >1.0 means "reduced burst", since burst is delayed beyond the CpsUpdateInterval |
| // >2.0 means "no burst" |
| var float vl_TLag := f_EPTF_SchedulerComp_snapshotTime() - pl_when; |
| //if there have been not burst last time, then try to recover |
| //with a gradient of 2.0 |
| if (vl_currentBurstSizeAsFloat == 0.0) {vl_currentBurstSizeAsFloat := 1.0} |
| //currentBurstSize := currentBurstSize * (2 - vl_TLag / pl_schData.roundedCpsUpdateInterval); |
| if(0.0 != pl_schData.roundedCpsUpdateInterval){ |
| vl_currentBurstSizeAsFloat := vl_currentBurstSizeAsFloat * (2.0 - vl_TLag / pl_schData.roundedCpsUpdateInterval)+0.5; |
| |
| if (vl_currentBurstSizeAsFloat > pl_schData.idealBurstSize) { |
| vl_currentBurstSizeAsFloat := pl_schData.idealBurstSize; |
| } |
| if (vl_currentBurstSizeAsFloat < 1.0) { |
| vl_currentBurstSizeAsFloat := 1.0; |
| } |
| |
| }else{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": The function has been called when the CPS is 0.0!") |
| //Don't generate traffic |
| vl_currentBurstSizeAsFloat := 0.0 |
| } |
| vl_currentBurstSizeAsInt := float2int(vl_currentBurstSizeAsFloat+0.5) |
| pl_schData.currentBurstSize := vl_currentBurstSizeAsInt; |
| |
| //if nextCalltime is "in the past", then reset it to full interval into the future |
| if(pl_nextCallTime < f_EPTF_SchedulerComp_snapshotTime() ) { |
| pl_nextCallTime := f_EPTF_SchedulerComp_snapshotTime() +tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM; |
| // corrigate calls to generate, because extra time added to pl_nextCallTime (calls generated during tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM should be added): |
| if (pl_schData.roundedCpsUpdateInterval > 0.0) { |
| vl_currentBurstSizeAsInt := float2int(vl_currentBurstSizeAsFloat*(1.0+tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM/pl_schData.roundedCpsUpdateInterval)+0.5); |
| } |
| if(-1 < v_LGenBase_precalcTC){ |
| v_LGenBase_trafficCases[v_LGenBase_precalcTC].cpsOverrunCounter := v_LGenBase_trafficCases[v_LGenBase_precalcTC].cpsOverrunCounter + 1 |
| } |
| } |
| } else { |
| |
| // new_error := old_error + (ideal-actual) |
| var float vl_currentCumulativeBurstSizeError := pl_schData.burstSizeCumulativeError + |
| (vl_idealBurstSize - int2float(vl_currentBurstSizeAsInt)); |
| //cumulativeBurstSize is the integer part of the currentBurst + currentCumulativeBurstSizeError |
| vl_cumulativeBurstSize := float2int(vl_currentCumulativeBurstSizeError) |
| vl_currentCumulativeBurstSizeError :=vl_currentCumulativeBurstSizeError - int2float(vl_cumulativeBurstSize) |
| |
| pl_schData.burstSizeCumulativeError := vl_currentCumulativeBurstSizeError; |
| //pl_schData.currentBurstSize := vl_currentBurstSizeAsInt; // currentBurstSize is not changed here |
| } |
| |
| //set number to send |
| pl_maxSend := vl_currentBurstSizeAsInt + vl_cumulativeBurstSize; |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Scheduler data:"&log2str(pl_schData)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPreCalcPoisson |
| // |
| // Purpose: |
| // The burst precalculation function for poisson distribution traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_when - *in* - *float* - time of scheduled event |
| // pl_maxSend - *out* - *integer* - maximum number of send |
| // pl_nextCallTime - *out* - *float* - the next call time |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPreCalcPoisson( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in float pl_when, |
| out integer pl_maxSend, |
| out float pl_nextCallTime) runs on EPTF_LGenBase_Private_CT |
| { |
| var float vl_elementaryTimestep := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM; |
| var integer vl_notStarted := pl_schData.lastBurstSize; // not started traffic |
| var float vl_lastCallTime := pl_schData.roundedCpsUpdateInterval; // last exponential arriving time |
| pl_nextCallTime := vl_lastCallTime + tsp_EPTF_cpsUpdateInterval; // next exponential starting time |
| var integer vl_toStart := 0; // traffic to start |
| var float vl_lambda := pl_schData.target.cpsToReach * vl_elementaryTimestep; // lambda - expected cps in one elementary timestep |
| pl_maxSend := 0; |
| var boolean vl_success := false; |
| var integer vl_nrOfIntervals := 1; |
| var integer vl_nrOfTimeSteps := 1; |
| var float vl_scale := vl_elementaryTimestep; |
| |
| if(pl_schData.target.cpsToReach>0.0) { // cpsToReach should not be 0 because of logarithm statement. |
| |
| if(vl_lastCallTime == 0.0) { // if we call burst calculation at first time |
| vl_lastCallTime := pl_when; |
| } |
| |
| // overload protection: increase vl_lastCallTime if TLag is higher than 10 times the CPS update interval (to tolarate 10*CPS bursts) |
| var float vl_lastCpsUpdateInterval := vl_elementaryTimestep*10.0; // = 10 times the CPS update interval |
| var float vl_TLag := f_EPTF_SchedulerComp_snapshotTime() - pl_when; |
| if (vl_lastCpsUpdateInterval < vl_TLag) { |
| |
| var float vl_TLagFactor := vl_TLag / vl_lastCpsUpdateInterval - 1.0; |
| if (vl_TLagFactor>1.0) { |
| vl_TLagFactor := 1.0; |
| } |
| // increase vl_lastCallTime to decrease CPS: It reaches the snapshotTime+vl_elementaryTimestep when vl_TLag = 2.0*vl_lastCpsUpdateInterval |
| vl_lastCallTime := vl_lastCallTime + (f_EPTF_SchedulerComp_snapshotTime()+vl_elementaryTimestep-vl_lastCallTime)*vl_TLagFactor; |
| } |
| |
| |
| if(pl_schData.target.cpsToReach >= 20.0) { // if cps is big |
| // we calculate nr of starts according to the poisson table |
| |
| if((vl_lambda) >= 200.0) { // if lambda is large, we are scaleing down |
| vl_lambda := vl_lambda / 100.0; |
| vl_scale := vl_scale / 100.0; |
| } |
| if((vl_lambda) <= 2.0) { // if lambda is small, we are scaleing up |
| vl_lambda := vl_lambda * 10.0; |
| vl_scale := vl_scale * 10.0; |
| } |
| |
| vl_nrOfIntervals := float2int((f_EPTF_SchedulerComp_snapshotTime() - vl_lastCallTime) / vl_scale) + 1; |
| pl_nextCallTime := vl_lastCallTime + int2float(vl_nrOfIntervals) * vl_scale; |
| |
| for(var integer vl_i := 0; vl_i < vl_nrOfIntervals; vl_i := vl_i + 1){ // maybe more updateintervals passed |
| vl_toStart := vl_toStart + f_getNext_poissonValue(vl_lambda, pl_schData.poissonTable, vl_success); |
| } |
| } |
| |
| if(not(vl_success)) { // if cps is small or poisson calculating failed |
| // we calculate exponential starting times |
| vl_toStart := 1; |
| pl_nextCallTime := vl_lastCallTime + f_gen_Exponential_Distribution(pl_schData.target.cpsToReach); |
| while(pl_nextCallTime < (f_EPTF_SchedulerComp_snapshotTime() + vl_elementaryTimestep)) { // maybe more elementary timesteps passed |
| pl_nextCallTime := pl_nextCallTime + f_gen_Exponential_Distribution(pl_schData.target.cpsToReach); |
| vl_toStart := vl_toStart + 1; |
| } |
| } |
| } |
| |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": burstPreCalcPoisson"); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId& |
| ": using poisson table: "&log2str(vl_success)& |
| "\nvl_lambda: "&log2str(vl_lambda)&" / "&log2str(vl_scale)& |
| "\nvl_nrOfIntervals: "&log2str(vl_nrOfIntervals)& |
| "\nvl_notStarted: "&log2str(vl_notStarted)& |
| "\nvl_lastCallTime: "&log2str(vl_lastCallTime)& |
| "\npl_nextCallTime: "&log2str(pl_nextCallTime)& |
| "\nvl_toStart: "&log2str(vl_toStart)& |
| "\npl_when: "&log2str(pl_when)& |
| "\nf_EPTF_SchedulerComp_snapshotTime(): "&log2str(f_EPTF_SchedulerComp_snapshotTime())) |
| } |
| pl_schData.roundedCpsUpdateInterval := pl_nextCallTime; |
| pl_maxSend := vl_toStart + vl_notStarted; |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Scheduler data:"&log2str(pl_schData)&" pl_maxSend: "&log2str(pl_maxSend)) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPreCalcIMST |
| // |
| // Purpose: |
| // The burst precalculation function for IMST traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_when - *in* - *float* - time of scheduled event |
| // pl_maxSend - *out* - *integer* - maximum number of send |
| // pl_nextCallTime - *out* - *float* - the next call time |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Obsolete function, calls the CS |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPreCalcIMST( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in float pl_when, |
| out integer pl_maxSend, |
| out float pl_nextCallTime) runs on EPTF_LGenBase_Private_CT |
| { |
| f_EPTF_LGenBase_burstPreCalcCS(pl_schData,pl_when,pl_maxSend,pl_nextCallTime) |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPreCalcIMST2 |
| // |
| // Purpose: |
| // The burst precalculation function for IMST traffic with a faster algorithm |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_when - *in* - *float* - time of scheduled event |
| // pl_maxSend - *out* - *integer* - maximum number of send |
| // pl_nextCallTime - *out* - *float* - the next call time |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Obsolete function, calls the CS |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPreCalcIMST2( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in float pl_when, |
| out integer pl_maxSend, |
| out float pl_nextCallTime) runs on EPTF_LGenBase_Private_CT |
| { |
| f_EPTF_LGenBase_burstPreCalcCS(pl_schData,pl_when,pl_maxSend,pl_nextCallTime) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPostCalcOrig |
| // |
| // Purpose: |
| // The burst postcalculation function for EPTF traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_maxSend - *in* - *integer* - maximum number of send |
| // pl_sent - *in* - integer - the number of sent traffic |
| // |
| // Return Value: |
| // boolean - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPostCalcOrig( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in integer pl_maxSend, |
| in integer pl_sent) runs on EPTF_LGenBase_Private_CT |
| { |
| |
| pl_schData.lastBurstSize := pl_sent; |
| pl_schData.burstSizeCumulativeError := pl_schData.burstSizeCumulativeError+int2float(pl_maxSend-pl_sent); |
| |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPostCalcPoisson |
| // |
| // Purpose: |
| // The burst postcalculation function for Poisson distribution traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_maxSend - *in* - *integer* - maximum number of send |
| // pl_sent - *in* - integer - the number of sent traffic |
| // |
| // Return Value: |
| // boolean - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPostCalcPoisson( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in integer pl_maxSend, |
| in integer pl_sent) runs on EPTF_LGenBase_Private_CT |
| { |
| |
| pl_schData.lastBurstSize := pl_maxSend - pl_sent; |
| |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_burstPostCalcIMST |
| // |
| // Purpose: |
| // The burst postcalculation function for IMST traffic |
| // |
| // Parameters: |
| // pl_schData - *inout* - <EPTF_LGenBase_SchedulerData> - Scheduler data (eg. lastBurstSize) |
| // pl_maxSend - *in* - *integer* - maximum number of send |
| // pl_sent - *in* - integer - the number of sent traffic |
| // |
| // Return Value: |
| // boolean - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Obsolete function, calls the CS |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_burstPostCalcIMST( |
| inout EPTF_LGenBase_SchedulerData pl_schData, |
| in integer pl_maxSend, |
| in integer pl_sent) runs on EPTF_LGenBase_Private_CT |
| { |
| f_EPTF_LGenBase_burstPostCalcOrig(pl_schData,pl_maxSend,pl_sent) |
| } |
| } //group PrivatePredefinedBurstCal |
| |
| /////////////////////////////////////////////////////////// |
| // Group: PrivateTrafficManagement |
| // |
| // Purpose: |
| // Private functions of the traffic management |
| /////////////////////////////////////////////////////////// |
| group PrivateTrafficManagement{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_doTrafficCaseTimerAction |
| // |
| // Purpose: |
| // The handler function that will be called to handle the traffic case action |
| // |
| // Parameters: |
| // pl_action - *in* - <EPTF_ScheduledAction> - |
| // pl_eventIndex - *in* - *integer* - |
| // |
| // Return Value: |
| // boolean - True |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_doTrafficCaseTimerAction( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| var integer vl_maxSend; |
| var float vl_nextCallTime; |
| var float vl_currentTime := f_EPTF_SchedulerComp_snapshotTime(); |
| var integer vl_tcIdx := pl_action.actionId[0]; |
| v_LGenBase_trafficCases[vl_tcIdx].schedulingTimer := -1; |
| |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_Base_assert(%definitionId&"Burst PreCalc is empty.",null != v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstFuncRef.burstPreCalc); |
| if(f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&":-------------- "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" ----------------------"); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": pl_when: "&log2str(pl_action.when)) |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": snaphot time: "&log2str(vl_currentTime)) |
| } |
| } |
| //precalculation of burst |
| v_LGenBase_precalcTC := vl_tcIdx |
| v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstFuncRef.burstPreCalc.apply( |
| v_LGenBase_trafficCases[vl_tcIdx].schedulerData, |
| pl_action.when, |
| vl_maxSend, |
| vl_nextCallTime |
| ); //EBENMOL |
| v_LGenBase_precalcTC := -1 |
| v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstCalcNeeded := false; // burst recalc dont need any more |
| //Start TC for entities |
| var integer vl_eIdxInTC := f_EPTF_LGenBase_getNextFreeEntity(vl_tcIdx) |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Relative idx of the entity: "&int2str(vl_eIdxInTC)) |
| var integer vl_sent := 0; |
| if (vl_eIdxInTC<0) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": OVERLOAD AT START: NOT ENOUGH ENTITIES"); |
| } |
| |
| if(ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart) and |
| v_LGenBase_groupFinishConditionMask.nrOfExecStart){ |
| var integer vl_t := v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.count; |
| if(vl_maxSend > vl_t){ |
| vl_maxSend := vl_t; |
| } |
| } |
| if ( v_LGenBase_trafficCases[vl_tcIdx].enabled) {v_LGenBase_trafficCases[vl_tcIdx].currentSent := 0} |
| var EPTF_LGenBase_ConditionTrue vl_finishedRec := c_EPTF_LGenBase_emptyConditionTrue; |
| if(0 < vl_maxSend){ |
| while ( vl_sent < vl_maxSend and |
| -1 < vl_eIdxInTC and |
| v_LGenBase_trafficCases[vl_tcIdx].enabled and |
| not vl_finishedRec.anythingFinished) |
| { |
| if(not f_EPTF_FBQ_itemIsBusy(f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_eIdxInTC,vl_tcIdx,0), v_LGenBase_entities[v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_eIdxInTC].entityIdx].fsmCtxQueue) |
| or v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_eIdxInTC].disabled){ |
| f_EPTF_LGenBase_disableEntityInTrafficCase(vl_tcIdx,vl_eIdxInTC); |
| |
| vl_eIdxInTC := f_EPTF_LGenBase_getNextFreeEntity(vl_tcIdx); |
| continue; // fsm is inactive or entity is disabled |
| } |
| vl_finishedRec.anythingFinished := f_EPTF_LGenBase_startEntityInternal( |
| v_LGenBase_trafficCases[vl_tcIdx], |
| vl_tcIdx, |
| vl_eIdxInTC, |
| true, |
| vl_finishedRec); |
| vl_sent := vl_sent + 1; |
| Inc(v_LGenBase_trafficCases[vl_tcIdx].currentSent); |
| //Check group conditions |
| //v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditions.nrOfGrpLoop |
| //v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditions.nrOfRangeLoop |
| if( not vl_finishedRec.anythingFinished ){ |
| vl_eIdxInTC := f_EPTF_LGenBase_getNextFreeEntity(vl_tcIdx) |
| } |
| if (vl_sent < vl_maxSend and vl_eIdxInTC<0) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": OVERLOAD DURING ITERATION: NOT ENOUGH ENTITIES"); |
| } |
| } |
| } |
| if(vl_maxSend != vl_sent){ |
| v_LGenBase_trafficCases[vl_tcIdx].entityUnderrunCounter := |
| v_LGenBase_trafficCases[vl_tcIdx].entityUnderrunCounter + vl_maxSend - vl_sent |
| } |
| if(vl_currentTime - v_LGenBase_trafficCases[vl_tcIdx].lastCallTime > 0.0){ |
| v_LGenBase_trafficCases[vl_tcIdx].lastCPS := int2float(v_LGenBase_trafficCases[vl_tcIdx].lastSent) / (vl_currentTime - v_LGenBase_trafficCases[vl_tcIdx].lastCallTime); |
| } |
| //postcalculation of burst |
| v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstFuncRef.burstPostCalc.apply(v_LGenBase_trafficCases[vl_tcIdx].schedulerData,vl_maxSend,vl_sent); |
| |
| for (var integer x:= 0; x<sizeof(v_LGenBase_burstGenerated); x:= x+1) |
| { |
| v_LGenBase_burstGenerated[x].apply( v_LGenBase_trafficCases[vl_tcIdx].schedulerData, vl_maxSend, vl_sent ); // burst generated callback |
| } |
| |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&":-------------- "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" ----------------------"& |
| "\nsentMsgs: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].sentMsgs)& |
| "\nreceivedAnswers: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].receivedAnswers)& |
| "\npending: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].sentMsgs - v_LGenBase_trafficCases[vl_tcIdx].receivedAnswers)& |
| "\nNot finished entities: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfNotFinishedEntities)) |
| } |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId& |
| ": burstSizeCumulativeError: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].schedulerData.burstSizeCumulativeError)& |
| "\npl_when: "&log2str(pl_action.when)& |
| "\nvl_nextCallTime: "&log2str(vl_nextCallTime)& |
| "\nsent: "&log2str(vl_sent)& |
| "\nsnaphot time: "&log2str(vl_currentTime)& |
| "\nlast time: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].lastCallTime)& |
| "\nlast Sent: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].lastSent)& |
| "\ncurrent Sent: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].currentSent)& |
| "\nlast CPS: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].lastCPS)) |
| } |
| v_LGenBase_trafficCases[vl_tcIdx].lastSent := v_LGenBase_trafficCases[vl_tcIdx].currentSent; |
| v_LGenBase_trafficCases[vl_tcIdx].lastCallTime := vl_currentTime; |
| if(vl_finishedRec.anythingFinished){ |
| f_EPTF_LGenBase_groupFinishedDetected(vl_tcIdx, vl_finishedRec); |
| } |
| |
| if (v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected == c_EPTF_LGenBase_emptyConditionTrue){ |
| if(v_LGenBase_trafficCases[vl_tcIdx].enabled){ //May be, the traffic case has been disabled |
| //Start timer |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| vl_nextCallTime, |
| refers(f_EPTF_LGenBase_doTrafficCaseTimerAction), |
| {vl_tcIdx}, |
| v_LGenBase_trafficCases[vl_tcIdx].schedulingTimer)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&"Can not schedule traffic case timer event."); |
| } |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Created timer of tc "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" == "&int2str(v_LGenBase_trafficCases[vl_tcIdx].schedulingTimer)) |
| } |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_groupFinishedDetected |
| // |
| // Purpose: |
| // Books the finish of the traffic case |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_groupFinishedDetected( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_ConditionTrue pl_current |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(null != v_LGenBase_groupFinishedDetectedFn){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling newer callback: "& |
| log2str(v_LGenBase_groupFinishedDetectedFn)&" with conditions "&log2str(pl_current)) |
| } |
| var boolean vl_abortGroupFinished; |
| v_LGenBase_groupFinishedDetectedFn.apply(pl_tcIdx, pl_condition := pl_current, pl_abortGroupFinished := vl_abortGroupFinished); |
| |
| if (vl_abortGroupFinished){ |
| var EPTF_LGenBase_ConditionTrue vl_conditionTemp |
| f_EPTF_LGenBase_checkGroupFinishConditionFired( |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected, |
| pl_current, |
| vl_conditionTemp) |
| if(c_EPTF_LGenBase_emptyConditionTrue != vl_conditionTemp){ |
| f_EPTF_LGenBase_setGroupFinishConditionFired( |
| vl_conditionTemp, |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected); |
| } |
| return; |
| } else { |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected := c_EPTF_LGenBase_emptyConditionTrue; |
| } |
| } |
| |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": The traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" finish detected"& |
| "\nFinish conditions received: "&log2str(pl_current)& |
| "\nStopped state: "&log2str(v_LGenBase_trafficCases[pl_tcIdx].stopped)); |
| } |
| |
| if (v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer != -1) { |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling execTime timer failed."); |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].execTimeTimer := -1; |
| } |
| |
| if(v_LGenBase_trafficCases[pl_tcIdx].stopped){return} |
| var EPTF_LGenBase_ConditionTrue vl_conditionTemp |
| f_EPTF_LGenBase_checkGroupFinishConditionFired( |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected, |
| pl_current, |
| vl_conditionTemp) |
| if(c_EPTF_LGenBase_emptyConditionTrue != vl_conditionTemp){ |
| f_EPTF_LGenBase_setGroupFinishConditionFired( |
| vl_conditionTemp, |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected); |
| f_EPTF_LGenBase_processGroupFinished(pl_tcIdx, vl_conditionTemp, false); |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_doWeightedScenarioTimerAction |
| // |
| // Purpose: |
| // The handler function that will be called to handle the |
| // traffic launch for weighted scnearios |
| // |
| // Parameters: |
| // pl_action - *in* - <EPTF_ScheduledAction> - |
| // pl_eventIndex - *in* - *integer* - |
| // |
| // Return Value: |
| // boolean - True |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_doWeightedScenarioTimerAction( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| var integer vl_maxSend; |
| var float vl_nextCallTime; |
| var float vl_currentTime := f_EPTF_SchedulerComp_snapshotTime(); |
| var integer vl_eGrpIdx := pl_action.actionId[0], |
| vl_scInGrpIdx := pl_action.actionId[1]; |
| //v_LGenBase_trafficCases[vl_tcIdx].schedulingTimer := -1; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.schedulingTimer := -1 |
| |
| |
| //precalculation of burst |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstPreCalc.apply( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData, |
| pl_action.when, |
| vl_maxSend, |
| vl_nextCallTime) |
| |
| //launch traffics |
| var boolean vl_scenarioEnabled := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].enabled; |
| var integer vl_sent := 0; |
| var integer vl_tcPos := -1; |
| if(vl_maxSend > 0) { |
| vl_tcPos := f_EPTF_LGenBase_selectWeightedTrafficCase( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].weightedScData.deterministicMix, |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].trafficMixData |
| ); |
| } |
| |
| var boolean vl_congestion := false; |
| var integer vl_eIdxInTC := -1; |
| var integer vl_tcIdx:= -1; |
| while (vl_sent < vl_maxSend |
| and vl_tcPos >=0 |
| and vl_scenarioEnabled |
| and not vl_congestion |
| and c_EPTF_LGenBase_tcStateRunning == v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].state) |
| { |
| var EPTF_LGenBase_ConditionTrue vl_finishedRec := c_EPTF_LGenBase_emptyConditionTrue; |
| vl_tcIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].tcIdxList[vl_tcPos]; |
| vl_eIdxInTC := f_EPTF_LGenBase_getNextFreeEntity(vl_tcIdx) |
| if (vl_eIdxInTC >=0) { |
| vl_finishedRec.anythingFinished := f_EPTF_LGenBase_startEntityInternal( |
| v_LGenBase_trafficCases[vl_tcIdx], |
| vl_tcIdx, |
| vl_eIdxInTC, |
| true, |
| vl_finishedRec); |
| vl_sent := vl_sent +1; |
| Inc(v_LGenBase_trafficCases[vl_tcIdx].currentSent) |
| v_LGenBase_trafficCases[vl_tcIdx].hasSent := true |
| } else { //cannot start the traffix |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": There are no free entities in tc "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName) |
| vl_congestion := true |
| } |
| |
| //if TC has finished, the we need to recalc mix |
| if (vl_finishedRec.anythingFinished) { |
| f_EPTF_LGenBase_groupFinishedDetected(vl_tcIdx, vl_finishedRec); |
| } |
| |
| if (vl_sent<vl_maxSend) { |
| vl_tcPos:=f_EPTF_LGenBase_selectWeightedTrafficCase( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].weightedScData.deterministicMix, |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].trafficMixData |
| ) |
| } |
| } |
| //update TC stats |
| var integer vl_tcCount := sizeof(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].tcIdxList); |
| for (var integer vl_i := 0; vl_i<vl_tcCount ; vl_i:=vl_i+1) { |
| //if this traffic has been selected in this burst |
| var integer vl_tcAbsIdx := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].tcIdxList[vl_i]; |
| if (v_LGenBase_trafficCases[vl_tcAbsIdx].hasSent and |
| (vl_currentTime - v_LGenBase_trafficCases[vl_tcAbsIdx].lastCallTime >= 0.001)) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": LastSentOfTC "&v_LGenBase_trafficCases[vl_tcAbsIdx].uniqueName&" == "&int2str(v_LGenBase_trafficCases[vl_tcAbsIdx].lastSent)) |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&log2str(vl_currentTime - v_LGenBase_trafficCases[vl_tcAbsIdx].lastCallTime)) |
| v_LGenBase_trafficCases[vl_tcAbsIdx].lastCPS := |
| int2float(v_LGenBase_trafficCases[vl_tcAbsIdx].lastSent) / (vl_currentTime - v_LGenBase_trafficCases[vl_tcAbsIdx].lastCallTime); |
| v_LGenBase_trafficCases[vl_tcAbsIdx].lastCallTime := vl_currentTime; |
| v_LGenBase_trafficCases[vl_tcAbsIdx].lastSent := v_LGenBase_trafficCases[vl_tcAbsIdx].currentSent; |
| v_LGenBase_trafficCases[vl_tcAbsIdx].hasSent := false; |
| v_LGenBase_trafficCases[vl_tcAbsIdx].currentSent := 0; |
| } |
| } |
| //FIXME This should be decided config time |
| var EPTF_LGenBase_burstPostCalc_FT vl_postCalcFunc := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.burstFuncRef.burstPostCalc |
| if(null == vl_postCalcFunc) |
| { |
| if("" != v_LGenBase_burstCalcMode) { |
| var EPTF_LGenBase_burstPreCalc_FT vl_preCalcFunc; |
| v_LGenBase_dummyInt := f_EPTF_LGenBase_getBurstCalcFunction(v_LGenBase_burstCalcMode, vl_preCalcFunc, vl_postCalcFunc) |
| } |
| } |
| if(null != vl_postCalcFunc) |
| { |
| //postcalculation of burst |
| vl_postCalcFunc.apply( v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData, vl_maxSend,vl_sent); |
| } |
| for (var integer x:= 0; x<sizeof(v_LGenBase_burstGenerated); x:= x+1) |
| { |
| v_LGenBase_burstGenerated[x].apply( v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData, vl_maxSend, vl_sent ); // burst generated callback |
| } |
| |
| if (vl_congestion) { |
| vl_nextCallTime := vl_currentTime + v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.roundedCpsUpdateInterval; |
| } |
| |
| // MTTSM00016712 - re-scheduling if paused causes the event queue to grow when it gets unpaused/restarted, resulting in problems after cleanup: |
| vl_scenarioEnabled := vl_scenarioEnabled and |
| (v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].state == c_EPTF_LGenBase_tcStateRunning); |
| |
| if(vl_scenarioEnabled){ //May be, the traffic case has been disabled |
| //Start timer |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| vl_nextCallTime, |
| refers(f_EPTF_LGenBase_doWeightedScenarioTimerAction), |
| {vl_eGrpIdx,vl_scInGrpIdx}, |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.schedulingTimer)){ |
| f_EPTF_LGenBase_loggingError(%definitionId&" Can not schedule traffic case timer event."); |
| f_EPTF_Base_stop(); |
| } |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Created timer of sc "& |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].uniqueName&" == "& |
| int2str(v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scInGrpIdx].schedulerData.schedulingTimer)) |
| } |
| |
| |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_selectWeightedTrafficCase |
| // |
| // Purpose: |
| // Selects the next traffic case to execute using trafficMixer |
| // |
| // Parameters: |
| // pl_deterministicMix - *boolean* - if deterministic mix |
| // pl_mixData - <EPTF_TrafficMixer_scenarioTraffixMixData> - the mixer data of the scenario |
| // |
| // Return Value: |
| // *integer* - the traffic case index to start |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_selectWeightedTrafficCase( |
| in boolean pl_deterministicMix, |
| inout EPTF_TrafficMixer_scenarioTraffixMixData pl_mixData |
| ) runs on EPTF_LGenBase_Private_CT return integer |
| { |
| |
| if (not pl_deterministicMix) { |
| f_EPTF_TrafficMixer_generateTrafficMix_Rand(pl_mixData); |
| pl_mixData.burstListIdx := 0; |
| } |
| |
| for (var integer i:=0;i<sizeof(pl_mixData.burstList);i:=i+1) { |
| if (pl_mixData.burstListIdx == sizeof(pl_mixData.burstList)) |
| //and pl_deterministicMix) In case of deterministic it can not happen because of the previous block |
| { |
| f_EPTF_TrafficMixer_generateTrafficMix(pl_mixData); |
| pl_mixData.burstListIdx := 0; |
| } |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": pl_mixData == "&log2str(pl_mixData)) |
| } |
| if (pl_mixData.burstList[pl_mixData.burstListIdx] != 0) { |
| pl_mixData.burstListIdx := pl_mixData.burstListIdx + 1; |
| return pl_mixData.burstListIdx - 1; |
| } |
| pl_mixData.burstListIdx:= pl_mixData.burstListIdx + 1; |
| } |
| |
| // EPTF_LOG_VA_CORE(tsp_debug_EPTF_CLL_CS_Admin_Functions, {CORE_DEBUG}, "f_EPTF_CS_Admin_selectTrafficCase(): unsuccessfull traffic case selection"); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Unsuccessful traffic case selection") |
| return -1 |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_getNextFreeEntity |
| // |
| // Purpose: |
| // Retrieves the relative index of the first available entity in the tc. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_getNextFreeEntity(in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return integer{ |
| f_EPTF_Base_assert(%definitionId&": Invalid traffic case index: "&int2str(pl_tcAbsIdx),-1 < pl_tcAbsIdx and pl_tcAbsIdx < sizeof(v_LGenBase_trafficCases)); |
| if(v_LGenBase_trafficCases[pl_tcAbsIdx].nrOfAvailableEntities > 0) { |
| if(v_LGenBase_trafficCases[pl_tcAbsIdx].entityInfo.entitySelection == round_robin) { |
| return f_EPTF_FBQ_getFreeSlot(v_LGenBase_trafficCases[pl_tcAbsIdx].entityInfo.fbq); |
| } else { |
| return f_EPTF_RNA_getRndFreeSlot(v_LGenBase_trafficCases[pl_tcAbsIdx].entityInfo.rna); |
| } |
| } else { |
| return -1; |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_entityIsBusy |
| // |
| // Purpose: |
| // Checkes whether the entity is in busy state. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_entityIsBusy( |
| in integer pl_eRelIdx, |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| return f_EPTF_FBQ_itemIsBusy(pl_eRelIdx,v_LGenBase_trafficCases[pl_tcIdx].entityInfo.fbq); |
| } else { |
| return f_EPTF_RNA_itemIsBusy(pl_eRelIdx,v_LGenBase_trafficCases[pl_tcIdx].entityInfo.rna); |
| } |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishedTcListener |
| // |
| // Purpose: |
| // Administrates the succesful and failed calls. |
| // Checkes the finish conditions and executes finish |
| // actions when necessary calling <f_EPTF_LGenBase_execGroupActions> |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_finishedTcListener( |
| EPTF_LGenBase_ReportedEventDescriptor pl_event, |
| EPTF_IntegerList pl_listenerArgs |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| //Statistics |
| //Entity |
| var integer vl_entityIdx := pl_event.reportedArgs[1]; |
| //Find TC |
| var integer vl_tcIdx := pl_event.reportedArgs[0]; |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert( |
| %definitionId& |
| " Invalid traffic case index reported: "&log2str(vl_tcIdx), |
| vl_tcIdx > -1 and vl_tcIdx < sizeof(v_LGenBase_trafficCases)); |
| } |
| var integer vl_entityInTcFBQIdx := vl_entityIdx - v_LGenBase_entityGroups[v_LGenBase_trafficCases[vl_tcIdx].eGroupBackref].eOffset; |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert( |
| %definitionId& |
| " Entity #"&int2str(vl_entityInTcFBQIdx)&" of traffic case "& |
| v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" is not busy.", |
| f_EPTF_LGenBase_entityIsBusy(vl_entityInTcFBQIdx, vl_tcIdx)); |
| } |
| if (false == f_EPTF_LGenBase_entityIsBusy(vl_entityInTcFBQIdx, vl_tcIdx)) { |
| f_EPTF_LGenBase_loggingWarning( |
| %definitionId& |
| " Entity #"&int2str(vl_entityInTcFBQIdx)&" of traffic case "& |
| v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" is not busy." |
| ); |
| } |
| |
| var integer vl_fsmCtxIdx := -1 |
| if(ispresent(pl_event.event.source) and ispresent(pl_event.event.source.fsmCtxIdx)){ |
| vl_fsmCtxIdx := pl_event.event.source.fsmCtxIdx |
| }else{ |
| vl_fsmCtxIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_entityInTcFBQIdx, vl_tcIdx, 0); |
| } |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert( |
| %definitionId& |
| ": Invalid FSM context idx.", |
| -1 < vl_fsmCtxIdx and vl_fsmCtxIdx < sizeof(v_LGenBase_entities[vl_entityIdx].fsmCtxList)) |
| } |
| if(v_LGenBase_entities[vl_entityIdx].fsmCtxList[vl_fsmCtxIdx].singleShotDebugLog){ |
| v_LGenBase_entities[vl_entityIdx].fsmCtxList[vl_fsmCtxIdx].singleShotDebugLog := false |
| f_EPTF_Var_removeVar(v_LGenBase_entities[vl_entityIdx].fsmCtxList[vl_fsmCtxIdx].singleShotLogBufferVariable) |
| v_LGenBase_entities[vl_entityIdx].fsmCtxList[vl_fsmCtxIdx].singleShotLogBufferVariable := -1 |
| } |
| var float vl_transactionTime := T_EPTF_componentClock.read - |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].startTime |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_setTransactionTimeStatValueFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_setTransactionTimeStatValueFnList[vl_cb].apply( vl_tcIdx, vl_entityInTcFBQIdx, vl_transactionTime ) |
| } |
| |
| v_LGenBase_tempFinishedRec := c_EPTF_LGenBase_emptyConditionTrue; |
| var boolean vl_success := false; |
| |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_Base_assert( |
| %definitionId& |
| ": Finish is reported for the non-running Entity#"&int2str(vl_entityIdx)&" in TC: "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName& |
| ", fsmCtxIdx: "&int2str(vl_fsmCtxIdx)& " Event: "&log2str(pl_event), |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].isRunning); |
| } |
| |
| if (false == v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].isRunning) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId& |
| ": Finish is reported for the non-running Entity#"&int2str(vl_entityIdx)&" in TC: "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName& |
| ", fsmCtxIdx: "&int2str(vl_fsmCtxIdx)& |
| ", Event: "&log2str(pl_event) |
| ) |
| } |
| |
| |
| Dec(v_LGenBase_trafficCases[vl_tcIdx].nrOfRunningEntities); |
| v_LGenBase_trafficCases[vl_tcIdx].receivedAnswers := v_LGenBase_trafficCases[vl_tcIdx].receivedAnswers + 1; |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].isRunning := false |
| |
| select( pl_event.event.iIdx ) |
| { |
| case ( c_EPTF_LGenBase_inputIdx_testMgmt_finishedTcSuccess ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].nrOfSuccesses := v_LGenBase_trafficCases[vl_tcIdx].nrOfSuccesses + 1; |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfSuccesses := |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfSuccesses + 1; |
| vl_success := true; |
| f_EPTF_LGenBaseStats_trafficSucces( vl_tcIdx ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshSuccFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshSuccFnList[vl_cb].apply( vl_tcIdx ) |
| } |
| if(not v_LGenBase_trafficCases[vl_tcIdx].stopped and |
| not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.nrOfSuccesses and |
| v_LGenBase_groupFinishConditionMask.nrOfSuccesses and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses) and |
| v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.count <= v_LGenBase_trafficCases[vl_tcIdx].nrOfSuccesses){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.nrOfSuccesses := true |
| } |
| |
| if(v_LGenBase_ILog_enableILog){ |
| //ILog: log short chainat the end of a successfull TC |
| f_EPTF_LGenBase_ILog_logSuccess(vl_entityIdx, vl_fsmCtxIdx); |
| } |
| } |
| case ( c_EPTF_LGenBase_inputIdx_testMgmt_finishedTcFail ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].nrOfFails := v_LGenBase_trafficCases[vl_tcIdx].nrOfFails + 1; |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfFails := |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfFails + 1; |
| f_EPTF_LGenBaseStats_trafficFail( vl_tcIdx ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshFailFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshFailFnList[vl_cb].apply( vl_tcIdx ) |
| } |
| if(not v_LGenBase_trafficCases[vl_tcIdx].stopped and |
| not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.nrOfFails and |
| v_LGenBase_groupFinishConditionMask.nrOfFails and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails) and |
| v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails.count <= v_LGenBase_trafficCases[vl_tcIdx].nrOfFails){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.nrOfFails := true |
| } |
| |
| if(v_LGenBase_ILog_enableILog){ |
| //ILog: log all chains in case of failed TC |
| var integer vl_iLogElementId := f_EPTF_LGenBase_ILog_addToChainsBase(vl_entityIdx, vl_fsmCtxIdx, v_LGenBase_ILog_DB_Idx); |
| if (vl_iLogElementId!=-1) { |
| v_LGenBase_ILog_DB[vl_iLogElementId] := f_EPTF_Time() & ": EPTF_CLL_LGenBase: ILog: TC finished with fail"; |
| } |
| f_EPTF_LGenBase_ILog_logFailed(vl_entityIdx, vl_fsmCtxIdx); |
| } |
| } |
| case ( c_EPTF_LGenBase_inputIdx_testMgmt_finishedTcError ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].nrOfErrors := v_LGenBase_trafficCases[vl_tcIdx].nrOfErrors + 1; |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfErrors := |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfErrors + 1; |
| f_EPTF_LGenBaseStats_trafficError( vl_tcIdx ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshErrorFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshErrorFnList[vl_cb].apply( vl_tcIdx ) |
| } |
| if(not v_LGenBase_trafficCases[vl_tcIdx].stopped and |
| not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.nrOfErrors and |
| v_LGenBase_groupFinishConditionMask.nrOfErrors and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors) and |
| v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors.count <= v_LGenBase_trafficCases[vl_tcIdx].nrOfErrors){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.nrOfErrors := true |
| } |
| |
| if(v_LGenBase_ILog_enableILog){ |
| //ILog: log all chains in case of TC finished with error |
| var integer vl_iLogElementId := f_EPTF_LGenBase_ILog_addToChainsBase(vl_entityIdx, vl_fsmCtxIdx, v_LGenBase_ILog_DB_Idx); |
| if (vl_iLogElementId!=-1) { |
| v_LGenBase_ILog_DB[vl_iLogElementId] := f_EPTF_Time() & ": EPTF_CLL_LGenBase: ILog: TC finished with error"; |
| } |
| f_EPTF_LGenBase_ILog_logFailed(vl_entityIdx, vl_fsmCtxIdx); |
| } |
| } |
| case ( c_EPTF_LGenBase_inputIdx_testMgmt_finishedTcTimeout ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].nrOfTimeouts := v_LGenBase_trafficCases[vl_tcIdx].nrOfTimeouts + 1; |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfTimeouts := |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfTimeouts + 1; |
| f_EPTF_LGenBaseStats_trafficTimeout( vl_tcIdx ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_refreshTimeoutFnList) ; vl_cb := vl_cb+1 ){ |
| v_LGenBase_refreshTimeoutFnList[vl_cb].apply( vl_tcIdx ) |
| } |
| if(not v_LGenBase_trafficCases[vl_tcIdx].stopped and |
| not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.nrOfTimeouts and |
| v_LGenBase_groupFinishConditionMask.nrOfTimeouts and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts) and |
| v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.count <= v_LGenBase_trafficCases[vl_tcIdx].nrOfTimeouts){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.nrOfTimeouts := true |
| } |
| |
| if(v_LGenBase_ILog_enableILog){ |
| //ILog: log all chains in case of timed out TC |
| var integer vl_iLogElementId := f_EPTF_LGenBase_ILog_addToChainsBase(vl_entityIdx, vl_fsmCtxIdx, v_LGenBase_ILog_DB_Idx); |
| if (vl_iLogElementId!=-1) { |
| v_LGenBase_ILog_DB[vl_iLogElementId] := f_EPTF_Time() & ": EPTF_CLL_LGenBase: ILog: TC finished with timeout"; |
| } |
| f_EPTF_LGenBase_ILog_logFailed(vl_entityIdx, vl_fsmCtxIdx); |
| } |
| } |
| case else |
| { |
| f_EPTF_LGenBase_loggingError(%definitionId&"Invalid input index in finished event: "&log2str(pl_event.event)) |
| } |
| } |
| var integer vl_pending := v_LGenBase_trafficCases[vl_tcIdx].sentMsgs - v_LGenBase_trafficCases[vl_tcIdx].receivedAnswers; |
| var EPTF_LGenBase_EntityState vl_state := none; |
| var EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup2_FT vl_succFn := v_LGenBase_trafficCases[vl_tcIdx].customEntitySucc2; |
| |
| if(null != vl_succFn){ |
| vl_state := vl_succFn.apply( vl_tcIdx, vl_entityInTcFBQIdx, vl_success ); |
| }else{ |
| var EPTF_LGenBase_evaluateSuccess4EntityAtEntityGroup_FT vl_succPrevFn := v_LGenBase_trafficCases[vl_tcIdx].customEntitySuccPrev; |
| if(null != vl_succPrevFn){ |
| if(vl_succPrevFn.apply( vl_tcIdx, vl_entityInTcFBQIdx)){ |
| vl_state := pass |
| }else{ |
| vl_state := fail; |
| } |
| }else{ |
| vl_state := f_EPTF_LGenBase_successSucNoFail( vl_tcIdx, vl_entityInTcFBQIdx, vl_success ); |
| } |
| } |
| f_EPTF_LGenBase_setEntityState(vl_entityInTcFBQIdx, vl_tcIdx, vl_state); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId& |
| "Entity#"&int2str(vl_entityIdx)&" has finished in TC:"&v_LGenBase_trafficCases[vl_tcIdx].uniqueName& |
| "\npending msgs: "&log2str(vl_pending)& |
| "\nsuccessful: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfSuccesses)& |
| "\nfailed: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfFails)& |
| "\nerroneous: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfErrors)& |
| "\ntimed out: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfTimeouts)& |
| "\nentity success: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfSuccesses)& |
| "\nentity failes: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfFails)& |
| "\nentity errors: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfErrors)& |
| "\nentity timeouts: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfTimeouts) |
| ) |
| } |
| //Entity finish conditions |
| if(((ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfExecStart) and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfExecStart <= |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfStarts) or |
| (ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.customFinishCondition) and |
| null != v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.customFinishCondition and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.customFinishCondition.apply( vl_tcIdx, vl_entityInTcFBQIdx )) or |
| (ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfSuccesses) and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfSuccesses <= |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfSuccesses) or |
| (ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfErrors) and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfErrors <= |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfErrors) or |
| (ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfTimeouts) and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfTimeouts <= |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfTimeouts) or |
| (ispresent(v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfFails) and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishConditions.nrOfFails <= |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].nrOfFails)) |
| ){ |
| //Yes, it's finished |
| Dec(v_LGenBase_trafficCases[vl_tcIdx].nrOfNotFinishedEntities); |
| //Check whether the group finish condition is true too |
| if(not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.entitiesFinished and |
| v_LGenBase_groupFinishConditionMask.entitiesFinished and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.entitiesFinished) and |
| 0 == v_LGenBase_trafficCases[vl_tcIdx].nrOfNotFinishedEntities ){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.entitiesFinished := true |
| } |
| if(not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.availableEntitiesFinished and |
| v_LGenBase_groupFinishConditionMask.availableEntitiesFinished and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.availableEntitiesFinished) and |
| 0 == v_LGenBase_trafficCases[vl_tcIdx].nrOfRunningEntities and |
| 0 == v_LGenBase_trafficCases[vl_tcIdx].nrOfAvailableEntities ){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.availableEntitiesFinished := true |
| } |
| |
| //Execute entity finish actions |
| if(v_LGenBase_trafficCases[vl_tcIdx].state == c_EPTF_LGenBase_tcStateRunning or v_LGenBase_trafficCases[vl_tcIdx].state == c_EPTF_LGenBase_tcStatePaused){ |
| v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].finished := true; |
| var integer vl_efaCount := sizeof(v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions); |
| for ( var integer vl_i := 0; vl_i < vl_efaCount ; vl_i := vl_i+1 ) |
| { |
| select( v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i] ) |
| { |
| case ( {disableEntity4Tc := ?} ) |
| { |
| f_EPTF_LGenBase_disableEntityInTrafficCase( |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].disableEntity4Tc.tcIdx, |
| vl_entityInTcFBQIdx); |
| } |
| case ( {enableEntity4Tc := ?} ) |
| { |
| select( v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].enableEntity4Tc.aMode ) |
| { |
| case ( enableIfPreviousSuccess ) |
| { |
| if(pass == f_EPTF_LGenBase_getEntityState(vl_entityInTcFBQIdx, vl_tcIdx)){ |
| f_EPTF_LGenBase_enableEntityInTrafficCase( |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].enableEntity4Tc.tcIdx, |
| vl_entityInTcFBQIdx); |
| }else{ |
| f_EPTF_LGenBase_disableEntityInTrafficCase( |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].enableEntity4Tc.tcIdx, |
| vl_entityInTcFBQIdx); |
| } |
| } |
| case (available){ |
| f_EPTF_LGenBase_enableEntityInTrafficCase( |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].enableEntity4Tc.tcIdx, |
| vl_entityInTcFBQIdx); |
| } |
| case (non_available){ |
| f_EPTF_LGenBase_disableEntityInTrafficCase( |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].enableEntity4Tc.tcIdx, |
| vl_entityInTcFBQIdx); |
| } |
| case else { } |
| } |
| } |
| case ( {generateFsmEvent := ?} ) |
| { |
| f_EPTF_Base_assert(%definitionId&"Invalid event ID.", |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].generateFsmEvent.iIdx > -1 and |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].generateFsmEvent.iIdx <= c_EPTF_LGenBase_lastInputIdx); |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].generateFsmEvent.iIdx, |
| target := { |
| eIdx := vl_entityIdx, |
| fsmCtxIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_entityInTcFBQIdx, vl_tcIdx, 0) |
| }, |
| source := { |
| eIdx := vl_entityIdx, |
| fsmCtxIdx := vl_fsmCtxIdx |
| } |
| }, |
| reportedArgs := {} |
| }); |
| } |
| case ( {customFinishFunction := ?} ) |
| { |
| if ( null != v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].customFinishFunction ) |
| { |
| v_LGenBase_trafficCases[vl_tcIdx].entityFinishActions[vl_i].customFinishFunction.apply( vl_entityIdx ); |
| } |
| } |
| case else |
| { |
| //A bit paranoia, EPTF_LGenBase_TcMgmt_EntityActions type changed |
| f_EPTF_Base_assert(%definitionId&"Invalid action type.",false); |
| } |
| } |
| } |
| } |
| |
| }else{ |
| //HN15601 |
| if(not v_LGenBase_trafficCases[vl_tcIdx].entityInfo.itemList[vl_entityInTcFBQIdx].disabled){ |
| //Put back to free chain |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Put back Entity#"&int2str(vl_entityIdx)&" in "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" rel. idx: "&int2str(vl_entityInTcFBQIdx)) |
| } |
| if(v_LGenBase_trafficCases[vl_tcIdx].entityInfo.entitySelection == round_robin) { |
| f_EPTF_FBQ_moveFromBusyToFreeTail(vl_entityInTcFBQIdx, v_LGenBase_trafficCases[vl_tcIdx].entityInfo.fbq); |
| } else { |
| if(not f_EPTF_RNA_moveFromBusyToFreeSlot(vl_entityInTcFBQIdx, v_LGenBase_trafficCases[vl_tcIdx].entityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromBusyToFreeSlot",false) |
| } |
| } |
| Inc(v_LGenBase_trafficCases[vl_tcIdx].nrOfAvailableEntities); |
| } |
| } |
| if (c_EPTF_Common_debugSwitch){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&":---- Not finished: "&int2str(v_LGenBase_trafficCases[vl_tcIdx].nrOfNotFinishedEntities)) |
| } |
| //Group finish conditions |
| if (not v_LGenBase_trafficCases[vl_tcIdx].stopped){ |
| if(not v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionDetected.customFinishCondition and |
| v_LGenBase_groupFinishConditionMask.customFinishCondition and |
| ispresent(v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.customFinishConditionFuncRef) and |
| v_LGenBase_trafficCases[vl_tcIdx].trafficStartFinishConditionsAndActions.customFinishConditionFuncRef.functionRef.apply(vl_tcIdx, vl_entityInTcFBQIdx)){ |
| v_LGenBase_tempFinishedRec.anythingFinished := true |
| v_LGenBase_tempFinishedRec.customFinishCondition := true |
| } |
| if(v_LGenBase_tempFinishedRec.anythingFinished) |
| { |
| f_EPTF_LGenBase_groupFinishedDetected(vl_tcIdx, v_LGenBase_tempFinishedRec); |
| } |
| } |
| if(v_LGenBase_trafficCases[vl_tcIdx].groupFinishConditionProcessed.anythingFinished and |
| not v_LGenBase_trafficCases[vl_tcIdx].stopped) |
| { |
| f_EPTF_LGenBase_checkLaunchFinished(vl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_checkLaunchFinished |
| // |
| // Purpose: |
| // This internal function checks whether the launch on the |
| // specified traffic case had finished. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_checkLaunchFinished(in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": ---- checkLaunchFinished"); |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": NotFinishedEntities"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfNotFinishedEntities)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": groupFinishConditionDetected"&log2str(v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": groupFinishConditionProcessed"&log2str(v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionProcessed)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": nrOfStarts"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfStarts)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": nrOfFails"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfFails)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": nrOfErrors"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfErrors)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": nrOfTimeouts"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfTimeouts)) |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": nrOfSuccesses"&log2str(v_LGenBase_trafficCases[pl_tcIdx].nrOfSuccesses)) |
| } |
| if(v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionProcessed.anythingFinished and |
| 0 == v_LGenBase_trafficCases[pl_tcIdx].nrOfRunningEntities |
| /*v_LGenBase_trafficCases[pl_tcIdx].nrOfStarts == |
| v_LGenBase_trafficCases[pl_tcIdx].nrOfFails + |
| v_LGenBase_trafficCases[pl_tcIdx].nrOfErrors + |
| v_LGenBase_trafficCases[pl_tcIdx].nrOfTimeouts + |
| v_LGenBase_trafficCases[pl_tcIdx].nrOfSuccesses*/ |
| ){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Traffic finished for tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_launchedTrafficFinished, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| |
| if(null != v_LGenBase_groupFinishedFn){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling elder callback: "& |
| log2str(v_LGenBase_groupFinishedFn)) |
| } |
| v_LGenBase_groupFinishedFn.apply(pl_tcIdx, onLaunchFinish); |
| }else{ |
| if(null != v_LGenBase_groupFinishedPerConditionFn){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling callback: "& |
| log2str(v_LGenBase_groupFinishedPerConditionFn)) |
| } |
| v_LGenBase_groupFinishedPerConditionFn.apply(pl_tcIdx, {trafficFinished := {}}); |
| }else{ |
| if(0 != sizeof(v_LGenBase_trafficCases[pl_tcIdx].trafficFinishedActions)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling f_EPTF_LGenBase_execTrafficFinishedActions") |
| f_EPTF_LGenBase_execTrafficFinishedActions(pl_tcIdx) |
| } |
| } |
| } |
| |
| var integer vl_scIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef; |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref; |
| var integer vl_runningTcs := v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].startedTcs - 1; |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].startedTcs := vl_runningTcs; |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateTerminated; |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": State of tc "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&": "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[pl_tcIdx].state]); |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| |
| if(null != v_LGenBase_detectPhaseFinishFn){v_LGenBase_detectPhaseFinishFn.apply( pl_tcIdx )} |
| //f_EPTF_LGenBase_callPhaseFinishConditions(pl_tcIdx); // calling phase finish condition checking |
| |
| if(0 == vl_runningTcs){ |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_scenarioFinished, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| } |
| } |
| } |
| |
| friend function f_EPTF_LGenBase_execTrafficFinishedActions(in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_execGroupActions(v_LGenBase_trafficCases[pl_tcIdx], v_LGenBase_trafficCases[pl_tcIdx].trafficFinishedActions, pl_tcIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_execGroupFinishActions |
| // |
| // Purpose: |
| // Executes the actions associated to the conditions described |
| // in the pl_cause parameter. |
| // |
| // Detailed Comments: |
| // Since the function was developed primarily for CLL internal use, |
| // be very careful if you decided to use it. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_execGroupFinishActions( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_finishCallbackCause pl_cause) |
| runs on EPTF_LGenBase_Private_CT{ |
| if ( ischosen(pl_cause.conditions) ){ |
| f_EPTF_LGenBase_execFinishActions(pl_tcIdx, pl_cause.conditions) |
| f_EPTF_LGenBase_checkLaunchFinished(pl_tcIdx) |
| } |
| else if ( ischosen(pl_cause.trafficFinished) ){ |
| f_EPTF_LGenBase_execTrafficFinishedActions(pl_tcIdx) |
| } else { |
| f_EPTF_Base_assert(%definitionId&": Programming error: the EPTF_LGenBase_finishCallbackCause had been changed, "& |
| " but it isn't handled in the f_EPTF_LGenBase_execGroupFinishActions function!",true) |
| } |
| } |
| |
| type enumerated EPTF_LGenBase_TrafficStartFinishConditions { |
| customFinish, |
| entitiesFinished, |
| availableEntitiesFinished, |
| execTime, |
| nrOfExecStart, |
| nrOfFails, |
| nrOfErrors, |
| nrOfTimeouts, |
| nrOfRangeLoop, |
| nrOfSuccesses, |
| anythingFinished |
| } |
| |
| friend function f_EPTF_LGenBase_getTrafficStartFinishConditionCounter( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_TrafficStartFinishConditions pl_condition |
| ) runs on EPTF_LGenBase_Private_CT return integer { |
| select(pl_condition) { |
| // case(customFinish) { |
| // } |
| // case(entitiesFinished) { |
| // } |
| // case(availableEntitiesFinished) { |
| // } |
| // case(execTime) { |
| // return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.execTime; |
| // } |
| case(nrOfExecStart) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.count; |
| } |
| case(nrOfFails) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails.count; |
| } |
| case(nrOfErrors) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors.count; |
| } |
| case(nrOfTimeouts) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.count; |
| } |
| case(nrOfRangeLoop) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count; |
| } |
| case(nrOfSuccesses) { |
| if (not ispresent(v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses)) { |
| return -1; |
| } |
| return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.count; |
| } |
| // case(anythingFinished) { |
| // } |
| case else { |
| // not supported |
| return -1; |
| } |
| } |
| } |
| |
| friend function f_EPTF_LGenBase_setTrafficStartFinishConditionCounter( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_TrafficStartFinishConditions pl_condition, |
| in integer pl_newCounter |
| ) runs on EPTF_LGenBase_Private_CT { |
| select(pl_condition) { |
| // case(customFinish) { |
| // } |
| // case(entitiesFinished) { |
| // } |
| // case(availableEntitiesFinished) { |
| // } |
| // case(execTime) { |
| // return v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.execTime; |
| // } |
| case(nrOfExecStart) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.count := pl_newCounter; |
| } |
| case(nrOfFails) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfFails.count := pl_newCounter; |
| } |
| case(nrOfErrors) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfErrors.count := pl_newCounter; |
| } |
| case(nrOfTimeouts) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.count := pl_newCounter; |
| } |
| case(nrOfRangeLoop) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count := pl_newCounter; |
| } |
| case(nrOfSuccesses) { |
| v_LGenBase_trafficCases[pl_tcIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.count := pl_newCounter; |
| } |
| // case(anythingFinished) { |
| // } |
| case else { |
| // not supported |
| return; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishedAbortTcListener |
| // |
| // Purpose: |
| // Event listener to handle the generic event about the handling of the |
| // abort TC event replied by the entities. |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_finishedAbortTcListener( |
| EPTF_LGenBase_ReportedEventDescriptor pl_event, |
| EPTF_IntegerList pl_listenerArgs |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcIdx := pl_event.reportedArgs[0]; |
| var integer vl_eRelIdx := f_EPTF_LGenBase_getERelIdx(pl_event.reportedArgs[1]); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": \nState: "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]) |
| } |
| if(c_EPTF_LGenBase_tcStateAborting == v_LGenBase_trafficCases[vl_tcIdx].state){ |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_eRelIdx, v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic( |
| "Nof remaining entities: "&log2str( f_EPTF_FBQ_getLengthOfFreeChain(v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo))& |
| " \nTimer: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer)) |
| } |
| if(0 == f_EPTF_FBQ_getLengthOfFreeChain(v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo)){ |
| if(-1 < v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer){ |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling stop timeout timer failed."); |
| } |
| v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer := -1; |
| } |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStateAborted; |
| f_EPTF_LGenBase_tcStateChanged(vl_tcIdx); |
| } |
| }else{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Entity abort response of entity#"&int2str(vl_eRelIdx)& |
| " of traffic case "&v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" has arrived, but the TC is in "& |
| c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]&" state."); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_finishedStopTcListener |
| // |
| // Purpose: |
| // Event listener to handle the generic event about the handling of the |
| // stop TC event replied by the entities. |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_finishedStopTcListener( |
| EPTF_LGenBase_ReportedEventDescriptor pl_event, |
| EPTF_IntegerList pl_listenerArgs |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| var integer vl_tcIdx := pl_event.reportedArgs[0]; |
| var integer vl_eRelIdx := f_EPTF_LGenBase_getERelIdx(pl_event.reportedArgs[1]); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": \nState: "&c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]) |
| } |
| if(c_EPTF_LGenBase_tcStateStopping == v_LGenBase_trafficCases[vl_tcIdx].state){ |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_eRelIdx, v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic( |
| "Nof remaining entities: "&log2str( f_EPTF_FBQ_getLengthOfFreeChain(v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo))& |
| " \nTimer: "&log2str(v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer)) |
| } |
| if(0 == f_EPTF_FBQ_getLengthOfFreeChain(v_LGenBase_trafficCases[vl_tcIdx].stoppingEntityInfo)){ |
| if(-1 < v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer){ |
| if(not f_EPTF_SchedulerComp_CancelEvent(v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling stop timeout timer failed."); |
| } |
| v_LGenBase_trafficCases[vl_tcIdx].stopTimeoutTimer := -1; |
| } |
| v_LGenBase_trafficCases[vl_tcIdx].state := c_EPTF_LGenBase_tcStateStopped; |
| if(null != v_LGenBase_detectPhaseFinishFn){v_LGenBase_detectPhaseFinishFn.apply( vl_tcIdx )} |
| //f_EPTF_LGenBase_callPhaseFinishConditions(vl_tcIdx); |
| f_EPTF_LGenBase_tcStateChanged(vl_tcIdx); |
| } |
| }else{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Entity stop response of entity#"&int2str(vl_eRelIdx)&" of traffic case "& |
| v_LGenBase_trafficCases[vl_tcIdx].uniqueName&" has arrived, but the TC is in "& |
| c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[vl_tcIdx].state]&" state."); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_restartActionTimer |
| // |
| // Purpose: |
| // Internal function to stop and start periodic tc or scenario event if it exists |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_restartActionTimer( |
| inout integer pl_timer, |
| in EPTF_Scheduler_ActionHandler pl_actionHandler, |
| in EPTF_ActionId pl_action, |
| in float pl_delay := tsp_EPTF_ELEMENTARY_TIMESTEP_PARAM |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&log2str(pl_action)) |
| } |
| if ( -1 != pl_timer ) |
| { |
| if(f_EPTF_SchedulerComp_CancelEvent(pl_timer)) { |
| pl_timer := -1 |
| } else { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": Cancelling timer failed."); |
| } |
| } |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| T_EPTF_componentClock.read + pl_delay, |
| pl_actionHandler, |
| pl_action, |
| pl_timer)) { |
| f_EPTF_LGenBase_loggingError(%definitionId&": Can not schedule timer event."); |
| //TODO Retry? |
| f_EPTF_Base_stop(); |
| } |
| |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_tcStateChanged |
| // |
| // Purpose: |
| // Checks the state of the traffic case and the scenario, |
| // and calls the callback if it's changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_tcStateChanged(in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(log2str(%definitionId&"--------checkScState. TcIdx == ",pl_tcIdx," scenario == ",v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef)) |
| } |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref; |
| var integer vl_scIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef; |
| f_EPTF_LGenBaseStats_tcStateChangedCallback(pl_tcIdx) |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_tcStateChangedCallbacks) ; vl_i := vl_i+1 ) |
| { |
| v_LGenBase_tcStateChangedCallbacks[vl_i].apply(pl_tcIdx); |
| } |
| f_EPTF_LGenBase_setScNewState( |
| vl_eGrpIdx, |
| vl_scIdx, |
| f_EPTF_LGenBase_stateOfScenario(vl_eGrpIdx, vl_scIdx)) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_setScNewState |
| // |
| // Purpose: |
| // Sets the state of the specified scenario to the new state if it |
| // wasn't equal with the previous one, and calls the registered |
| // callback functions. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_setScNewState( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx, |
| in EPTF_LGenBase_tcState pl_newState) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(pl_newState != v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].state){ |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].state := pl_newState; |
| f_EPTF_LGenBaseStats_scenarioStateChangedCallback( pl_eGrpIdx, pl_scIdx ) |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_scenarioStateChangedCallbacks) ; vl_i := vl_i+1 ) |
| { |
| v_LGenBase_scenarioStateChangedCallbacks[vl_i].apply( pl_eGrpIdx, pl_scIdx ); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_processGroupFinished |
| // |
| // Purpose: |
| // Books the finish of the traffic case and executes the |
| // associated actions. |
| // Detailed Comments: |
| // Since the function was developed primarily for CLL internal use, |
| // be very careful if you decided to use it. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_processGroupFinished( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_ConditionTrue pl_current := c_EPTF_LGenBase_anythingConditionTrue, |
| in boolean pl_externalCall := true |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": The traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" finished"); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Finish conditions received: "&log2str(pl_current)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": External call: "&log2str(pl_externalCall)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": v_LGenBase_groupFinishedFn: "&log2str(v_LGenBase_groupFinishedFn)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": v_LGenBase_groupFinishedPerConditionFn: "&log2str(v_LGenBase_groupFinishedPerConditionFn)); |
| } |
| var EPTF_LGenBase_ConditionTrue vl_conditionTemp |
| f_EPTF_LGenBase_checkGroupFinishConditionFired( |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionProcessed, |
| pl_current, |
| vl_conditionTemp) |
| if(c_EPTF_LGenBase_emptyConditionTrue != vl_conditionTemp){ |
| if(pl_externalCall){ |
| f_EPTF_LGenBase_execFinishActions(pl_tcIdx, vl_conditionTemp) |
| }else{ |
| if(null != v_LGenBase_groupFinishedFn){ |
| if(vl_conditionTemp.anythingFinished){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling elder callback: "& |
| log2str(v_LGenBase_groupFinishedFn)) |
| } |
| v_LGenBase_groupFinishedFn.apply(pl_tcIdx, onGroupFinishCondition); |
| }else{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": There is an elder callback, but the group finished had been reported earlier.") |
| } |
| }else{ |
| if(null != v_LGenBase_groupFinishedPerConditionFn){ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Calling newer callback: "& |
| log2str(v_LGenBase_groupFinishedPerConditionFn)&" with conditions "&log2str(vl_conditionTemp)) |
| } |
| v_LGenBase_groupFinishedPerConditionFn.apply(pl_tcIdx, {conditions := vl_conditionTemp}) |
| }else{ |
| f_EPTF_LGenBase_execFinishActions(pl_tcIdx, vl_conditionTemp) |
| } |
| } |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].state := c_EPTF_LGenBase_tcStateFinished; |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| f_EPTF_LGenBase_disableTrafficCaseInternal(pl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_copyEntityAvailabilityModes |
| // |
| // Purpose: |
| // This internal function sets the enabled/disabled state of the entities |
| // according to the pl_mode parameter and the state of the entity in the |
| // source list. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_copyEntityAvailabilityModes( |
| in EPTF_LGenBase_TcMgmt_EntityAvailabilityGroupTransferMode pl_mode, |
| inout EPTF_LGenBase_EntityInfo pl_srcEntityInfo, |
| inout EPTF_LGenBase_EntityInfo pl_destEntityInfo) |
| runs on EPTF_LGenBase_Private_CT{ |
| if(noChange == pl_mode){return} |
| f_EPTF_Base_assert(%definitionId&": Different FBQ sizes.",sizeof(pl_destEntityInfo.itemList)==sizeof(pl_srcEntityInfo.itemList)); |
| var integer vl_eCount := sizeof(pl_srcEntityInfo.itemList); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": copyEntityAvailabilityModes"); |
| for ( var integer vl_i := 0; vl_i < vl_eCount ; vl_i := vl_i+1 ) |
| { |
| var boolean vl_srcSuccess := pl_mode == available or |
| (pl_mode == enableIfPreviousSuccess and pass == f_EPTF_LGenBase_integer2eState(pl_srcEntityInfo.itemList[vl_i].entityState)); |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Success of entity#"&int2str(vl_i)&" == "&log2str(vl_srcSuccess)) |
| if(pl_destEntityInfo.entitySelection == round_robin) { // round robin |
| if(vl_srcSuccess){ |
| if (not f_EPTF_FBQ_itemIsFree(vl_i,pl_destEntityInfo.fbq)){ |
| if ( f_EPTF_FBQ_itemIsBusy(vl_i,pl_destEntityInfo.fbq)){ |
| f_EPTF_FBQ_moveFromBusyToFreeTail(vl_i,pl_destEntityInfo.fbq); |
| }else{ |
| if ( f_EPTF_FBQ_itemIsInvalid(vl_i,pl_destEntityInfo.fbq) ) |
| { |
| f_EPTF_FBQ_moveFromInvalidToFreeTail(vl_i,pl_destEntityInfo.fbq); |
| } |
| } |
| } |
| } else { |
| if ( not f_EPTF_FBQ_itemIsBusy(vl_i,pl_destEntityInfo.fbq)){ |
| if ( f_EPTF_FBQ_itemIsInvalid(vl_i,pl_destEntityInfo.fbq) ) |
| { |
| f_EPTF_FBQ_moveFromInvalidToBusyTail(vl_i,pl_destEntityInfo.fbq); |
| } |
| if ( f_EPTF_FBQ_itemIsFree(vl_i,pl_destEntityInfo.fbq)){ |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_i,pl_destEntityInfo.fbq); |
| } |
| } |
| } |
| } else { // random |
| if(vl_srcSuccess){ |
| if ( f_EPTF_RNA_itemIsBusy(vl_i,pl_destEntityInfo.rna)){ |
| if(not f_EPTF_RNA_moveFromBusyToFreeSlot(vl_i,pl_destEntityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromBusyToFreeSlot",false) |
| } |
| } |
| } else { |
| if ( f_EPTF_RNA_itemIsFree(vl_i,pl_destEntityInfo.rna)){ |
| if(not f_EPTF_RNA_moveFromFreeToBusySlot(vl_i,pl_destEntityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromFreeToBusySlot",false) |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_execGroupActions |
| // |
| // Purpose: |
| // Executes finish actions |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_execGroupActions( |
| inout EPTF_LGenBase_TcDescriptor pl_tcDescriptor, |
| inout EPTF_LGenBase_TcMgmt_GroupActionsDescList pl_actions, |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&"action of "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" is "&log2str(pl_actions)); |
| } |
| |
| var integer vl_gfaCount := sizeof(pl_actions); |
| for ( var integer vl_i := 0; vl_i < vl_gfaCount ; vl_i := vl_i+1 ) |
| { |
| if (ischosen(pl_actions[vl_i].enableAllTc) ){ |
| var integer vl_tcCount := |
| sizeof(v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList); |
| for ( var integer vl_iTc := 0; vl_iTc < vl_tcCount ; vl_iTc := vl_iTc+1 ) |
| { |
| f_EPTF_LGenBase_copyEntityAvailabilityModes( |
| pl_actions[vl_i].enableAllTc.aMode, |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo, |
| v_LGenBase_trafficCases[v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList[vl_iTc]].entityInfo) |
| f_EPTF_LGenBase_enableTrafficCaseInternal( |
| v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList[vl_iTc]); |
| } |
| } |
| else if (ischosen(pl_actions[vl_i].disableAllTc)) { |
| var integer vl_tcCount := |
| sizeof(v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList); |
| for ( var integer vl_iTc := 0; vl_iTc < vl_tcCount ; vl_iTc := vl_iTc+1 ) |
| { |
| if(vl_iTc != pl_tcIdx) { |
| f_EPTF_LGenBase_copyEntityAvailabilityModes( |
| pl_actions[vl_i].disableAllTc.aMode, |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo, |
| v_LGenBase_trafficCases[v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList[vl_iTc]].entityInfo); |
| f_EPTF_LGenBase_disableTrafficCaseInternal(v_LGenBase_entityGroups[pl_tcDescriptor.eGroupBackref].scenarios[pl_tcDescriptor.eScenarioBackRef].tcIdxList[vl_iTc]); |
| } |
| } |
| } |
| else if ( ischosen(pl_actions[vl_i].enableTc) ){ |
| f_EPTF_LGenBase_copyEntityAvailabilityModes( |
| pl_actions[vl_i].enableTc.aMode, |
| v_LGenBase_trafficCases[pl_tcIdx].entityInfo, |
| v_LGenBase_trafficCases[pl_actions[vl_i].enableTc.tcIdx].entityInfo) |
| f_EPTF_LGenBase_enableTrafficCaseInternal(pl_actions[vl_i].enableTc.tcIdx); |
| } |
| else if ( ischosen(pl_actions[vl_i].disableTc) ){ |
| if(pl_tcIdx != pl_actions[vl_i].disableTc.tcIdx) { |
| f_EPTF_LGenBase_disableTrafficCaseInternal(pl_actions[vl_i].disableTc.tcIdx); |
| } |
| } |
| else if (ischosen(pl_actions[vl_i].generateGenericEvent) ){ |
| f_EPTF_Base_assert(%definitionId&"Invalid event ID.", |
| pl_actions[vl_i].generateGenericEvent.iIdx > -1 and |
| pl_actions[vl_i].generateGenericEvent.iIdx <= c_EPTF_LGenBase_lastInputIdx); |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := pl_actions[vl_i].generateGenericEvent.iIdx, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| } |
| else if (ischosen(pl_actions[vl_i].customFinishFunction) ){ |
| if(null != pl_actions[vl_i].customFinishFunction){ |
| pl_actions[vl_i].customFinishFunction.apply( pl_tcIdx ); |
| } |
| } |
| else if (ischosen(pl_actions[vl_i].testFinished) ){ |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_testFinished, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| } else { |
| //A bit paranoia. Something changed asychronously |
| f_EPTF_Base_assert(%definitionId&": Invalid FBQ state.",false); |
| } |
| } |
| } |
| |
| function Inc(inout integer pl_i){ |
| pl_i := pl_i + 1; |
| } |
| function Dec(inout integer pl_i){ |
| pl_i := pl_i - 1; |
| } |
| function IncBy(inout integer pl_i, in integer pl_diff){ |
| pl_i := pl_i + pl_diff; |
| } |
| function DecBy(inout integer pl_i, in integer pl_diff){ |
| pl_i := pl_i - pl_diff; |
| } |
| |
| function SetIfLt(inout integer pl_prev, in integer pl_to){ |
| if(pl_to < pl_prev){ |
| pl_prev := pl_to; |
| } |
| } |
| function SetIfGt(inout integer pl_prev, in integer pl_to){ |
| if(pl_to > pl_prev){ |
| pl_prev := pl_to; |
| } |
| } |
| }//PrivateTrafficManagement |
| |
| /////////////////////////////////////////////////////////// |
| // Group: PrivateStartStopInit |
| // |
| // Purpose: |
| // Private functions during the start, stop, etc. traffic cases |
| /////////////////////////////////////////////////////////// |
| group PrivateStartStopInit{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resetTcStats |
| // |
| // Purpose: |
| // Resets the statistics of a traffic case |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_resetTcStats( |
| in integer pl_tcIdx, |
| inout EPTF_LGenBase_TcDescriptor pl_tc) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": "&log2str(pl_tc)) |
| } |
| pl_tc.nrOfStarts := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfSuccesses := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfFails := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfErrors := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfTimeouts := 0; //cumulative stat for all entities of the entity group |
| pl_tc.grpLoop := 0; |
| |
| pl_tc.schedulerData.lastBurstSize := 0; //EBENMOL |
| if (pl_tc.schedulerData.burstFuncRef.burstCalcMode == c_EPTF_LGenBase_BurstCalc_poisson) { |
| pl_tc.schedulerData.burstSizeCumulativeError := 0.0; |
| pl_tc.schedulerData.idealBurstSize := 0.0; |
| pl_tc.schedulerData.currentBurstSize := 0; |
| pl_tc.schedulerData.roundedCpsUpdateInterval := 0.0; |
| } |
| // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| pl_tc.schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_tc.eGroupBackref].trafficCorrigation; |
| |
| pl_tc.lastCPS := 0.0; |
| pl_tc.lastSent := 0; |
| pl_tc.currentSent := 0; |
| pl_tc.hasSent := false; |
| |
| pl_tc.lastCallTime := 0.0; |
| pl_tc.groupFinishConditionDetected := c_EPTF_LGenBase_emptyConditionTrue; |
| pl_tc.groupFinishConditionProcessed := c_EPTF_LGenBase_emptyConditionTrue; |
| pl_tc.sentMsgs := 0; |
| pl_tc.receivedAnswers := 0; |
| pl_tc.rangeIndex := 0; |
| for ( var integer vl_i := 0; vl_i < pl_tc.v_sizeofRanges ; vl_i := vl_i+1 ) |
| { |
| pl_tc.rangePosInRange[vl_i] := -1; |
| } |
| pl_tc.rangeLoops := 0; |
| //if invalid(<0) then the TC NOT running for the group |
| pl_tc.nrOfNotFinishedEntities := sizeof(pl_tc.entityInfo.itemList); |
| pl_tc.nrOfAllEntities := pl_tc.nrOfNotFinishedEntities; |
| if(pl_tc.entityInfo.entitySelection == round_robin) { |
| pl_tc.nrOfAvailableEntities := f_EPTF_FBQ_getLengthOfFreeChain(pl_tc.entityInfo.fbq); |
| } else { |
| pl_tc.nrOfAvailableEntities := f_EPTF_RNA_getLengthOfFreeList(pl_tc.entityInfo.rna); |
| } |
| pl_tc.minAvailable := pl_tc.nrOfAvailableEntities; |
| pl_tc.maxBusy := 0; |
| pl_tc.maxRunning := 0; |
| pl_tc.nrOfRunningEntities := 0; |
| pl_tc.stopped := false |
| //reset variables |
| var integer vl_eFirst := v_LGenBase_entityGroups[pl_tc.eGroupBackref].eOffset |
| var EPTF_TopProviderType vl_providerType; |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugFsmVars)){ |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": Entity#"&log2str(vl_i)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": fsmIdx: "&log2str(vl_fsmIdx)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": varList: "&log2str(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": declared: "&log2str(v_LGenBase_fsmTables[pl_tc.fsmIdx].varListArray[c_EPTF_LGenBase_fsmObjectScopeFSM])) |
| } |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList) ; vl_j := vl_j+1 ){ |
| f_EPTF_Var_getTopProviderType(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList[vl_j],vl_providerType) |
| if(empty == vl_providerType){ |
| f_EPTF_Var_adjustContent( |
| v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList[vl_j], |
| v_LGenBase_fsmTables[pl_tc.fsmList[vl_siblingIdx].fsmTypeIdx].varListArray[c_EPTF_LGenBase_fsmObjectScopeFSM][vl_j].initValue) |
| } |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.varList); i:=i+1) { |
| f_EPTF_Var_getTopProviderType(pl_tc.varList[i].varId,vl_providerType) |
| if(empty == vl_providerType){ |
| var integer vl_varIdxInFsm := pl_tc.varList[i].idxInFsm |
| var integer vl_fsmTable := pl_tc.fsmList[pl_tc.varList[i].siblingFsmIdx].fsmTypeIdx |
| f_EPTF_Var_adjustContent( |
| pl_tc.varList[i].varId, |
| v_LGenBase_fsmTables[vl_fsmTable].varListArray[c_EPTF_LGenBase_fsmObjectScopeTC][vl_varIdxInFsm].initValue) |
| } |
| } |
| //Disable stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_disableStat(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_disableStat(pl_tc.statMeasStatList[i].statId); |
| } |
| //Reset stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_initStatValue(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_initStatValue(pl_tc.statMeasStatList[i].statId); |
| } |
| //Enable stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_enableStat(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_enableStat(pl_tc.statMeasStatList[i].statId); |
| } |
| pl_tc.cpsOverrunCounter := 0 |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resetTcStatsData |
| // |
| // Purpose: |
| // Resets the statistics of a traffic case data |
| /////////////////////////////////////////////////////////// |
| // TR HR20548 - Reset All statistics button |
| // Same as f_EPTF_LGenBase_resetTcStats except |
| // the commented lines. |
| private function f_EPTF_LGenBase_resetTcStatsData( |
| in integer pl_tcIdx, |
| inout EPTF_LGenBase_TcDescriptor pl_tc) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": "&log2str(pl_tc)) |
| } |
| pl_tc.nrOfStarts := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfSuccesses := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfFails := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfErrors := 0; //cumulative stat for all entities of the entity group |
| pl_tc.nrOfTimeouts := 0; //cumulative stat for all entities of the entity group |
| pl_tc.grpLoop := 0; |
| |
| // pl_tc.schedulerData.lastBurstSize := 0; //EBENMOL |
| // if (pl_tc.schedulerData.burstFuncRef.burstCalcMode == c_EPTF_LGenBase_BurstCalc_poisson) { |
| // pl_tc.schedulerData.burstSizeCumulativeError := 0.0; |
| // pl_tc.schedulerData.idealBurstSize := 0.0; |
| // pl_tc.schedulerData.currentBurstSize := 0; |
| // pl_tc.schedulerData.roundedCpsUpdateInterval := 0.0; |
| // } |
| // // distribute the bursterror differently according to the traffic corrigation => smooth out cumulative bursts |
| // pl_tc.schedulerData.burstSizeCumulativeError := v_LGenBase_entityGroups[pl_tc.eGroupBackref].trafficCorrigation; |
| |
| |
| pl_tc.lastCPS := 0.0; |
| pl_tc.lastSent := 0; |
| pl_tc.currentSent := 0; |
| pl_tc.hasSent := false; |
| |
| pl_tc.lastCallTime := 0.0; |
| |
| // pl_tc.groupFinishConditionDetected := c_EPTF_LGenBase_emptyConditionTrue; |
| // pl_tc.groupFinishConditionProcessed := c_EPTF_LGenBase_emptyConditionTrue; |
| |
| pl_tc.sentMsgs := 0; |
| pl_tc.receivedAnswers := 0; |
| pl_tc.rangeIndex := 0; |
| for ( var integer vl_i := 0; vl_i < pl_tc.v_sizeofRanges ; vl_i := vl_i+1 ) |
| { |
| pl_tc.rangePosInRange[vl_i] := -1; |
| } |
| pl_tc.rangeLoops := 0; |
| //if invalid(<0) then the TC NOT running for the group |
| pl_tc.nrOfNotFinishedEntities := sizeof(pl_tc.entityInfo.itemList); |
| pl_tc.nrOfAllEntities := pl_tc.nrOfNotFinishedEntities; |
| if(pl_tc.entityInfo.entitySelection == round_robin) { |
| pl_tc.nrOfAvailableEntities := f_EPTF_FBQ_getLengthOfFreeChain(pl_tc.entityInfo.fbq); |
| } else { |
| pl_tc.nrOfAvailableEntities := f_EPTF_RNA_getLengthOfFreeList(pl_tc.entityInfo.rna); |
| } |
| |
| pl_tc.minAvailable := pl_tc.nrOfAvailableEntities; |
| pl_tc.maxBusy := 0; |
| pl_tc.maxRunning := 0; |
| pl_tc.nrOfRunningEntities := 0; |
| |
| // pl_tc.stopped := false |
| |
| //reset variables |
| var integer vl_eFirst := v_LGenBase_entityGroups[pl_tc.eGroupBackref].eOffset |
| var EPTF_TopProviderType vl_providerType |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugFsmVars)){ |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": Entity#"&log2str(vl_i)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": fsmIdx: "&log2str(vl_fsmIdx)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": varList: "&log2str(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList)) |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": declared: "&log2str(v_LGenBase_fsmTables[pl_tc.fsmIdx].varListArray[c_EPTF_LGenBase_fsmObjectScopeFSM])) |
| } |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList) ; vl_j := vl_j+1 ){ |
| f_EPTF_Var_getTopProviderType(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList[vl_j],vl_providerType) |
| if(empty == vl_providerType){ |
| f_EPTF_Var_adjustContent( |
| v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].varList[vl_j], |
| v_LGenBase_fsmTables[pl_tc.fsmList[vl_siblingIdx].fsmTypeIdx].varListArray[c_EPTF_LGenBase_fsmObjectScopeFSM][vl_j].initValue) |
| } |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.varList); i:=i+1) { |
| f_EPTF_Var_getTopProviderType(pl_tc.varList[i].varId,vl_providerType) |
| if(empty == vl_providerType){ |
| var integer vl_varIdxInFsm := pl_tc.varList[i].idxInFsm |
| var integer vl_fsmTable := pl_tc.fsmList[pl_tc.varList[i].siblingFsmIdx].fsmTypeIdx |
| f_EPTF_Var_adjustContent( |
| pl_tc.varList[i].varId, |
| v_LGenBase_fsmTables[vl_fsmTable].varListArray[c_EPTF_LGenBase_fsmObjectScopeTC][vl_varIdxInFsm].initValue) |
| } |
| } |
| //Disable stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_disableStat(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_disableStat(pl_tc.statMeasStatList[i].statId); |
| } |
| //Reset stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_initStatValue(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_initStatValue(pl_tc.statMeasStatList[i].statId); |
| } |
| //Enable stats |
| for(var integer vl_i := 0; vl_i < sizeof(pl_tc.entityInfo.itemList); vl_i := vl_i + 1){ |
| for ( var integer vl_siblingIdx := 0; vl_siblingIdx < sizeof(pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList) ; vl_siblingIdx := vl_siblingIdx+1 ) |
| { |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(vl_i,pl_tcIdx,vl_siblingIdx); |
| for ( var integer vl_j := 0; vl_j < sizeof(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList) ; vl_j := vl_j+1 ){ |
| f_EPTF_StatMeasure_enableStat(v_LGenBase_entities[vl_eFirst+vl_i].fsmCtxList[vl_fsmIdx].statMeasStatList[vl_j]) |
| } |
| } |
| } |
| for(var integer i:=0; i<sizeof(pl_tc.statMeasStatList); i:=i+1) { |
| f_EPTF_StatMeasure_enableStat(pl_tc.statMeasStatList[i].statId); |
| } |
| pl_tc.cpsOverrunCounter := 0; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_resetTcGroupFinishConditionDetected |
| // |
| // Purpose: |
| // Resets the groupFinishConditionDetected flags of a traffic case |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_resetTcGroupFinishConditionDetected( |
| in integer pl_tcIdx |
| ) runs on EPTF_LGenBase_Private_CT |
| { |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTrafficVerbose)){ |
| f_EPTF_LGenBase_loggingDebugTrafficVerbose(%definitionId&": "&log2str(v_LGenBase_trafficCases[pl_tcIdx])) |
| } |
| v_LGenBase_trafficCases[pl_tcIdx].groupFinishConditionDetected := c_EPTF_LGenBase_emptyConditionTrue; |
| //pl_tc.groupFinishConditionProcessed := c_EPTF_LGenBase_emptyConditionTrue; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_initTCInternal |
| // |
| // Purpose: |
| // Internal function to initialize the entities and the statistics of a traffic case |
| // |
| // Detailed Comments: |
| // To initialize a tc before restart, call <f_EPTF_LGenBase_restoreTC>. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_initTCInternal( |
| inout EPTF_LGenBase_TcDescriptor pl_tc, |
| in integer pl_tcIdx, |
| in boolean pl_enableEntities, |
| in boolean pl_create) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| var integer vl_maxEntities := v_LGenBase_entityGroups[pl_tc.eGroupBackref].eCount; |
| pl_tc.entityInfo.fbq := c_EPTF_emptyFreeBusyQueue; |
| pl_tc.entityInfo.rna := c_EPTF_RNA_emptyRandomNArray; |
| f_EPTF_FBQ_initFreeBusyQueue(pl_tc.entityInfo.fbq); |
| f_EPTF_FBQ_createFreeSlots(vl_maxEntities, pl_tc.entityInfo.fbq); |
| f_EPTF_RNA_initRFBA(vl_maxEntities, pl_tc.entityInfo.rna); |
| //Fill entities from group |
| for(var integer vl_i := 0; vl_i < vl_maxEntities; vl_i := vl_i + 1){ |
| var integer vl_absEIdx := v_LGenBase_entityGroups[pl_tc.eGroupBackref].eOffset+ vl_i; |
| if(pl_create){ |
| pl_tc.entityInfo.itemList[vl_i] := c_EPTF_LGenBase_emptyEntityItem; |
| pl_tc.entityInfo.itemList[vl_i].entityIdx := vl_absEIdx; |
| } else { |
| var EPTF_IntegerList vl_fsmCtxIdxList := pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList; |
| pl_tc.entityInfo.itemList[vl_i] := c_EPTF_LGenBase_emptyEntityItem; |
| pl_tc.entityInfo.itemList[vl_i].entityIdx := vl_absEIdx; |
| pl_tc.entityInfo.itemList[vl_i].siblingFsmCtxList := vl_fsmCtxIdxList; |
| } |
| |
| if(not pl_enableEntities){ |
| f_EPTF_FBQ_moveFromFreeToBusyTail(vl_i, pl_tc.entityInfo.fbq); |
| if(not f_EPTF_RNA_moveFromFreeToBusySlot(vl_i, pl_tc.entityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromFreeToBusySlot",false) |
| } |
| } |
| } |
| if(pl_create){ |
| //FSM list |
| //Create TC variable, stats hashmaps |
| f_EPTF_LGenBase_createTCHashmaps(pl_tc); |
| //Activate the FSMs |
| for ( var integer vl_fsm := 0; vl_fsm < sizeof(pl_tc.fsmList) ; vl_fsm := vl_fsm+1 ){ |
| v_LGenBase_dummyInt := f_EPTF_LGenBase_activateFsmGroup( |
| pl_tc.fsmList[vl_fsm].fsmTypeIdx, |
| c_EPTF_LGenBase_idleStateIndex, |
| {tcData := { |
| tcIdx := pl_tcIdx, |
| siblingIdx := vl_fsm |
| } |
| }) |
| } |
| //Register SiblingFSM stathandler providers |
| for ( var integer vl_i := 0; vl_i < sizeof(pl_tc.siblingStatHandlerStatList) ; vl_i := vl_i+1 ){ |
| for ( var integer vl_eRelIdx := 0; vl_eRelIdx < sizeof(pl_tc.entityInfo.itemList) ; vl_eRelIdx := vl_eRelIdx+1 ){ |
| var charstring vl_statName := f_EPTF_LGenBase_varNameOfSiblingFSMsVar(pl_tcIdx, vl_eRelIdx, pl_tc.siblingStatHandlerStatList[vl_i].statName); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugFsmVars)){ |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": Registering SiblingFSM statHandler providers for statHandler "&vl_statName& |
| " of traffic case "&pl_tc.uniqueName) |
| } |
| var integer vl_tableType := pl_tc.fsmList[pl_tc.siblingStatHandlerStatList[vl_i].siblingFsmIdx].fsmTypeIdx |
| f_EPTF_LGenBase_registerStatHandlerProviders( |
| v_LGenBase_fsmTables[vl_tableType].statisticListArray[c_EPTF_LGenBase_fsmObjectScopeSiblingFSM][vl_i].providers, |
| v_LGenBase_fsmTables[vl_tableType], |
| vl_tableType, |
| pl_tcIdx, |
| vl_statName, |
| c_EPTF_LGenBase_fsmObjectScopeSiblingFSM, |
| pl_tc.siblingStatHandlerStatList[vl_i].siblingFsmIdx, |
| vl_eRelIdx) |
| } |
| } |
| |
| //Register TC stathandler providers |
| for ( var integer vl_i := 0; vl_i < sizeof(pl_tc.statHandlerStatList) ; vl_i := vl_i+1 ) |
| { |
| var charstring vl_statName := f_EPTF_LGenBase_varNameOfTCVar(pl_tcIdx, pl_tc.statHandlerStatList[vl_i].statName); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugFsmVars)){ |
| f_EPTF_LGenBase_loggingDebugFsmVars(%definitionId&": Registering TC statHandler providers for statHandler "&vl_statName& |
| " of traffic case "&pl_tc.uniqueName) |
| } |
| var integer vl_tableType := pl_tc.fsmList[pl_tc.statHandlerStatList[vl_i].siblingFsmIdx].fsmTypeIdx |
| f_EPTF_LGenBase_registerStatHandlerProviders( |
| v_LGenBase_fsmTables[vl_tableType].statisticListArray[c_EPTF_LGenBase_fsmObjectScopeTC][vl_i].providers, |
| v_LGenBase_fsmTables[vl_tableType], |
| vl_tableType, |
| pl_tcIdx, |
| vl_statName, |
| c_EPTF_LGenBase_fsmObjectScopeTC, |
| pl_tc.statHandlerStatList[vl_i].siblingFsmIdx) |
| } |
| |
| //Set referred sibling indexes |
| for ( var integer vl_sibling := 0; vl_sibling < sizeof(pl_tc.fsmList) ; vl_sibling := vl_sibling+1 ){ |
| for ( var integer vl_fsmRef := 0; vl_fsmRef < sizeof(v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].referredFsmList) ; vl_fsmRef := vl_fsmRef+1 ){ |
| var charstring vl_flReferredSiblingName := v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].referredFsmList[vl_fsmRef] |
| var integer vl_referredSiblingIdx := -1 |
| for ( var integer vl_i := 0; vl_i < sizeof(pl_tc.fsmList) and vl_referredSiblingIdx == -1; vl_i := vl_i+1 ){ |
| if(vl_flReferredSiblingName == pl_tc.fsmList[vl_i].siblingName){ |
| vl_referredSiblingIdx := vl_i |
| } |
| } |
| if(0 > vl_referredSiblingIdx){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": There is no sibling FSM "& |
| v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].referredFsmList[vl_fsmRef]& |
| " in the traffic case "&pl_tc.uniqueName& |
| " in the FSM "&v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].name); |
| } |
| pl_tc.referredFsmIdxsInSiblings[vl_sibling][vl_fsmRef] := vl_referredSiblingIdx |
| } |
| |
| for ( var integer vl_siblingTC := 0; vl_siblingTC < sizeof(v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].referredTCList) ; vl_siblingTC := vl_siblingTC+1 ){ |
| var charstring vl_flReferredTCName := v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].referredTCList[vl_siblingTC]; |
| var integer vl_referredTCIdx := -1; |
| var integer vl_scIdx := f_EPTF_LGenBase_scenarioNameIndex(v_LGenBase_entityGroups[pl_tc.eGroupBackref].scenarios[pl_tc.eScenarioBackRef].name); |
| for ( var integer vl_idx := 0; vl_idx < sizeof(v_LGenBase_scenarioTypes[vl_scIdx].tcList) and vl_referredTCIdx == -1; vl_idx := vl_idx+1 ){ |
| if (v_LGenBase_scenarioTypes[vl_scIdx].tcList[vl_idx].tcPrivateName == vl_flReferredTCName){ |
| vl_referredTCIdx := vl_idx; |
| } |
| } |
| if(0 > vl_referredTCIdx){ |
| f_EPTF_LGenBase_loggingError(%definitionId&": There is no traffic case "& |
| vl_flReferredTCName& |
| " in the scenario "&v_LGenBase_entityGroups[pl_tc.eGroupBackref].scenarios[pl_tc.eScenarioBackRef].name& |
| " in the FSM "&v_LGenBase_fsmTables[pl_tc.fsmList[vl_sibling].fsmTypeIdx].name); |
| } |
| pl_tc.referredTCIdxsInSiblings[vl_sibling][vl_siblingTC] := vl_referredTCIdx; |
| } |
| } |
| |
| pl_tc.fsmIdx := pl_tc.fsmList[0].fsmTypeIdx |
| f_EPTF_LGenBase_deleteTCHashmaps(pl_tcIdx); |
| } |
| pl_tc.state := c_EPTF_LGenBase_tcStateIdle; |
| f_EPTF_LGenBase_resetTcStats(pl_tcIdx, pl_tc); |
| } |
| |
| friend function f_EPTF_LGenBase_createTCHashmaps( |
| inout EPTF_LGenBase_TcDescriptor pl_tc ) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| pl_tc.TCVarNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_tcVarsHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.SiblingFSMVarNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_siblingFsmVarsHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.FSMVarNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_fsmVarsHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.TCStatMeasNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_tcStatmeasHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.SiblingFSMStatMeasNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_siblingFsmStatmeasHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.FSMStatMeasNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_fsmStatmeasHashmapPrefix&pl_tc.uniqueName); |
| pl_tc.TCStatHandlerNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_tcStatHandlerHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.SiblingFSMStatHandlerNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_siblingFsmStatHandlerHashmapPrefix&pl_tc.uniqueName) |
| pl_tc.FSMStatHandlerNamesHash := f_EPTF_str2int_HashMap_New(c_EPTF_LGenBase_fsmStatHandlerHashmapPrefix&pl_tc.uniqueName); |
| } |
| |
| friend function f_EPTF_LGenBase_deleteTCHashmaps( |
| in integer pl_tcIdx ) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].TCVarNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_tcVarsHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].TCVarNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMVarNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_siblingFsmVarsHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMVarNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].FSMVarNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_fsmVarsHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].FSMVarNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].TCStatMeasNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_tcStatmeasHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].TCStatMeasNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMStatMeasNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_siblingFsmStatmeasHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMStatMeasNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].FSMStatMeasNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_fsmStatmeasHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| v_LGenBase_trafficCases[pl_tcIdx].FSMStatMeasNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].TCStatHandlerNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_tcStatHandlerHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].TCStatHandlerNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMStatHandlerNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_siblingFsmStatHandlerHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName) |
| v_LGenBase_trafficCases[pl_tcIdx].SiblingFSMStatHandlerNamesHash := -1; |
| } |
| if(-1 < v_LGenBase_trafficCases[pl_tcIdx].FSMStatHandlerNamesHash){ |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_LGenBase_fsmStatHandlerHashmapPrefix&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| v_LGenBase_trafficCases[pl_tcIdx].FSMStatHandlerNamesHash := -1; |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_enableTrafficCaseInternal |
| // |
| // Purpose: |
| // Enables a traffic case |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_enableTrafficCaseInternal( |
| in integer pl_tcIdx, |
| in boolean pl_start := true) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Enable traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| v_LGenBase_trafficCases[pl_tcIdx].enabled := true; |
| if(pl_start ){ |
| f_EPTF_LGenBase_startLaunchTC(pl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopTcTimerInternal |
| // |
| // Purpose: |
| // Cancels the periodic timer event of a traffic case if it's scheduled |
| // |
| // Return Value: |
| // True if the traffic case had run before calling the function |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_stopTcTimerInternal( |
| inout EPTF_LGenBase_TcDescriptor pl_tc |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| //Remove next timer event, if exists |
| if(-1 != pl_tc.schedulingTimer){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": timer of tc "&pl_tc.uniqueName&" == "&int2str(pl_tc.schedulingTimer)) |
| if(not f_EPTF_SchedulerComp_CancelEvent(pl_tc.schedulingTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": cancelling timer failed."); |
| return false; |
| } |
| pl_tc.schedulingTimer := -1; |
| return true; |
| } |
| return true; |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_stopScTimerInternal |
| // |
| // Purpose: |
| // Cancels the periodic timer event of a scenario if it's scheduled |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_stopScTimerInternal( |
| in integer pl_eGrpIdx, |
| in integer pl_scInGrpIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| //Remove next timer event, if exists |
| if(-1 != v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": timer of "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].uniqueName& |
| " == "&log2str(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer)) |
| if(not f_EPTF_SchedulerComp_CancelEvent( |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer)) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&" Cancelling timer failed."); |
| } |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scInGrpIdx].schedulerData.schedulingTimer := -1; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_disableTrafficCaseInternal |
| // |
| // Purpose: |
| // Disables a traffic case |
| // |
| // Detailed Comments: |
| // Also removes events in the event queu related to the traffic case, |
| // dispatches a <c_EPTF_LGenBase_inputIdx_testMgmt_trafficCaseStopped> |
| // generic event and checks launch finish conditions. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_disableTrafficCaseInternal( |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT{ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Disable traffic case "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| //Remove next timer event, if exists |
| if(not f_EPTF_LGenBase_stopTcTimerInternal(v_LGenBase_trafficCases[pl_tcIdx])) { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": Could not stop traffic case timer for traffic case "& |
| v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| var boolean vn_enabled := v_LGenBase_trafficCases[pl_tcIdx].enabled; |
| v_LGenBase_trafficCases[pl_tcIdx].enabled := false; |
| if(c_EPTF_LGenBase_tcStateRunning == v_LGenBase_trafficCases[pl_tcIdx].state or |
| c_EPTF_LGenBase_tcStatePaused == v_LGenBase_trafficCases[pl_tcIdx].state){ |
| //Stop if it was running //--enabled-- |
| //if(v_LGenBase_trafficCases[pl_tcIdx].enabled){ |
| f_EPTF_LGenBase_dispatchEvent({ |
| event := { |
| bIdx := c_EPTF_LGenBase_bIdx, |
| iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_trafficCaseStopped, |
| target := omit, |
| source := omit |
| }, |
| reportedArgs := {pl_tcIdx} |
| }); |
| f_EPTF_LGenBase_tcStateChanged(pl_tcIdx); |
| for ( var integer vl_i := 0; vl_i < sizeof(v_LGenBase_tcStartedOrStoppedCallbacks) ; vl_i := vl_i+1 ) |
| { |
| v_LGenBase_tcStartedOrStoppedCallbacks[vl_i].apply( pl_tcIdx, false ); |
| } |
| }else{ |
| var integer vl_eGrpIdx := v_LGenBase_trafficCases[pl_tcIdx].eGroupBackref; |
| var integer vl_scIdx := v_LGenBase_trafficCases[pl_tcIdx].eScenarioBackRef; |
| if(vn_enabled and f_EPTF_LGenBase_isWeightedScenario(vl_eGrpIdx, vl_scIdx)) |
| { |
| var boolean vl_mixerAcceptsMix := f_EPTF_TrafficMixer_acceptNewTrafficMix( |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].trafficMixData, |
| f_EPTF_LGenBase_getEnabledWeightListFromScenario(vl_eGrpIdx,vl_scIdx), |
| v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].weightedScData.deterministicMix |
| ) |
| f_EPTF_Base_assert(%definitionId&": initializing traffic mix for TC in weighted SC "&v_LGenBase_entityGroups[vl_eGrpIdx].scenarios[vl_scIdx].name& ": mixer has not accepted traffic mix", |
| vl_mixerAcceptsMix); |
| } |
| } |
| f_EPTF_LGenBase_checkLaunchFinished(pl_tcIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_startEntityInternal |
| // |
| // Purpose: |
| // Processes the start of an entity. |
| // |
| // Parameters: |
| // pl_tcDesc - *in* <EPTF_LGenBase_TcDescriptor> - The appropriate tc descriptor in <v_LGenBase_trafficCases>. |
| // pl_tcIdx - *in* *integer* - The index of traffic case |
| // pl_eIdxInTC - *in* *integer* - The relative index of the entity |
| // pl_dispatchStartEvent - *in* *boolean* - Whether the c_EPTF_LGenBase_inputIdx_testMgmt_startTC |
| // event should be dispatched or not. |
| // |
| // Return Value: |
| // Returns true if a group finish condition mutches. |
| // |
| // Detailed Comments: |
| // Administers the start of an entity. If the pl_dispatchStartEvent == true, |
| // dispatches the c_EPTF_LGenBase_inputIdx_testMgmt_startTC |
| // FSM event and changes the statistics of the traffic case. |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_startEntityInternal( |
| inout EPTF_LGenBase_TcDescriptor pl_tcDesc, |
| in integer pl_tcIdx, |
| in integer pl_eIdxInTC, |
| in boolean pl_dispatchStartEvent, |
| out EPTF_LGenBase_ConditionTrue pl_finished, |
| in boolean pl_singleShotDebug := false, |
| in integer pl_logBufferVar := -1 |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": pl_dispatchStartEvent == "&log2str(pl_dispatchStartEvent)) |
| pl_finished := c_EPTF_LGenBase_emptyConditionTrue |
| var integer vl_eIdx := pl_tcDesc.entityInfo.itemList[pl_eIdxInTC].entityIdx; |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| f_EPTF_FBQ_moveFromFreeToBusyTail(pl_eIdxInTC, pl_tcDesc.entityInfo.fbq); |
| } else { |
| if(not f_EPTF_RNA_moveFromFreeToBusySlot(pl_eIdxInTC, pl_tcDesc.entityInfo.rna)){ |
| f_EPTF_Base_assert(%definitionId&": Error in f_EPTF_RNA_moveFromFreeToBusySlot",false) |
| } |
| } |
| //Statistics |
| //We must set it before dispatching the start event, because during its process it could be counted |
| pl_tcDesc.entityInfo.itemList[pl_eIdxInTC].nrOfStarts := |
| pl_tcDesc.entityInfo.itemList[pl_eIdxInTC].nrOfStarts + 1; |
| pl_tcDesc.nrOfStarts := pl_tcDesc.nrOfStarts + 1; |
| var integer vl_fsmIdx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(pl_eIdxInTC,pl_tcIdx,0); |
| Inc(pl_tcDesc.sentMsgs); |
| Dec(pl_tcDesc.nrOfAvailableEntities); |
| SetIfLt(pl_tcDesc.minAvailable, pl_tcDesc.nrOfAvailableEntities); |
| if(v_LGenBase_trafficCases[pl_tcIdx].entityInfo.entitySelection == round_robin) { |
| SetIfGt(pl_tcDesc.maxBusy,f_EPTF_FBQ_getLengthOfBusyChain(pl_tcDesc.entityInfo.fbq)); |
| } else { |
| SetIfGt(pl_tcDesc.maxBusy,f_EPTF_RNA_getLengthOfBusyList(pl_tcDesc.entityInfo.rna)); |
| } |
| Inc(pl_tcDesc.nrOfRunningEntities); |
| SetIfGt(pl_tcDesc.maxRunning,pl_tcDesc.nrOfRunningEntities); |
| var EPTF_IntegerList vl_trafficParam; |
| f_EPTF_LGenBase_getNextRangeParam(pl_tcDesc, pl_tcIdx, vl_trafficParam); |
| pl_tcDesc.entityInfo.itemList[pl_eIdxInTC].startTime := T_EPTF_componentClock.read |
| pl_tcDesc.entityInfo.itemList[pl_eIdxInTC].isRunning := true |
| if(pl_singleShotDebug){ |
| v_LGenBase_entities[vl_eIdx].fsmCtxList[vl_fsmIdx].singleShotDebugLog := true |
| v_LGenBase_entities[vl_eIdx].fsmCtxList[vl_fsmIdx].singleShotLogBufferVariable := pl_logBufferVar |
| } |
| f_EPTF_LGenBaseStats_trafficStartedCallback( pl_tcIdx, vl_eIdx ) |
| for ( var integer vl_cb := 0; vl_cb < sizeof(v_LGenBase_trafficStarted_FTList) ; vl_cb := vl_cb+1 ) |
| { |
| v_LGenBase_trafficStarted_FTList[vl_cb].apply( pl_tcIdx, vl_eIdx ); |
| } |
| |
| if(v_LGenBase_ILog_enableILog){ |
| var integer vl_fsmCtxIdx := f_EPTF_LGenBase_getFSMCtxIdx(vl_eIdx, pl_tcIdx); |
| f_EPTF_LGenBase_ILog_newChains( vl_eIdx, vl_fsmCtxIdx, |
| refers(f_EPTF_LGenBase_ILog_logHeaderDetailed), {vl_eIdx, vl_fsmCtxIdx}, |
| refers(f_EPTF_LGenBase_ILog_logHeaderShort), {vl_eIdx, vl_fsmCtxIdx}); |
| } |
| if(pl_dispatchStartEvent){ |
| //Dispatch start event to FSM |
| var integer vl_targetFsmCtx := f_EPTF_LGenBase_fsmCtxIdxOfSiblingInTc(pl_eIdxInTC, pl_tcIdx,0); |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId& |
| log2str(": " |
| ,"\nEntity#", vl_eIdx |
| ,"\nsmIdx: ", pl_tcDesc.fsmIdx |
| ,"\nTC: ",v_LGenBase_trafficCases[pl_tcIdx].uniqueName |
| ,"\nFSM Ctx idx: ",vl_targetFsmCtx |
| ,"\nParameter: ",vl_trafficParam)) |
| } |
| var EPTF_LGenBase_ReportedEventDescriptor vl_startTcOfFsmEvent := c_EPTF_LGenBase_emptyReportedEventDescriptor; |
| vl_startTcOfFsmEvent.event.bIdx := c_EPTF_LGenBase_bIdx; |
| vl_startTcOfFsmEvent.event.iIdx := c_EPTF_LGenBase_inputIdx_testMgmt_startTC; |
| vl_startTcOfFsmEvent.event.target := { |
| eIdx := vl_eIdx, |
| fsmCtxIdx := vl_targetFsmCtx |
| }; |
| vl_startTcOfFsmEvent.reportedArgs := vl_trafficParam; |
| f_EPTF_LGenBase_dispatchEvent(vl_startTcOfFsmEvent); |
| } |
| if(ispresent(pl_tcDesc.trafficStartFinishConditionsAndActions.nrOfExecStart) and |
| v_LGenBase_groupFinishConditionMask.nrOfExecStart and |
| pl_tcDesc.trafficStartFinishConditionsAndActions.nrOfExecStart.count <= pl_tcDesc.nrOfStarts){ |
| pl_finished.nrOfExecStart := true; |
| pl_finished.anythingFinished := true; |
| } |
| if( ispresent(pl_tcDesc.trafficStartFinishConditionsAndActions.nrOfRangeLoop) and |
| v_LGenBase_groupFinishConditionMask.nrOfRangeLoop and |
| pl_tcDesc.trafficStartFinishConditionsAndActions.nrOfRangeLoop.count <= pl_tcDesc.rangeLoops){ |
| pl_finished.nrOfRangeLoop := true; |
| pl_finished.anythingFinished := true; |
| } |
| |
| return pl_finished.anythingFinished; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_processStartStep |
| // |
| // Purpose: |
| // Internal function to execute the <f_EPTF_LGenBase_startEntityInternal> function from the |
| // <f_EPTF_LGenBase_step_recordEntityStart> or |
| // <f_EPTF_LGenBase_step_startEntity> functions. |
| // |
| // Parameters: |
| // pl_ptr - *in* - *EPTF_LGenBase_TestStepArgs* - step arguments |
| // pl_dispatchStartEvent - *in* *boolean* - Whether the c_EPTF_LGenBase_inputIdx_testMgmt_startTC |
| // event should be dispatched or not. |
| // |
| // Return Value: |
| // Returns false if the entity is busy |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_processStartStep( |
| in EPTF_LGenBase_TestStepArgs pl_ptr, |
| in boolean pl_dispatchStartEvent |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| var integer vl_entityIdx := pl_ptr.eIdx; |
| var integer vl_tcIdx := f_EPTF_LGenBase_tcIdxOfStep(pl_ptr); |
| var integer vl_entityInTcFBQIdx := vl_entityIdx - v_LGenBase_entityGroups[v_LGenBase_trafficCases[vl_tcIdx].eGroupBackref].eOffset |
| return f_EPTF_LGenBase_doStartStep(vl_entityInTcFBQIdx, vl_tcIdx, pl_dispatchStartEvent); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_doStartStep |
| // |
| // Purpose: |
| // Starts a traffic on the entity of a traffic case |
| // |
| // Return Value: |
| // Returns false if the entity is busy |
| // |
| // Detailed Comments: |
| // Calls the <f_EPTF_LGenBase_startEntityInternal> function |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBase_doStartStep( |
| in integer pl_eRelIdx, |
| in integer pl_tcIdx, |
| in boolean pl_dispatchStartEvent, |
| in boolean pl_singleShotDebug := false, |
| in integer pl_logBufferVar := -1 |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean |
| { |
| if (c_EPTF_Common_debugSwitch and f_EPTF_LGenBase_isEnabled(c_EPTF_LGenBase_loggingClassIdx_DebugTraffic)){ |
| f_EPTF_LGenBase_loggingDebugTraffic(log2str("eRelIdx == ",pl_eRelIdx)) |
| f_EPTF_LGenBase_loggingDebugTraffic("tc == "&v_LGenBase_trafficCases[pl_tcIdx].uniqueName); |
| } |
| if(not f_EPTF_LGenBase_entityIsBusy(pl_eRelIdx, pl_tcIdx)){ |
| if(f_EPTF_LGenBase_startEntityInternal( |
| v_LGenBase_trafficCases[pl_tcIdx], |
| pl_tcIdx, |
| pl_eRelIdx, |
| pl_dispatchStartEvent, |
| v_LGenBase_tempFinishedRec, |
| pl_singleShotDebug, |
| pl_logBufferVar)){ |
| f_EPTF_LGenBase_groupFinishedDetected(pl_tcIdx, v_LGenBase_tempFinishedRec); |
| } |
| }else{ |
| f_EPTF_LGenBase_loggingWarning(%definitionId&": StartStep called but entiy#"&int2str(pl_eRelIdx)&" in traffic case "& |
| v_LGenBase_trafficCases[pl_tcIdx].uniqueName&" ("&int2str(pl_tcIdx)&") is busy!") |
| return false; |
| } |
| return true; |
| } |
| |
| }//PrivateStartStopInit |
| |
| /////////////////////////////////////////////////////////// |
| // function: f_EPTF_LGenBase_setGroupFinishedPerConditionFn |
| // |
| // Purpose: |
| // Convenient function for the <ExecCtrl> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setGroupFinishedPerConditionFn( |
| in EPTF_LGenBase_groupFinishedPerCondition_FT pl_fn |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_groupFinishedPerCondition_FT{ |
| var EPTF_LGenBase_groupFinishedPerCondition_FT vl_retVal := v_LGenBase_groupFinishedPerConditionFn |
| v_LGenBase_groupFinishedPerConditionFn := pl_fn |
| return vl_retVal |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // function: f_EPTF_LGenBase_setGroupFinishedDetectedFn |
| // |
| // Purpose: |
| // Convenient function for the <ExecCtrl> |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBase_setGroupFinishedDetectedFn( |
| in EPTF_LGenBase_GroupFinishedDetected_FT pl_fn |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_GroupFinishedDetected_FT{ |
| var EPTF_LGenBase_GroupFinishedDetected_FT vl_retVal := v_LGenBase_groupFinishedDetectedFn |
| v_LGenBase_groupFinishedDetectedFn := pl_fn |
| return vl_retVal |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // function: f_EPTF_LGenBase_setGroupFinishedPerConditionFn |
| // |
| // Purpose: |
| // Convenient function for the <ExecCtrl> |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_setGroupFinishedFn( |
| in EPTF_LGenBase_groupFinished_FT pl_fn |
| ) |
| runs on EPTF_LGenBase_Private_CT |
| return EPTF_LGenBase_groupFinished_FT{ |
| var EPTF_LGenBase_groupFinished_FT vl_retVal := v_LGenBase_groupFinishedFn |
| v_LGenBase_groupFinishedFn := pl_fn |
| return vl_retVal |
| } |
| }//PrivateFunctions |
| /////////////////////////////////////////////////////////// |
| // Group: PrivateFunctions |
| // |
| // Purpose: |
| // The private functions of the EPTF_LGenBaseStats feature |
| // Don't use them from outside of EPTF_LGenBaseStats |
| // |
| /////////////////////////////////////////////////////////// |
| group PrivateStatsFunctions{ |
| |
| /////////////////////////////////////////////////////////// |
| // Group: LGenBase_specific |
| // |
| // Purpose: |
| // Functions to retrive/convert/calculate values from the component |
| // variables of the LGenBase |
| /////////////////////////////////////////////////////////// |
| group LGenBase_specific{ |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_createStatVarsOfTC |
| // |
| // Purpose: |
| // Creates the statistical variables of a TC |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_createStatVarsOfTC( |
| inout EPTF_LGenBase_TcDescriptor pl_tc, |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in integer pl_tcIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Base_assert(%definitionId&": "&"Invalid traffic case index: "&int2str(pl_tcIdx),pl_tcIdx == sizeof(v_LGenBaseStats_trafficCases)); |
| v_LGenBaseStats_trafficCases[sizeof(v_LGenBaseStats_trafficCases)] := c_EPTF_LGenBaseStats_emptyTcDescriptor |
| var charstring vl_tcName := pl_tc.privateName; |
| f_EPTF_Base_assert(%definitionId&": "&"Traffic case name "&vl_tcName& |
| " contains the separator "&tsp_LGenBase_nameSeparator, |
| f_EPTF_LGenBase_checkName(vl_tcName)); |
| var charstring vl_varNameBase := f_EPTF_LGenBase_getNamePrefix(pl_eGrpName,pl_scName,pl_tc.privateName); |
| var integer vl_temp := 0; |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfStarts, pl_tc.nrOfStarts, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_resetOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfStarts := vl_temp; |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfSuccesses, pl_tc.nrOfSuccesses, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_resetOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfSuccesses := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfFails, pl_tc.nrOfFails, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_resetOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfFails := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfErrors, pl_tc.nrOfErrors, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_resetOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfErrors := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfTimeouts, pl_tc.nrOfTimeouts, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_resetOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfTimeouts := vl_temp |
| |
| f_EPTF_Var_newInt(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfAllEntities, pl_tc.nrOfAllEntities, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfAllEntities := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfRunningEntities, pl_tc.nrOfRunningEntities, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfRunningEntities := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfAvailableEntities, pl_tc.nrOfAvailableEntities, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfAvailableEntities := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcMinAvailable, pl_tc.minAvailable, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcMinAvailable := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcMaxRunning,pl_tc.maxRunning, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcMaxRunning := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcMaxBusy,pl_tc.maxBusy, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcMaxBusy := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcNrOfNotFinishedEntities, pl_tc.nrOfNotFinishedEntities, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcNrOfNotFinishedEntities := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcState, pl_tc.state, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcState := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcSentMessages, pl_tc.sentMsgs, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcSentMessages := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcReceivedAnswers, pl_tc.receivedAnswers, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcReceivedAnswers := vl_temp |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcRangeLoops, pl_tc.rangeLoops, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcRangeLoops := vl_temp |
| |
| if(f_EPTF_LGenBase_isWeightedScenario(pl_tc.eGroupBackref, pl_tc.eScenarioBackRef)){ |
| f_EPTF_Var_newFloatRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcWeight, pl_tc.schedulerData.target.trafficWeight, vl_temp); |
| f_EPTF_Var_addPostProcFn(vl_temp, {refers(f_EPTF_LGenBaseStats_tcWeightChanged),{pl_tcIdx}}); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_floatPositiveOrZeroGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcWeight := vl_temp |
| |
| f_EPTF_Var_newFloat(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach, 0.0, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcCpsToReach := vl_temp |
| }else{ |
| f_EPTF_Var_newFloatRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach, pl_tc.schedulerData.target.cpsToReach, vl_temp); |
| f_EPTF_Var_addPostProcFn(vl_temp, {refers(f_EPTF_LGenBaseStats_tcCpsChanged),{pl_tcIdx}}); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_floatPositiveOrZeroGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcCpsToReach := vl_temp |
| |
| f_EPTF_Var_newFloat(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcWeight, 0.0, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcWeight := vl_temp |
| } |
| f_EPTF_Var_newFloat(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcLastCps, 0.0, vl_temp); |
| //f_EPTF_Var_subscribeLocal(vl_temp, {{refers(f_EPTF_LGenBaseStats_calcCPSSubs),{},{pl_tcIdx}}}); |
| v_LGenBaseStats_lastCpsVarList[pl_tcIdx] := vl_temp; |
| //v_LGenBaseStats_lastCPSCalcTimeList[pl_tcIdx] := 0.0; |
| //f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| //f_EPTF_Var_newInt(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcLastCalls, 0.0, vl_temp); |
| v_LGenBaseStats_lastCallsList[pl_tcIdx] := 0; |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcLastCps := vl_temp |
| |
| //f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| f_EPTF_Var_newCharstringRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcUserData, pl_tc.userData, vl_temp); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcUserData := vl_temp |
| |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcName, pl_tc.privateName, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcName := vl_temp |
| |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcUniqueName, pl_tc.uniqueName, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcUniqueName := vl_temp |
| |
| f_EPTF_Var_newBoolRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcEnabled, pl_tc.enabled, vl_temp); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcEnabled := vl_temp |
| |
| //f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcStateName, "", vl_temp); |
| f_EPTF_Var_subscribeLocal(vl_temp, {{refers(f_EPTF_LGenBaseStats_tcStateName),{},{pl_tcIdx}}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcStateName := vl_temp |
| |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcTrafficType, |
| c_EPTF_LGenBase_trafficTypeNames[enum2int(v_LGenBase_trafficCases[pl_tcIdx].trafficType)], |
| vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| v_LGenBaseStats_trafficCases[pl_tcIdx].varIdxOfTcTrafficType := vl_temp |
| |
| f_EPTF_Var_newBool(vl_varNameBase& c_LGenBase_dataElementTcEnabledAtStartup, pl_tc.enabledAtStartup, vl_temp); |
| f_EPTF_Var_addSyncCallBackFn(refers(f_EPTF_LGenBaseStats_EnabledUpdate), {pl_tcIdx, vl_temp}); |
| f_EPTF_Var_addPostProcFn(vl_temp,{refers(f_EPTF_LGenBaseStats_EnabledCallback), {pl_tcIdx, vl_temp} }); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_createScenarioVars |
| // |
| // Purpose: |
| // Creates the statistical variables of a scenario. |
| // Calls the <f_EPTF_LGenBaseStats_createStatVarsOfTC> |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_createScenarioVars( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].uniqueName); |
| var integer vl_tcCount := sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList); |
| var charstring vl_eGrpName := v_LGenBase_entityGroups[pl_eGrpIdx].name; |
| f_EPTF_Base_assert(%definitionId&": "&"Entity group name "&vl_eGrpName&" contains the separator "& |
| tsp_LGenBase_nameSeparator, |
| f_EPTF_LGenBase_checkName(vl_eGrpName)); |
| var charstring vl_scName := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].name; |
| f_EPTF_Base_assert(%definitionId&": Scenario name "&vl_scName& |
| " contains the separator "&tsp_LGenBase_nameSeparator, |
| f_EPTF_LGenBase_checkName(vl_scName)); |
| var charstring vl_varNameBase := f_EPTF_LGenBase_getScNamePrefix(vl_eGrpName,vl_scName); |
| var integer vl_temp; |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScName, v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].uniqueName, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| |
| f_EPTF_Var_newIntRef(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScState, v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].state, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| |
| f_EPTF_Var_newBoolRef( |
| vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScEnabled, |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].enabled, |
| vl_temp); |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScStateName, "", vl_temp); |
| f_EPTF_Var_subscribeLocal(vl_temp, {{refers(f_EPTF_LGenBaseStats_scStateName),{},{pl_eGrpIdx, pl_scIdx}}}); |
| |
| f_EPTF_Var_newCharstring(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcTrafficType, "", vl_temp); |
| f_EPTF_Var_subscribeLocal(vl_temp, {{refers(f_EPTF_LGenBaseStats_scTrafficType),{},{pl_eGrpIdx, pl_scIdx}}}); |
| |
| if(f_EPTF_LGenBase_isWeightedScenario(pl_eGrpIdx, pl_scIdx)){ |
| f_EPTF_Var_newFloatRef( |
| vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach, |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].schedulerData.target.cpsToReach, |
| vl_temp); |
| f_EPTF_Var_addPostProcFn(vl_temp, {refers(f_EPTF_LGenBaseStats_scCpsChanged),{pl_eGrpIdx, pl_scIdx}}); |
| f_EPTF_Var_addGuardFn(vl_temp, {refers(f_EPTF_LGenBaseStats_floatPositiveOrZeroGuard),{}}); |
| f_EPTF_Var_newBoolRef( |
| vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScLockCPS, |
| v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].lockCPS, |
| vl_temp); |
| }else{ |
| f_EPTF_Var_newFloat(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcCpsToReach, 0.0, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| f_EPTF_Var_newBool( vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScLockCPS, false, vl_temp); |
| f_EPTF_Var_addGuardFn( vl_temp, {refers(f_EPTF_LGenBaseStats_readOnlyGuard),{}}); |
| } |
| for ( var integer vl_i := 0; vl_i < vl_tcCount ; vl_i := vl_i+1 ) |
| { |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].tcIdxList[vl_i]; |
| f_EPTF_LGenBaseStats_createStatVarsOfTC( |
| v_LGenBase_trafficCases[vl_tcIdx], |
| vl_eGrpName, |
| vl_scName, |
| vl_tcIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_createScenarioVarsOfEG |
| // |
| // Purpose: |
| // Creates the statistical variables of the scenarios of an entity group. |
| // Calls the <f_EPTF_LGenBaseStats_createScenarioVars> |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_createScenarioVarsOfEG( |
| in integer pl_eGrpIdx |
| ) |
| runs on EPTF_LGenBase_Private_CT { |
| for ( var integer vl_scIdx := 0; vl_scIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios) ; vl_scIdx := vl_scIdx+1 ) |
| { |
| f_EPTF_LGenBaseStats_createScenarioVars(pl_eGrpIdx, vl_scIdx) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_tcWeightChanged |
| // |
| // Purpose: |
| // Postproc function when a weight of a TC changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_tcWeightChanged( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { |
| var EPTF_Var_DirectContent vl_currentContent; |
| f_EPTF_Var_getContent(pl_idx,vl_currentContent); |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setTcWeight(pl_argList[0],vl_currentContent.floatVal); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_scWeightChanged |
| // |
| // Purpose: |
| // Postproc function when a weight of a scenario changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_scWeightChanged( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { |
| var EPTF_Var_DirectContent vl_currentContent; |
| f_EPTF_Var_getContent(pl_idx,vl_currentContent); |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setScenarioCPSByIdx(pl_argList[0],pl_argList[1],vl_currentContent.floatVal); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_tcCpsChanged |
| // |
| // Purpose: |
| // Postproc function when a CPS of a TC changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_tcCpsChanged( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_LGenBase_loggingDebugTraffic(%definitionId&": "&v_LGenBase_trafficCases[pl_argList[0]].uniqueName&" schedulingTimer == "&log2str(v_LGenBase_trafficCases[pl_argList[0]].schedulingTimer)); |
| var EPTF_Var_DirectContent vl_Content |
| f_EPTF_Var_getContent(pl_idx, vl_Content) |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setCPS(pl_argList[0], vl_Content.floatVal) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_scCpsChanged |
| // |
| // Purpose: |
| // Postproc function when a CPS of a scenario changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_scCpsChanged( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| return; |
| } |
| var EPTF_Var_DirectContent vl_currentContent; |
| f_EPTF_Var_getContent(pl_idx,vl_currentContent); |
| v_LGenBase_dummyFloat := f_EPTF_LGenBase_setScenarioCPSByIdx(pl_argList[0], pl_argList[1], vl_currentContent.floatVal, true); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_tcStateName |
| // |
| // Purpose: |
| // Returns the text format of the state of the specified TC |
| // |
| // Detailed Comments: |
| // Calc function |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_tcStateName( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| pl_retVal.charstringVal:=""; |
| return; |
| } |
| pl_retVal.charstringVal := c_EPTF_LGenBase_stateNames[v_LGenBase_trafficCases[pl_nonVarArgList[0]].state]; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_scStateName |
| // |
| // Purpose: |
| // Returns the text format of the state of the specified scenario |
| // |
| // Detailed Comments: |
| // Calc function |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBaseStats_scStateName( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| pl_retVal.charstringVal:=""; |
| return; |
| } |
| pl_retVal.charstringVal := c_EPTF_LGenBase_stateNames[v_LGenBase_entityGroups[pl_nonVarArgList[0]].scenarios[pl_nonVarArgList[1]].state]; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_tcTrafficType |
| // |
| // Purpose: |
| // Returns the text format of the traffic type of the specified TC |
| // |
| // Detailed Comments: |
| // Calc function |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBaseStats_tcTrafficType( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| pl_retVal.charstringVal:=""; |
| return; |
| } |
| pl_retVal.charstringVal := c_EPTF_LGenBase_trafficTypeNames[enum2int(v_LGenBase_trafficCases[pl_nonVarArgList[0]].trafficType)]; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_scTrafficType |
| // |
| // Purpose: |
| // Returns the text format of the traffic type of the specified SC |
| // |
| // Detailed Comments: |
| // Calc function |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBaseStats_scTrafficType( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| pl_retVal.charstringVal:=""; |
| return; |
| } |
| pl_retVal.charstringVal := c_EPTF_LGenBase_trafficTypeNames[enum2int(v_LGenBase_entityGroups[pl_nonVarArgList[0]].scenarios[pl_nonVarArgList[1]].trafficType)]; |
| } |
| |
| }//LGenBase_specific |
| |
| /////////////////////////////////////////////////////////// |
| // Group: Callbacks |
| // |
| // Purpose: |
| // Callback functions registered in the LGenBase |
| /////////////////////////////////////////////////////////// |
| group Callbacks{ |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_scenarioStateChangedCallback |
| // |
| // Purpose: |
| // The function is called when the state of a scenario has changed |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_scenarioStateChangedCallback( |
| in integer pl_eGrpIdx, |
| in integer pl_scIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| var charstring vl_eGrpName := v_LGenBase_entityGroups[pl_eGrpIdx].name; |
| var charstring vl_scName := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[pl_scIdx].name; |
| var charstring vl_varNameBase := f_EPTF_LGenBase_getScNamePrefix(vl_eGrpName,vl_scName); |
| var integer vl_varId := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScState); |
| f_EPTF_Base_assert(%definitionId&": Invalid variable name "&vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScState, -1 < vl_varId); |
| f_EPTF_Var_refreshContent(vl_varId); |
| vl_varId := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScStateName); |
| f_EPTF_Base_assert(%definitionId&": Invalid variable name "&vl_varNameBase&c_EPTF_LGenBaseStats_nameOfScStateName, -1 < vl_varId); |
| f_EPTF_Var_refreshContent(vl_varId); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_tcStateChangedCallback |
| // |
| // Purpose: |
| // The function is called when a TC has been started |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_tcStateChangedCallback( |
| in integer pl_tcIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| var charstring vl_eGrpName; |
| var charstring vl_scName; |
| var charstring vl_tcName; |
| f_EPTF_LGenBase_trafficCaseIdNames(pl_tcIdx, vl_eGrpName, vl_scName, vl_tcName); |
| var charstring vl_varNameBase := f_EPTF_LGenBase_getNamePrefix(vl_eGrpName, vl_scName, vl_tcName); |
| var integer vl_varId := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcState); |
| f_EPTF_Base_assert(%definitionId&": Invalid variable name "&vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcState, -1 < vl_varId); |
| f_EPTF_Var_refreshContent(vl_varId); |
| vl_varId := f_EPTF_Var_getId(vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcStateName); |
| f_EPTF_Base_assert(%definitionId&": Invalid variable name "&vl_varNameBase&c_EPTF_LGenBaseStats_nameOfTcStateName, -1 < vl_varId); |
| f_EPTF_Var_refreshContent(vl_varId); |
| } |
| |
| group trafficStatistics{ |
| |
| private function f_EPTF_LGenBaseStats_trafficSucces( |
| in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfSuccesses) |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfRunningEntities) |
| } |
| private function f_EPTF_LGenBaseStats_trafficFail( |
| in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfFails) |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfRunningEntities) |
| } |
| private function f_EPTF_LGenBaseStats_trafficError( |
| in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfErrors) |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfRunningEntities) |
| } |
| private function f_EPTF_LGenBaseStats_trafficTimeout( |
| in integer pl_tcAbsIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfTimeouts) |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfRunningEntities) |
| } |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_trafficStartedCallback |
| // |
| // Purpose: |
| // The function is called when a traffic has been started on an entity |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_trafficStartedCallback(in integer pl_tcAbsIdx, in integer pl_eAbsIdx) |
| runs on EPTF_LGenBase_Private_CT { |
| v_LGenBaseStats_lastCallsList[pl_tcAbsIdx] := v_LGenBaseStats_lastCallsList[pl_tcAbsIdx] + 1; |
| f_EPTF_Var_refreshContent(v_LGenBaseStats_trafficCases[pl_tcAbsIdx].varIdxOfTcNrOfStarts) |
| } |
| } |
| }//Callbacks |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_calcCPSListAction |
| // |
| // Purpose: |
| // Calculates the CPS |
| // |
| // Detailed Comments: |
| // The function is registered as a scheduler action. Wrapper function for the f_EPTF_LGenBaseStats_calcCPS |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_LGenBaseStats_calcCPSListAction( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| var integer vl_count := sizeof(v_LGenBaseStats_lastCallsList); |
| var float vl_currentTime := f_EPTF_SchedulerComp_snapshotTime(); |
| var float vl_interval := vl_currentTime - v_LGenBaseStats_lastCPSCalcTime; |
| for ( var integer vl_i := 0; vl_i < vl_count ; vl_i := vl_i+1 ) |
| { |
| if(isbound(v_LGenBaseStats_lastCallsList[vl_i])){ |
| f_EPTF_LGenBaseStats_calcCPS(vl_i, vl_interval) |
| v_LGenBaseStats_lastCallsList[vl_i]:=0; |
| } |
| } |
| v_LGenBaseStats_lastCPSCalcTime := vl_currentTime; |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| pl_action.when + tsp_LGenBaseStats_CPSCalc, |
| refers(f_EPTF_LGenBaseStats_calcCPSListAction), |
| {}, |
| v_LGenBaseStats_CPSCalcTimer |
| )) { |
| f_EPTF_LGenBase_loggingError(%definitionId& ": Could not start CPS calculation timer."); |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_calcCPS |
| // |
| // Purpose: |
| // Calculates the CPS |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_calcCPS( |
| in integer pl_tcAbsIdx, |
| in float pl_interval) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if(0.0 == pl_interval){ |
| f_EPTF_Var_adjustContent(v_LGenBaseStats_lastCpsVarList[pl_tcAbsIdx], {floatVal := 0.0 }); |
| }else{ |
| f_EPTF_Var_adjustContent(v_LGenBaseStats_lastCpsVarList[pl_tcAbsIdx], {floatVal := int2float(v_LGenBaseStats_lastCallsList[pl_tcAbsIdx])/pl_interval }); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Group: Guards |
| // |
| // Purpose: |
| // Guard functions |
| /////////////////////////////////////////////////////////// |
| group Guards{ |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_readOnlyGuard |
| // |
| // Purpose: |
| // Makes the EPTF Var readonly |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_readOnlyGuard( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_resetOnlyGuard |
| // |
| // Purpose: |
| // Makes the EPTF Var readonly, only reset value of "0" is accepted |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_resetOnlyGuard( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean { |
| if (ischosen(pl_newContent.intVal) and pl_newContent.intVal == 0) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| |
| private function f_EPTF_LGenBaseStats_EnabledCallback(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { //Set also the enabled flag it ensures to have effect also before and during test execution |
| if( not v_LGenBase_initialized ) { |
| return; |
| } |
| var integer vl_tcId := pl_argList[0]; |
| var integer vl_varId := pl_argList[1]; |
| var EPTF_Var_DirectContent vl_content; |
| f_EPTF_Var_getContent(vl_varId, vl_content) |
| v_LGenBase_trafficCases[pl_argList[0]].enabledAtStartup := vl_content.boolVal; |
| } |
| |
| private function f_EPTF_LGenBaseStats_EnabledUpdate(in EPTF_IntegerList pl_argList) |
| runs on EPTF_LGenBase_Private_CT { |
| if( not v_LGenBase_initialized ) { |
| return; |
| } |
| var integer vl_tcId := pl_argList[0]; |
| var integer vl_varId := pl_argList[1]; |
| var EPTF_Var_DirectContent vl_content := {boolVal := v_LGenBase_trafficCases[vl_tcId].enabledAtStartup}; |
| if(f_EPTF_Var_getBoolValue(vl_varId) != vl_content.boolVal) { |
| f_EPTF_Var_adjustContent(vl_varId, vl_content); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBaseStats_floatPositiveOrZeroGuard |
| // |
| // Purpose: |
| // Allows only positive numbers or 0 |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_LGenBaseStats_floatPositiveOrZeroGuard( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_LGenBase_Private_CT |
| return boolean{ |
| if(not ischosen(pl_newContent.floatVal)) { return false; } |
| if(pl_newContent.floatVal < 0.0) { return false; } |
| return true; |
| } |
| } |
| |
| }//PrivateStatsFunctions |
| |
| group LimitedExecution |
| { |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_limitExecution |
| // |
| // Purpose: |
| // Limits the number of entities in the EntityGroup in order to limit execution to help testing and troubleshooting |
| // |
| // Parameters: |
| // pl_eGrpIdx - *in* - *integer* - entityGroup identifier |
| // pl_eLimit - *in* - *integer* - entity limit size : from 0 to chosen entityGroup size -1 it limits the execution, if negative = unlimit the group |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_limitExecution( |
| in integer pl_eGrpIdx, |
| in integer pl_eLimit) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if(( v_LGenBase_entityGroups[pl_eGrpIdx].isLimited == false and v_LGenBase_entityGroups[pl_eGrpIdx].eCount < pl_eLimit ) or |
| ( v_LGenBase_entityGroups[pl_eGrpIdx].isLimited == true and v_LGenBase_entityGroups[pl_eGrpIdx].origECount < pl_eLimit )) { |
| f_EPTF_LGenBase_loggingError(%definitionId&" Error : Limit is greater than all the number of entities in the given entity group!"); |
| return; |
| } |
| |
| if(pl_eLimit < 0){ |
| f_EPTF_LGenBase_unLimitExecution(pl_eGrpIdx); |
| } |
| |
| if(v_LGenBase_entityGroups[pl_eGrpIdx].isLimited == false){ |
| v_LGenBase_entityGroups[pl_eGrpIdx].isLimited := true; |
| v_LGenBase_entityGroups[pl_eGrpIdx].origECount := v_LGenBase_entityGroups[pl_eGrpIdx].eCount; |
| } |
| |
| // if pl_eLimit < v_LGenBase_entityGroups[pl_eGrpIdx].eCount disable entities above pl_eLimit: |
| //action("disable:" & log2str(pl_eLimit)& "-tol" & log2str(v_LGenBase_entityGroups[pl_eGrpIdx].eCount-1) & "-ig"); |
| for( var integer vl_eRelIDx := pl_eLimit; vl_eRelIDx < v_LGenBase_entityGroups[pl_eGrpIdx].eCount; vl_eRelIDx := vl_eRelIDx + 1){ |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcIdx := 0; vl_tcIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcIdx := vl_tcIdx + 1){ |
| f_EPTF_LGenBase_disableEntityInTrafficCase(pl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcIdx], |
| pl_eRelIdx := vl_eRelIDx); |
| } |
| } |
| } |
| |
| var integer vl_prevECount := v_LGenBase_entityGroups[pl_eGrpIdx].eCount; |
| // set the new size to pl_eLimit |
| v_LGenBase_entityGroups[pl_eGrpIdx].eCount := pl_eLimit; |
| var integer vl_state; |
| //action("enable init: 0-tol" & log2str(v_LGenBase_entityGroups[pl_eGrpIdx].origECount) & "-ig"); |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcRelIdx := 0; vl_tcRelIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcRelIdx := vl_tcRelIdx + 1){ |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcRelIdx]; |
| v_LGenBase_entityGroups[v_LGenBase_trafficCases[vl_tcIdx].eGroupBackref].eCount := pl_eLimit; |
| vl_state := v_LGenBase_trafficCases[vl_tcIdx].state; |
| f_EPTF_LGenBase_initTCInternal(v_LGenBase_trafficCases[vl_tcIdx], vl_tcIdx, true, false); |
| v_LGenBase_trafficCases[vl_tcIdx].state := vl_state; |
| } |
| } |
| |
| |
| for( var integer vl_eRelIDx := 0; vl_eRelIDx < v_LGenBase_entityGroups[pl_eGrpIdx].eCount; vl_eRelIDx := vl_eRelIDx + 1){ |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcIdx := 0; vl_tcIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcIdx := vl_tcIdx + 1){ |
| f_EPTF_LGenBase_disableEntityInTrafficCase(pl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcIdx], |
| pl_eRelIdx := vl_eRelIDx); |
| } |
| } |
| } |
| // enable all entities |
| for( var integer vl_eRelIDx := 0; vl_eRelIDx < pl_eLimit; vl_eRelIDx := vl_eRelIDx + 1){ |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcRelIdx := 0; vl_tcRelIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcRelIdx := vl_tcRelIdx + 1){ |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcRelIdx]; |
| f_EPTF_LGenBase_enableEntityInTrafficCase(pl_tcIdx := vl_tcIdx, |
| pl_eRelIdx := vl_eRelIDx); |
| } |
| } |
| } |
| |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_LGenBase_unLimitExecution |
| // |
| // Purpose: |
| // Unlimits the limited EntityGroup. |
| // |
| // Parameters: |
| // pl_eGrpIdx - *in* - *integer* - entityGroup identifier |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_LGenBase_unLimitExecution( |
| in integer pl_eGrpIdx) |
| runs on EPTF_LGenBase_Private_CT |
| { |
| if( v_LGenBase_entityGroups[pl_eGrpIdx].isLimited == false ) { |
| f_EPTF_LGenBase_loggingWarning(%definitionId&" Warning : You are trying to unlimit an EntityGroup that has been unlimited before!"); |
| return; |
| } |
| |
| v_LGenBase_entityGroups[pl_eGrpIdx].isLimited := false; |
| v_LGenBase_entityGroups[pl_eGrpIdx].eCount := v_LGenBase_entityGroups[pl_eGrpIdx].origECount; |
| v_LGenBase_entityGroups[pl_eGrpIdx].origECount := 0; |
| var integer vl_state; |
| //action("enable init: 0-tol" & log2str(v_LGenBase_entityGroups[pl_eGrpIdx].origECount) & "-ig"); |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcRelIdx := 0; vl_tcRelIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcRelIdx := vl_tcRelIdx + 1){ |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcRelIdx]; |
| v_LGenBase_entityGroups[v_LGenBase_trafficCases[vl_tcIdx].eGroupBackref].eCount := v_LGenBase_entityGroups[pl_eGrpIdx].eCount; |
| vl_state := v_LGenBase_trafficCases[vl_tcIdx].state; |
| f_EPTF_LGenBase_initTCInternal(v_LGenBase_trafficCases[vl_tcIdx], vl_tcIdx, true, false); |
| v_LGenBase_trafficCases[vl_tcIdx].state := vl_state; |
| } |
| } |
| |
| for( var integer vl_eRelIDx := 0; vl_eRelIDx < v_LGenBase_entityGroups[pl_eGrpIdx].origECount; vl_eRelIDx := vl_eRelIDx + 1){ |
| for( var integer vl_scenIdx := 0; vl_scenIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios); vl_scenIdx := vl_scenIdx + 1){ |
| for( var integer vl_tcRelIdx := 0; vl_tcRelIdx < sizeof(v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList); vl_tcRelIdx := vl_tcRelIdx + 1){ |
| var integer vl_tcIdx := v_LGenBase_entityGroups[pl_eGrpIdx].scenarios[vl_scenIdx].tcIdxList[vl_tcRelIdx]; |
| f_EPTF_LGenBase_enableEntityInTrafficCase(pl_tcIdx := vl_tcIdx, |
| pl_eRelIdx := vl_eRelIDx); |
| } |
| } |
| } |
| |
| } |
| |
| } |
| |
| } // end of module |