| /////////////////////////////////////////////////////////////////////////////// |
| // // |
| // 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_ExecCtrl_Functions |
| // |
| // Purpose: |
| // This module contains the implementation of EPTF_CLL_ExecCtrl functions. |
| // |
| // Module depends on: |
| // <EPTF_CLL_Common_Definitions> |
| // <EPTF_CLL_Base_Functions> |
| // <EPTF_CLL_FBQ_Definitions> |
| // <EPTF_CLL_LGenBase_Definitions> |
| // <EPTF_CLL_LGenBase_ConfigDefinitions> |
| // <EPTF_CLL_LGenBase_ConfigFunctions> |
| // <EPTF_CLL_LGenBase_PhaseDefinitions> |
| // <EPTF_CLL_ExecCtrl_Definitions> |
| // <EPTF_CLL_ExecCtrlTimeProfile_Definitions> |
| // <EPTF_CLL_ExecCtrl_ScenarioFunctions> |
| // <EPTF_CLL_ExecCtrl_LoggingFunctions> |
| // <EPTF_CLL_HashMapStr2Int_Functions> |
| // <EPTF_CLL_HashMapInt2Int_Functions> |
| // <EPTF_CLL_Scheduler_Definitions> |
| // <EPTF_CLL_RBTScheduler_Functions> |
| // <EPTF_CLL_Variable_Definitions> |
| // <EPTF_CLL_Variable_Functions> |
| // <EPTF_CLL_LGenBaseStats_Definitions> |
| // <EPTF_CLL_LGenBaseStats_Functions> |
| // <EPTF_CLL_Logging_Definitions> |
| // <EPTF_CLL_Logging_Functions> |
| // <EPTF_CLL_ExecCtrl_ScenarioDefinitions> |
| // <EPTF_CLL_ExecCtrlClient_Functions> |
| // <EPTF_CLL_ExecCtrl_PhaseFunctions> |
| // <EPTF_CLL_StatMeasure_Functions> |
| // <EPTF_CLL_StatHandler_Functions> |
| // <EPTF_CLL_StatHandlerClient_Functions> |
| // <EPTF_CLL_StatHandlerClient_Definitions> |
| // <TCCFileIO_Functions> |
| // <TCCDateTime_Functions> |
| // <EPTF_CLL_HashMap_Functions> |
| // |
| // Module Parameters: |
| // tsp_debug_EPTF_ExecCtrl_Functions - boolean - enable/disable debug logs |
| // tsp_EPTF_ExecCtrl_maxKillTime - float - max time to wait for all LGens to stop |
| // tsp_EPTF_ExecCtrl_finalTestReportFile - charstring - name of the file where the final test report is saved. Default: EPTF_ExecCtrl_FinalTestReport_%Y-%m-%d_%H.%M.%S.txt |
| // tsp_EPTF_ExecCtrl_UIHandler_disableAutoEnablingOfManualControlModeWhenStopButtonIsPressed - *boolean* - Disable to return to manual control mode when stop button is pressed |
| // |
| // Current Owner: |
| // Jozsef Gyurusi (ethjgi) |
| // |
| // Last Review Date: |
| // 2009-02-03 |
| // |
| // Detailed Comments: |
| // This module contains the interface functions for the EPTF_CLL_ExecCtrl. |
| // |
| // Public functions: |
| // <f_EPTF_ExecCtrl_init_CT> |
| // <f_EPTF_ExecCtrl_checkManualLGenStarted> *new |
| // <f_EPTF_ExecCtrl_start> |
| // <f_EPTF_ExecCtrl_getManualControl> |
| // <f_EPTF_ExecCtrl_setManualControl> |
| // <f_EPTF_ExecCtrl_getTimePeriodForTcDeltaStats> |
| // <f_EPTF_ExecCtrl_setTimePeriodForTcDeltaStats> |
| // <f_EPTF_ExecCtrl_loadConfig> |
| // <f_EPTF_ExecCtrl_checkReadyToRun> |
| // <f_EPTF_ExecCtrl_waitForCondition> |
| // <f_EPTF_ExecCtrl_setTimeFormat> |
| // <f_EPTF_ExecCtrl_startTimeProfiles> |
| // <f_EPTF_ExecCtrl_stopTimeProfiles> |
| // <f_EPTF_ExecCtrl_startAllScenarios> |
| // <f_EPTF_ExecCtrl_startAllScenarioGroups> |
| // <f_EPTF_ExecCtrl_stopAllScenarioGroups> |
| // <f_EPTF_ExecCtrl_terminateAllScenarioGroups> *new |
| // <f_EPTF_ExecCtrl_stopCurrentPhaseForAllScenarioGroups> |
| // <f_EPTF_ExecCtrl_stopAllScenarios> |
| // <f_EPTF_ExecCtrl_terminateAllScenarios> *new |
| // <f_EPTF_ExecCtrl_checkAllScenarios> *new |
| // <f_EPTF_ExecCtrl_setCps_TC> |
| // <f_EPTF_ExecCtrl_setCps_SC> |
| // <f_EPTF_ExecCtrl_getCPSToReach_TC> |
| // <f_EPTF_ExecCtrl_setCPSToReach_TC> |
| // <f_EPTF_ExecCtrl_getCPSToReach_SC> |
| // <f_EPTF_ExecCtrl_setCPSToReach_SC> |
| // <f_EPTF_ExecCtrl_getTCWeight> |
| // <f_EPTF_ExecCtrl_setTCWeight> |
| // <f_EPTF_ExecCtrl_Regulator_addRegulator> |
| // <f_EPTF_ExecCtrl_Regulator_getRegulatorId> |
| // <f_EPTF_ExecCtrl_Regulator_setTotalCps> |
| // <f_EPTF_ExecCtrl_Regulator_getTotalCps> |
| // <f_EPTF_ExecCtrl_Regulator_getRegulatedItemId> |
| // <f_EPTF_ExecCtrl_Regulator_getRegulatorName> |
| // <f_EPTF_ExecCtrl_Regulator_setRegulatorName> |
| // <f_EPTF_ExecCtrl_Regulator_logAll> |
| // <f_EPTF_ExecCtrl_registerScenarioStateChangedCallback> |
| // <f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback> |
| // <f_EPTF_ExecCtrl_enableStartStopScenario> |
| // <f_EPTF_ExecCtrl_disableStartStopScenario> |
| // <f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup> |
| // <f_EPTF_ExecCtrl_isDisabledStartStopScenario> |
| // <f_EPTF_ExecCtrl_getStartStopScenarioIdx> |
| // <f_EPTF_ExecCtrl_enableStartStopTC> |
| // <f_EPTF_ExecCtrl_disableStartStopTC> |
| // <f_EPTF_ExecCtrl_isDisabledStartStopTC> |
| // <f_EPTF_ExecCtrl_getStartStopTCIdx> |
| // <f_EPTF_ExecCtrl_startScenarioOnLGens> |
| // <f_EPTF_ExecCtrl_stopScenarioOnLGens> |
| // <f_EPTF_ExecCtrl_resetScenarioOnLGens> |
| // <f_EPTF_ExecCtrl_stopScenarioGroupOnLGens> |
| // <f_EPTF_ExecCtrl_startTCOnLGens> |
| // <f_EPTF_ExecCtrl_stopTCOnLGens> |
| // <f_EPTF_ExecCtrl_singleShotTc> |
| // <f_EPTF_ExecCtrl_scenarioEnabled> |
| // <f_EPTF_ExecCtrl_behavior> |
| // <f_EPTF_ExecCtrl_exit> |
| // <f_EPTF_ExeCtrl_enableUIHandlerProgress> |
| // <f_EPTF_ExecCtrl_resetFSMStat> |
| // <f_EPTF_ExecCtrl_LGenPool_createLGens> |
| // <f_EPTF_ExecCtrl_nrOfClients> |
| // <f_EPTF_ExecCtrl_LGenPool_dumpInstanceDB> |
| // <f_EPTF_ExecCtrl_addLGenFunctionsFromDeclarators> |
| // <f_EPTF_ExecCtrl_getLGenCompRefsOfPool> |
| // <f_EPTF_ExecCtrl_checkCreatorFnNameOfPool> |
| // <f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn> |
| // <f_EPTF_ExecCtrl_deregisterFinalTestReportGeneratorFn> |
| // <f_EPTF_ExecCtrl_generateFinalTestReport> |
| // <f_EPTF_ExecCtrl_registerFSMStatsCreatedCallback> |
| // <f_EPTF_ExecCtrl_deregisterFSMStatsCreatedCallback> |
| // <f_EPTF_ExecCtrl_getFSMStatisticsOfTcs> |
| // <f_EPTF_ExecCtrl_setStartDelay_TC> |
| // <f_EPTF_ExecCtrl_startScenarioOnLGensByName> |
| // <f_EPTF_ExecCtrl_stopScenarioOnLGensByName> |
| // <f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario> |
| // <f_EPTF_ExecCtrl_StatHandler_getVarIdx> |
| // <f_EPTF_ExecCtrl_StatHandler_getVarNameByStatName> |
| // <f_EPTF_ExecCtrl_StatHandler_getAuxVars> |
| // |
| // All other functions in this module are private! |
| // |
| /////////////////////////////////////////////////////////////// |
| |
| |
| module EPTF_CLL_ExecCtrl_Functions { |
| |
| //========================================================================= |
| // Import Part |
| //========================================================================= |
| |
| import from EPTF_CLL_Common_Definitions all; |
| |
| import from EPTF_CLL_Base_Functions 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_PhaseDefinitions all; |
| |
| import from EPTF_CLL_ExecCtrl_Definitions all; |
| import from EPTF_CLL_ExecCtrlTimeProfile_Definitions all; |
| import from EPTF_CLL_ExecCtrl_ScenarioFunctions all; |
| import from EPTF_CLL_ExecCtrl_LoggingFunctions all; |
| import from EPTF_CLL_HashMapStr2Int_Functions all; |
| import from EPTF_CLL_HashMapInt2Int_Functions all; |
| |
| import from EPTF_CLL_Scheduler_Definitions all; |
| import from EPTF_CLL_RBTScheduler_Functions all; |
| |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Variable_Functions all; |
| |
| import from EPTF_CLL_LGenBaseStats_Definitions all; |
| import from EPTF_CLL_LGenBaseStats_Functions all; |
| |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Logging_Functions all; |
| |
| import from EPTF_CLL_ExecCtrl_ScenarioDefinitions all; |
| import from EPTF_CLL_ExecCtrl_PhaseDefinitions all; |
| import from EPTF_CLL_ExecCtrl_PhaseFunctions all; |
| import from EPTF_CLL_ExecCtrl_DSFunctions all; |
| import from EPTF_CLL_StatMeasure_Functions all; |
| import from EPTF_CLL_StatHandler_Definitions all; |
| import from EPTF_CLL_StatHandler_Functions all; |
| import from EPTF_CLL_StatHandlerClient_Functions all; |
| import from EPTF_CLL_StatHandlerClient_Definitions all; |
| |
| import from EPTF_CLL_StatManager_Functions all; |
| |
| import from TCCFileIO_Functions all; |
| import from TCCDateTime_Functions all; |
| |
| import from EPTF_CLL_DataSource_Definitions all; |
| import from EPTF_CLL_DataSourceClient_Functions all; |
| |
| import from EPTF_CLL_HashMap_Functions all; |
| |
| import from EPTF_CLL_FBQ_Functions all; |
| |
| friend module EPTF_CLL_ExecCtrlUIHandler_Functions, EPTF_CLL_ExecCtrl_DSFunctions; |
| friend module EPTF_CLL_ExecCtrlClient_Functions; |
| |
| |
| //modulepar boolean tsp_EPTF_ExecCtrl_StatHandler_wait4response := true; // sets the StatHandler Wait4Resp flag |
| |
| //========================================================================= |
| // Functions |
| //======================================================================== |
| |
| /////////////////////////////////////////////////////////// |
| // Group: EPTF_ExecCtrl |
| // |
| // Purpose: |
| // Functions related to EPTF_ExecCtrl feature |
| // |
| /////////////////////////////////////////////////////////// |
| group EPTF_ExecCtrl { |
| |
| modulepar boolean tsp_debug_EPTF_ExecCtrl_Functions := false; |
| modulepar float tsp_EPTF_ExecCtrl_maxKillTime := 30.0; // max time to wait for all LGens to stop |
| modulepar charstring tsp_EPTF_ExecCtrl_finalTestReportFile := "EPTF_ExecCtrl_FinalTestReport_%Y-%m-%d_%H.%M.%S.txt"; // name of the file where the final test report is saved. Default: EPTF_ExecCtrl_FinalTestReport_%Y-%m-%d_%H.%M.%S.txt |
| // Set it to empty string to disable final test report generation |
| modulepar boolean tsp_EPTF_ExecCtrl_generateOwnReport := true; // If enabled ExecCtrl will write the traffic case statistics into the final test report. Default: true |
| |
| const charstring c_EPTF_ExecCtrl_Regulator_totalValue := "Regulator.totalValue"; // name of the variable that indicates the regulator targetLoad |
| const charstring c_EPTF_ExecCtrl_Regulator_targetLoad := "Regulator.targetLoad"; // name of the variable that indicates the regulator targetLoad |
| const charstring c_EPTF_ExecCtrl_Regulator_currentLoad := "Regulator.currentLoad"; // name of the variable that indicates the regulator currentLoad |
| const charstring c_EPTF_ExecCtrl_Regulator_status := "Regulator.status"; // name of the variable that indicates the regulator status |
| const charstring c_EPTF_ExecCtrl_Regulator_enable := "Regulator.enable"; // name of the variable that indicates the regulator enable flag |
| |
| modulepar boolean tsp_EPTF_ExecCtrl_UIHandler_disableAutoEnablingOfManualControlModeWhenStopButtonIsPressed := false; |
| |
| const EPTF_StatusLED c_EPTF_ExecCtrl_UIVars_StatusLED_init := { color := led_black, text := "NA" }; |
| const EPTF_StatusLED c_EPTF_ExecCtrl_UIVars_GroupFinishCondStatusLED_init := { color := led_black, text := " -- " }; |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_init_CT |
| // |
| // Purpose: |
| // Init EPTF_ExecCtrl feature |
| // |
| // Parameters: |
| // - pl_selfName - *in charstring* - the name of the component |
| // - pl_nrOfClients - *in integer* - the number of the <EPTF_ExecCtrlClient_CT> components created by the user |
| // (this is the size of the default pool) |
| // - pl_createLGenPools - *in boolean - if true, LGens in LGens pools are created automatically during init, otherwise |
| // the function <f_EPTF_ExecCtrl_LGenPool_createLGens> has to be called after the init function. Default: true |
| // - pl_loadModulepars - *in boolean - if true, module parameters are automatically loaded. Default: true |
| // - pl_autoStart - *in boolean - if true, ExecCtrl is started automatically by calling <f_EPTF_ExecCtrl_start>. Default: true |
| // - pl_dataSource_compRef - *in* <EPTF_DataSource_CT> - DataSource component reference. Optional, if given, ExecCtrl will be able to behave |
| // as a DataSource Client. It means that datas can be requested from it and it will provide them in variables. This component can |
| // be for example the UIHandler component. |
| // - pl_nofExternalStatHandlers - *in integer* - if >0: ExecCtrl TC and FSM statistics will be calculated on a separate StatHandler component, |
| // for 0: ExecCtrl will calculate the stats |
| // Note, that using external StatHandler component increases the internal traffic on the Variable interface (between ExecCtrl and StatHandler) |
| // Default: 0, which means that ExecCtrl will use its internal StatHandler (No extra internal traffic) |
| // - pl_usePullModeForStats - *in* *boolean* - If true pull mode is used for StatHandler statistics (default: false) |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - pl_nrOfClients shall be non-negative. |
| // |
| // Detailed Comments: |
| // The pl_nrOfClients parameter shall specify the number of LGens in the default LGen pool. |
| // The default LGen pool is the collection of LGens created by the user. |
| // All other LGens are created automatically by the LGenPool functionality, and |
| // the number of those LGens should not be added to this parameter. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_init_CT |
| ( |
| in charstring pl_selfName, |
| in integer pl_nrOfClients, |
| in boolean pl_createLGenPools := true, |
| in boolean pl_loadModulepars := true, |
| in boolean pl_autoStart := true, |
| in EPTF_DataSource_CT pl_dataSource_compRef := null, |
| in integer pl_nofExternalStatHandlers := 0, |
| in boolean pl_usePullModeForStats := false |
| ) runs on EPTF_ExecCtrl_CT { |
| if (v_ExecCtrl_initialized) { |
| return; // already initialized |
| } |
| v_ExecCtrl_initialized := true; // should be here to prevent cleanup from not being called |
| v_ExecCtrl_readyToRun := false; |
| v_ExecCtrl_allLGensCreated := false; |
| v_EPTF_ExecCtrl_startTime := -1.0; |
| v_EPTF_ExecCtrl_timeFormat := tsp_EPTF_ExecCtrl_timeFormat; |
| |
| v_EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_onGroupFinishCallbackFns := {}; |
| v_EPTF_ExecCtrl_finalTestReportGeneratorFns := {}; |
| v_EPTF_ExecCtrl_finalTestReport := ""; |
| |
| if (tsp_EPTF_ExecCtrl_generateOwnReport) { |
| f_EPTF_ExecCtrl_setGenerateOwnReport(true); |
| } |
| |
| v_ExecCtrl_endOfTest := false; |
| |
| v_ExecCtrl_pendingMsgCounter := 0; |
| v_ExecCtrl_pendingByeCounter := 0; |
| |
| v_ExecCtrl_FSMStats := {}; |
| v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns := {}; |
| v_ExecCtrl_processingCreateFSMStats := false; |
| |
| v_ExecCtrl_progressBarUIHandler_Idx := -1; |
| v_ExecCtrl_progressEnabled := true; |
| v_ExecCtrl_progressBarUIHandler_updateSent := false; |
| |
| f_EPTF_Base_init_CT(pl_selfName); |
| f_EPTF_FBQ_init_CT(pl_selfName); |
| f_EPTF_Var_init_CT(pl_selfName); |
| f_EPTF_StatMeasure_init_CT(pl_selfName); |
| |
| v_ExecCtrl_dataSourceCompRef := pl_dataSource_compRef; |
| v_EPTF_ExecCtrl_nofExternalStatHandlers := pl_nofExternalStatHandlers; |
| v_EPTF_ExecCtrl_statHandler_comprefList := {}; |
| v_EPTF_ExecCtrl_statHandler_autoSelector := 0; |
| v_ExecCtrl_statHandlerHash := f_EPTF_str2int_HashMap_New(c_ExecCtrl_statHandlerHashMapName); |
| v_ExecCtrl_usePullModeForStats := pl_usePullModeForStats; |
| f_ExecCtrl_ExternalStatHandler_startNew(); |
| |
| f_EPTF_StatHandlerClient_init_CT(pl_selfName); |
| f_EPTF_Scheduler_init_CT(pl_selfName); |
| f_EPTF_Logging_init_CT(pl_selfName); |
| f_EPTF_HashMap_init_CT (pl_selfName); |
| f_EPTF_DataSourceClient_init_CT(pl_selfName, pl_dataSource_compRef); |
| |
| v_ExecCtrl_regulatedItemsHash := f_EPTF_str2int_HashMap_New(c_ExecCtrl_regulatedItemsHashMapName); |
| |
| if(pl_dataSource_compRef != null){ |
| v_ExecCtrl_dataSourceCompRef := pl_dataSource_compRef; |
| f_EPTF_DataSourceClient_registerSetDataValue(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_ExecCtrl_DSProcessSetDataValue)); |
| f_EPTF_DataSourceClient_registerData(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_ExecCtrl_DSProcessData)); |
| f_EPTF_DataSourceClient_registerDataValue(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_ExecCtrl_DSProcessDataValue), pl_dataSource_compRef); |
| f_EPTF_DataSourceClient_registerCondition(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_ExecCtrl_conditionHandler_isWeightedSc),c_ExecCtrl_conditionIsWeightedSc); |
| f_EPTF_DataSourceClient_registerCondition(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName(), refers(f_EPTF_ExecCtrl_conditionHandler_isInScGroup), c_ExecCtrl_conditionIsInScGroup); |
| } |
| |
| v_ExecCtrl_loggingMaskId := f_EPTF_Logging_registerComponentMasks(tsp_EPTF_ExecCtrl_loggingComponentMask, c_EPTF_ExecCtrl_loggingEventClasses, EPTF_Logging_CLL); |
| if(tsp_debug_EPTF_ExecCtrl_Functions) { |
| f_EPTF_Logging_enableLocalMask(v_ExecCtrl_loggingMaskId, c_EPTF_ExecCtrl_loggingClassIdx_Debug); |
| } else { |
| f_EPTF_Logging_disableLocalMask(v_ExecCtrl_loggingMaskId, c_EPTF_ExecCtrl_loggingClassIdx_Debug); |
| } |
| |
| if (pl_loadModulepars) { |
| f_EPTF_ExecCtrl_loadConfigFromModulepars(); |
| } |
| |
| // add vars for automated GUI elements |
| f_EPTF_ExecCtrl_UIVars_InitGUILayout_vars(); |
| |
| f_EPTF_ExecCtrl_initEventStatus(); |
| |
| f_EPTF_Base_assert(%definitionId&": Checking number of ExecCtrlClients", pl_nrOfClients>=0); |
| |
| v_ExecCtrl_nrOfClients := pl_nrOfClients; |
| v_ExecCtrl_started := false; |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer := {}; |
| f_EPTF_Base_registerCleanup(refers(f_EPTF_ExecCtrl_cleanup_CT)); |
| |
| f_EPTF_ExecCtrl_registerOnGroupFinishCallbackFn(refers(f_EPTF_ExecCtrl_setLEDForOnGroupFinishCallBack)); |
| |
| v_EPTF_ExecCtrl_defaultAltstep := activate(as_EPTF_ExecCtrl_MgmtIf()); |
| |
| if (pl_autoStart) { |
| f_EPTF_ExecCtrl_start(pl_createLGenPools); |
| } else { |
| if (pl_createLGenPools) { |
| f_EPTF_ExecCtrl_warning(%definitionId& ": LGen pools are not created: Auto-start is disabled!"); |
| } |
| } |
| f_EPTF_ExecCtrl_Subscribe2ExitButton_vars(); |
| v_EPTF_ExecCtrl_SampledAtSync_vars := {}; // TR HQ88308 - Sampled & sync variables on old GUI for refresh |
| // TR HR20548 - Reset All statistics button |
| f_EPTF_StatHandler_registerStatisticsResetFunction(refers(f_EPTF_ExecCtrl_resetStatFunctions)); |
| f_EPTF_StatHandlerClient_registerResetFunction(refers(f_EPTF_ExecCtrl_resetStatFunctions)); |
| |
| } |
| |
| // this StatHandlert will process all ExecCtrl statistics (TC, FSM) |
| // Using External StatHandler will increase internal traffic on Variable interface |
| private function f_ExecCtrl_ExternalStatHandler_behaviour( |
| in EPTF_DataSource_CT pl_dataSource_compRef, |
| in integer pl_statHandlerId |
| ) runs on EPTF_ExecCtrl_StatHandler_CT { |
| f_EPTF_StatHandler_init_CT("ExecCtrl_ExternalStatHandler_Comp_"&log2str(pl_statHandlerId),pl_dataSource_compRef); |
| f_EPTF_StatManager_init_CT(f_EPTF_Base_selfName(),pl_dataSource_compRef); |
| f_EPTF_Base_wait4Shutdown(); |
| } |
| |
| // starts new StatHandlera or initializes the local |
| private function f_ExecCtrl_ExternalStatHandler_startNew() runs on EPTF_ExecCtrl_CT { |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers==0) { |
| // use local |
| f_EPTF_StatHandler_init_CT(f_EPTF_Base_selfName(), v_ExecCtrl_dataSourceCompRef); // Set pl_dataSource_compRef |
| f_EPTF_StatManager_init_CT(f_EPTF_Base_selfName(), v_ExecCtrl_dataSourceCompRef); |
| v_EPTF_ExecCtrl_statHandler_comprefList := {self}; |
| return; |
| } |
| for(var integer i:=0; i<v_EPTF_ExecCtrl_nofExternalStatHandlers; i:=i+1) { |
| var EPTF_ExecCtrl_StatHandler_CT vl_externalStatHandler := EPTF_ExecCtrl_StatHandler_CT.create; |
| vl_externalStatHandler.start(f_ExecCtrl_ExternalStatHandler_behaviour(v_ExecCtrl_dataSourceCompRef,i)); |
| v_EPTF_ExecCtrl_statHandler_comprefList[i] := vl_externalStatHandler; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_StatHandler_getVarIdx |
| // |
| // Purpose: |
| // Function for getting the id/index of the variable of a statistic. |
| // |
| // Parameters: |
| // pl_statName - *in* *charstring* - name of the stat |
| // |
| // Return Value: |
| // *integer* - index of variable for the stat |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // override function <f_EPTF_StatHandler_getVarIdx> |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_StatHandler_getVarIdx( |
| in charstring pl_statName |
| ) runs on EPTF_ExecCtrl_CT return integer { |
| |
| var integer vl_statVarIdx; |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_statName); |
| if (vl_statHandler==self) { |
| var integer vl_statId := f_EPTF_StatHandler_getId(pl_statName); |
| vl_statVarIdx := f_EPTF_StatHandler_getVarIdx(vl_statId); |
| } else { |
| // get var idx from remote statHandler |
| // the stat variable name and the stat name is the same; |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForVars := sampled; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForVars := pull; |
| } |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := vl_statHandler, |
| pl_remoteProviderVarName := pl_statName, |
| pl_subscriptionMode := vl_subscriptionModeForVars, |
| pl_idx := vl_statVarIdx, |
| pl_localName := pl_statName&"_Local" |
| ); |
| } |
| return vl_statVarIdx; |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_StatHandler_getVarNameByStatName |
| // |
| // Purpose: |
| // Function for getting the variable name for a statistic name. |
| // |
| // Parameters: |
| // pl_statName - *in* *charstring* - name of statistic |
| // pl_varName - *out* *charstring* - the variable name for a statistic name |
| // |
| // Return Value: |
| // *boolean* - true if success |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // override function <f_EPTF_StatHandler_getVarNameByStatName> |
| // |
| ///////////////////////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_StatHandler_getVarNameByStatName( |
| in charstring pl_statName, |
| out charstring pl_varName) |
| runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| var integer vl_varIdx := f_EPTF_ExecCtrl_StatHandler_getVarIdx(pl_statName); |
| if(vl_varIdx < 0) { return false; } |
| pl_varName := f_EPTF_Var_getName(vl_varIdx); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_StatHandler_getAuxVars |
| // |
| // Purpose: |
| // Function for getting the auxiliary Variable indices of a statistic. |
| // |
| // Parameters: |
| // pl_statName - *in* *charstring* - name of the stat |
| // |
| // Return Value: |
| // <EPTF_IntegerList> - list of auxiliary Var indices |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // override function f_EPTF_StatHandler_getAuxVars |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_StatHandler_getAuxVars( |
| in charstring pl_statName |
| ) runs on EPTF_ExecCtrl_CT return EPTF_IntegerList { |
| |
| var EPTF_IntegerList vl_auxVars; |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_statName); |
| if (vl_statHandler==self) { |
| var integer vl_statId := f_EPTF_StatHandler_getId(pl_statName); |
| vl_auxVars := f_EPTF_StatHandler_getAuxVars(vl_statId); |
| } else { |
| // get aux var idxs from remote statHandler and subscribe to them |
| var EPTF_CharstringList vl_auxVarNames := f_EPTF_StatHandlerClient_getAuxVariables(pl_statName,vl_statHandler); |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForVars := sampled; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForVars := pull; |
| } |
| for(var integer i:=0, size:=sizeof(vl_auxVarNames); i<size; i:=i+1) { |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := vl_statHandler, |
| pl_remoteProviderVarName := vl_auxVarNames[i], |
| pl_subscriptionMode := vl_subscriptionModeForVars, |
| pl_idx := vl_auxVars[i] |
| ) |
| } |
| } |
| return vl_auxVars; |
| } |
| |
| // override function f_EPTF_StatHandlerClient_declareStat |
| private function f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| in charstring pl_statName, |
| in EPTF_StatHandler_StatMethod pl_statMethod, |
| in EPTF_Var_DirectContent pl_statResetValue |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_statName); |
| |
| var integer vl_statHandlerCompIdx := -1; |
| if (vl_statHandler==null) { |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers==0) { |
| vl_statHandlerCompIdx := 0; |
| } else { |
| vl_statHandlerCompIdx := v_EPTF_ExecCtrl_statHandler_autoSelector mod v_EPTF_ExecCtrl_nofExternalStatHandlers; |
| } |
| vl_statHandler := v_EPTF_ExecCtrl_statHandler_comprefList[vl_statHandlerCompIdx]; |
| } else { |
| // stat already declared |
| return true; |
| } |
| |
| var boolean vl_success := f_EPTF_StatHandlerClient_declareStat( |
| pl_statName := pl_statName, |
| pl_statMethod := pl_statMethod, |
| pl_statResetValue := pl_statResetValue, |
| pl_statHandler := vl_statHandler, |
| pl_wait4response := true |
| ); |
| |
| if (vl_success) { |
| // subscribe statVar so that DS handler does not need f_EPTF_Var_subscribeRemote which would cause long call stack there |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForVars := sampled; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForVars := pull; |
| } |
| var integer vl_idx; |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := vl_statHandler, |
| pl_remoteProviderVarName := pl_statName, |
| pl_subscriptionMode := vl_subscriptionModeForVars, |
| pl_idx := vl_idx, |
| pl_localName := pl_statName&"_Local" |
| ); |
| |
| // store statHandler compRef for the statName: |
| f_EPTF_str2int_HashMap_Insert(v_ExecCtrl_statHandlerHash, pl_statName, vl_statHandlerCompIdx); |
| |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers>0) { |
| |
| v_EPTF_ExecCtrl_statHandler_autoSelector := v_EPTF_ExecCtrl_statHandler_autoSelector + 1; |
| |
| } |
| } |
| |
| return vl_success; |
| } |
| |
| // override function f_EPTF_StatHandlerClient_registerAggregatedStat |
| private function f_EPTF_ExecCtrl_StatHandlerClient_registerAggregatedStat( |
| in EPTF_StatHandler_CT pl_sourceStatHandler, |
| in charstring pl_sourceStatName, |
| in charstring pl_targetStatName, |
| in EPTF_Var_SubscriptionMode pl_subscriptionMode := sampledAtSync, |
| in boolean pl_wait4response := true//tsp_EPTF_ExecCtrl_StatHandler_wait4response |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| var EPTF_StatHandler_CT vl_statHandler := self; |
| |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers>0) { |
| vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_targetStatName); |
| if (vl_statHandler==null) { |
| return false; |
| } |
| } |
| |
| return f_EPTF_StatHandlerClient_registerAggregatedStat( |
| pl_sourceStatHandler := pl_sourceStatHandler, |
| pl_sourceStatName := pl_sourceStatName, |
| pl_targetStatName := pl_targetStatName, |
| pl_subscriptionMode := pl_subscriptionMode, |
| pl_wait4response := pl_wait4response, |
| pl_statHandler := vl_statHandler |
| ); |
| } |
| |
| // override function f_EPTF_StatHandlerClient_getStatVariableRef |
| private function f_EPTF_ExecCtrl_StatHandlerClient_getStatVariableRef( |
| in charstring pl_statName |
| ) runs on EPTF_ExecCtrl_CT return charstring { |
| var EPTF_StatHandler_CT vl_statHandler := self; |
| |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers>0) { |
| vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_statName); |
| if (vl_statHandler==null) { |
| return ""; |
| } |
| } |
| |
| return f_EPTF_StatHandlerClient_getStatVariableRef( |
| pl_statName := pl_statName, |
| pl_statHandler := vl_statHandler |
| ); |
| } |
| |
| //override function f_EPTF_StatHandlerClient_registerStat |
| private function f_EPTF_ExecCtrl_StatHandlerClient_registerStat( |
| in EPTF_CharstringList pl_providerVarList, |
| in charstring pl_statName, |
| in EPTF_Var_SubscriptionMode pl_subscriptionMode := sampledAtSync, |
| in boolean pl_wait4response := true,//tsp_EPTF_ExecCtrl_StatHandler_wait4response, |
| in EPTF_Var_CT pl_sourceCompRef := null, |
| in integer pl_refreshRate := 0 |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| var EPTF_StatHandler_CT vl_statHandler := self; |
| |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers>0) { |
| vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(pl_statName); |
| if (vl_statHandler==null) { |
| return false; |
| } |
| } |
| |
| return f_EPTF_StatHandlerClient_registerStat( |
| pl_providerVarList := pl_providerVarList, |
| pl_statName := pl_statName, |
| pl_subscriptionMode := pl_subscriptionMode, |
| pl_wait4response := pl_wait4response, |
| pl_sourceCompRef := pl_sourceCompRef, |
| pl_statHandler := vl_statHandler, |
| pl_refreshRate := pl_refreshRate |
| ); |
| } |
| |
| friend function f_EPTF_ExecCtrl_findStatHandler( |
| in charstring pl_statName |
| ) runs on EPTF_ExecCtrl_CT return EPTF_StatHandler_CT { |
| var integer vl_idx; |
| if (not f_EPTF_str2int_HashMap_Find( |
| v_ExecCtrl_statHandlerHash, |
| pl_statName, |
| vl_idx |
| )) { |
| return null; |
| } |
| return v_EPTF_ExecCtrl_statHandler_comprefList[vl_idx]; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkManualLGenStarted |
| // |
| // Purpose: |
| // Checks if LGens that are created manually (not in LGenPool) have started |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // boolean - true if all manual LGens have started, false if not |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // After this function is called, no more user created LGen will start. |
| // If LGen pools are created before user created LGens i.e. when start was called |
| // before the manual LGens are created, this function will return true when all |
| // LGens have been created. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_checkManualLGenStarted() runs on EPTF_ExecCtrl_CT return boolean { |
| return ((not v_ExecCtrl_started) and sizeof(v_EPTF_ExecCtrl_EntityResourceInfo_Buffer) == v_ExecCtrl_nrOfClients) or v_ExecCtrl_allLGensCreated; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_start |
| // |
| // Purpose: |
| // Start the ExecCtrl operation |
| // |
| // Parameters: |
| // - pl_createLGenPools - *in boolean - if true, LGens in LGens pools are created automatically, otherwise |
| // the function <f_EPTF_ExecCtrl_LGenPool_createLGens> has to be called later. Default: true |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // After this function is called, configuration data cannot be loaded i.e. |
| // config loaded by f_EPTF_ExecCtrl_loadConfig will be ignored. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_start(in boolean pl_createLGenPools := true) runs on EPTF_ExecCtrl_CT { |
| // Init R3 DB: |
| f_EPTF_ExecCtrl_initTypeDB(); |
| f_EPTF_ExecCtrl_loadTypeDB( |
| v_ExecCtrl_ScenarioDeclarators, |
| v_ExecCtrl_tcTypeDeclarators, |
| v_ExecCtrl_ScenarioDeclarators2, |
| v_ExecCtrl_tcTypeDeclarators2, |
| v_ExecCtrl_ScenarioDeclarators3, |
| v_ExecCtrl_ScenarioDeclaratorsR3 |
| ); |
| |
| f_EPTF_ExecCtrl_initInstanceDB(); |
| f_EPTF_ExecCtrl_loadInstanceDB( |
| v_ExecCtrl_EntityGrpDeclarators, |
| v_ExecCtrl_Scenarios2Grps, |
| v_ExecCtrl_scenario2EntityGroups |
| ); |
| // R3 end |
| |
| f_EPTF_ExecCtrl_initSc2grp(); |
| |
| f_EPTF_ExecCtrl_initScTimeProfileListDB(); |
| |
| f_EPTF_ExecCtrl_Phase_init(); |
| |
| //create scenario groups |
| f_EPTF_ExecCtrl_Phase_createScenarioGroups(); |
| |
| f_EPTF_ExecCtrl_Regulator_init(v_EPTF_ExecCtrl_RegulatorNames,v_EPTF_ExecCtrl_RegulatedItemsCFG); // this should be done at last |
| |
| f_EPTF_ExecCtrl_EntityGroupDistribution_init(v_EPTF_ExecCtrl_entityGroupDistributionCFG); |
| |
| f_EPTF_ExecCtrl_debug(log2str("value of v_ExecCtrl_tcTypeDeclarators = ", v_ExecCtrl_tcTypeDeclarators)); |
| |
| f_EPTF_ExecCtrl_LGenPool_initInstanceDB(); |
| f_EPTF_ExecCtrl_LGenPool_loadInstanceDB( |
| v_EPTF_ExecCtrl_LGenPool_Declarators, |
| v_EPTF_ExecCtrl_EntityGroup2LGenPools |
| ); |
| f_EPTF_ExecCtrl_LGenFunctions_initInstanceDB(); |
| f_EPTF_ExecCtrl_addLGenFunctionsFromDeclarators(v_EPTF_ExecCtrl_lgenCreatorFn_list); |
| |
| v_ExecCtrl_started := true; |
| f_EPTF_ExecCtrl_loadBuffered_EntityResourceInfo(); |
| |
| if (pl_createLGenPools) { |
| f_EPTF_ExecCtrl_LGenPool_createLGens(); |
| } |
| |
| if(v_ExecCtrl_nrOfClients==0 and v_ExecCtrl_allLGensCreated) { |
| if (pl_createLGenPools) { |
| t_ExecCtrl_allLGensCreated.stop; |
| } |
| f_EPTF_ExecCtrl_readyToRun(); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getManualControl |
| // |
| // Purpose: |
| // Gets the manual control mode |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // boolean - manual control mode |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getManualControl() runs on EPTF_ExecCtrl_CT return boolean |
| { |
| return v_ExecCtrl_manualControl; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setManualControl |
| // |
| // Purpose: |
| // Sets the manual control mode (overwrites config setting) |
| // |
| // Parameters: |
| // pl_manualControl - *in boolean* - true to enable manual control mode, false to disable (automatic start of scenarios) |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // It is not called in <f_EPTF_ExecCtrl_init_CT>. |
| // This function should be called before initializing the ExecCtrl component with its init function <f_EPTF_ExecCtrl_init_CT>. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setManualControl(in boolean pl_manualControl) runs on EPTF_ExecCtrl_CT |
| { |
| v_ExecCtrl_manualControl := pl_manualControl; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getTimePeriodForTcDeltaStats |
| // |
| // Purpose: |
| // Gets The time period when delta stats are refreshed |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // float - Time period when delta stats are refreshed. |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getTimePeriodForTcDeltaStats() runs on EPTF_ExecCtrl_CT return float |
| { |
| return v_EPTF_ExecCtrl_timePeriodForTcDeltaStats; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setTimePeriodForTcDeltaStats |
| // |
| // Purpose: |
| // Tells that the ExecCtrl's Time period when delta stats are refreshed. |
| // |
| // Parameters: |
| // pl_gtimePeriodForTcDeltaStats - *float* - Time period when delta stats are refreshed. |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setTimePeriodForTcDeltaStats(in float pl_gtimePeriodForTcDeltaStats) runs on EPTF_ExecCtrl_CT |
| { |
| v_EPTF_ExecCtrl_timePeriodForTcDeltaStats := pl_gtimePeriodForTcDeltaStats; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_loadConfig |
| // |
| // Purpose: |
| // Loads additional config data and appends them to existing data |
| // |
| // Parameters: |
| // pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList> |
| // pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList - *in* <EPTF_LGenBase_TcMgmt_Scenarios2GrpList> |
| // |
| // pl_EPTF_LGenBase_ScenarioDeclaratorList - *in* <EPTF_LGenBase_ScenarioDeclaratorList> |
| // pl_EPTF_LGenBase_tcTypeDeclaratorList - *in* <EPTF_LGenBase_tcTypeDeclaratorList> |
| // |
| // pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList> |
| // pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList> |
| // |
| // pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList - *in* <EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList> |
| // |
| // pl_EPTF_ExecCtrl_TimeProfileDescrList - *in* <EPTF_ExecCtrl_TimeProfileDescrList> |
| // pl_EPTF_ExecCtrl_TimeProfileList - *in* <EPTF_ExecCtrl_TimeProfileList> |
| // pl_EPTF_ExecCtrl_TimeProfile2TcList - *in* <EPTF_ExecCtrl_TimeProfile2TcList> |
| // |
| // pl_EPTF_LGenBase_ScenarioTypeDeclaratorList - *in* <EPTF_LGenBase_ScenarioTypeDeclaratorList> *optional* - Scenario Declator appeared in R3 |
| // pl_EPTF_ExecCtrl_ScenarioInstanceTypeList - *in* <EPTF_ExecCtrl_ScenarioInstanceTypeList> - scenario instance decl |
| // |
| // pl_EPTF_ExecCtrl_LGenPool_Declarators - *in* <EPTF_ExecCtrl_LGenPool_Declarators> - LGen Pool declarators |
| // pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List - *in* <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - Entity group to LGen Pool declarators |
| // |
| // pl_EPTF_ExecCtrl_LGenFunction_Entry_List - *in* <EPTF_ExecCtrl_LGenFunction_Entry_List> - the LGen creator functions to register |
| // |
| // pl_EPTF_ExecCtrl_PhaseList_Declarators - *in* <EPTF_LGenBase_PhaseList_Declarators> - list of phaseLists |
| // pl_EPTF_ExecCtrl_ScenarioGroup_Declarators - *in* <EPTF_ExecCtrl_ScenarioGroup_Declarators> - list of scenario groups |
| // |
| // pl_EPTF_ExecCtrl_RegulatorNames - *in* <EPTF_ExecCtrl_RegulatorNames> - list of regulator names |
| // pl_EPTF_ExecCtrl_RegulatedItems - *in* <EPTF_ExecCtrl_RegulatedItems> - list of regulated items |
| // |
| // pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList - *in* <EPTF_ExecCtrl_EntityGroupDistributionTypeList> - list of entity group distributions |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // All parameters are optional. If specified, the value of that parameter is appended to the corresponding data already loaded. |
| // This function can be called more than once with different arguments. It is not called in <f_EPTF_ExecCtrl_init_CT>. |
| // If you have your own tsp-s, this function can be used to load them into the ExecCtrl database. The ExecCtr |
| // should know about all declarators in the system. |
| // This function should be called before the <f_EPTF_ExecCtrl_start> function is called on the ExecCtrl component. |
| // This function can be called before the ExecCtrl is initialized with its init function <f_EPTF_ExecCtrl_init_CT>. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_loadConfig( |
| in EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList :={}, |
| in EPTF_LGenBase_TcMgmt_Scenarios2GrpList pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList :={}, |
| |
| in EPTF_LGenBase_ScenarioDeclaratorList pl_EPTF_LGenBase_ScenarioDeclaratorList :={}, |
| in EPTF_LGenBase_tcTypeDeclaratorList pl_EPTF_LGenBase_tcTypeDeclaratorList :={}, |
| |
| in EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList :={}, |
| in EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList :={}, |
| |
| in EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList :={}, |
| |
| in EPTF_ExecCtrl_TimeProfileDescrList pl_EPTF_ExecCtrl_TimeProfileDescrList := {}, |
| in EPTF_ExecCtrl_TimeProfileList pl_EPTF_ExecCtrl_TimeProfileList := {}, |
| in EPTF_ExecCtrl_TimeProfile2TcList pl_EPTF_ExecCtrl_TimeProfile2TcList := {}, |
| |
| in EPTF_LGenBase_ScenarioTypeDeclaratorList pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := {}, |
| in EPTF_ExecCtrl_ScenarioInstanceTypeList pl_EPTF_ExecCtrl_ScenarioInstanceTypeList := {}, |
| |
| in EPTF_ExecCtrl_LGenPool_Declarators pl_EPTF_ExecCtrl_LGenPool_Declarators := {}, |
| in EPTF_ExecCtrl_EntityGroup2LGenPool_List pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := {}, |
| |
| in EPTF_ExecCtrl_LGenFunction_Entry_List pl_EPTF_ExecCtrl_LGenFunction_Entry_List := {}, |
| |
| in EPTF_LGenBase_PhaseList_Declarators pl_EPTF_ExecCtrl_PhaseList_Declarators := {}, |
| in EPTF_ExecCtrl_ScenarioGroup_Declarators pl_EPTF_ExecCtrl_ScenarioGroup_Declarators := {}, |
| |
| in EPTF_ExecCtrl_RegulatorNames pl_EPTF_ExecCtrl_RegulatorNames := {}, |
| in EPTF_ExecCtrl_RegulatedItems pl_EPTF_ExecCtrl_RegulatedItems := {}, |
| |
| in EPTF_ExecCtrl_EntityGroupDistributionTypeList pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList := {} |
| |
| ) runs on EPTF_ExecCtrl_CT { |
| if (v_ExecCtrl_started) { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": Config not loaded: ExecCtrl was already started")); |
| return; |
| } |
| // load pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_EntityGrpDeclarators); |
| v_ExecCtrl_EntityGrpDeclarators[vl_currentSize] := pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList[i]; |
| } |
| // load pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_Scenarios2Grps); |
| v_ExecCtrl_Scenarios2Grps[vl_currentSize] := pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList[i]; |
| } |
| |
| |
| // load pl_EPTF_LGenBase_ScenarioDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_ScenarioDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_ScenarioDeclarators); |
| v_ExecCtrl_ScenarioDeclarators[vl_currentSize] := pl_EPTF_LGenBase_ScenarioDeclaratorList[i]; |
| } |
| // load pl_EPTF_LGenBase_tcTypeDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_tcTypeDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_tcTypeDeclarators); |
| v_ExecCtrl_tcTypeDeclarators[vl_currentSize] := pl_EPTF_LGenBase_tcTypeDeclaratorList[i]; |
| } |
| |
| |
| // load pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_tcTypeDeclarators2); |
| v_ExecCtrl_tcTypeDeclarators2[vl_currentSize] := pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList[i]; |
| } |
| // load pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_ScenarioDeclarators2); |
| v_ExecCtrl_ScenarioDeclarators2[vl_currentSize] := pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList[i]; |
| } |
| |
| |
| // load pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_ScenarioDeclarators3); |
| v_ExecCtrl_ScenarioDeclarators3[vl_currentSize] := pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_TimeProfileDescrList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_TimeProfileDescrList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_TimeProfileDescrList); |
| v_EPTF_ExecCtrl_TimeProfileDescrList[vl_currentSize] := pl_EPTF_ExecCtrl_TimeProfileDescrList[i]; |
| } |
| // load pl_EPTF_ExecCtrl_TimeProfileList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_TimeProfileList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_TimeProfileList); |
| v_EPTF_ExecCtrl_TimeProfileList[vl_currentSize] := pl_EPTF_ExecCtrl_TimeProfileList[i]; |
| } |
| // load pl_EPTF_ExecCtrl_TimeProfile2TcList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_TimeProfile2TcList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_TimeProfile2TcList); |
| v_EPTF_ExecCtrl_TimeProfile2TcList[vl_currentSize] := pl_EPTF_ExecCtrl_TimeProfile2TcList[i]; |
| } |
| |
| // load pl_EPTF_LGenBase_ScenarioTypeDeclaratorList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_LGenBase_ScenarioTypeDeclaratorList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_ScenarioDeclaratorsR3); |
| v_ExecCtrl_ScenarioDeclaratorsR3[vl_currentSize] := pl_EPTF_LGenBase_ScenarioTypeDeclaratorList[i]; |
| } |
| // load pl_EPTF_ExecCtrl_ScenarioInstanceTypeList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_ScenarioInstanceTypeList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_ExecCtrl_scenario2EntityGroups); |
| v_ExecCtrl_scenario2EntityGroups[vl_currentSize] := pl_EPTF_ExecCtrl_ScenarioInstanceTypeList[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_LGenPool_Declarators: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_LGenPool_Declarators); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_LGenPool_Declarators); |
| v_EPTF_ExecCtrl_LGenPool_Declarators[vl_currentSize] := pl_EPTF_ExecCtrl_LGenPool_Declarators[i]; |
| } |
| // load pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_EntityGroup2LGenPools); |
| v_EPTF_ExecCtrl_EntityGroup2LGenPools[vl_currentSize] := pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_LGenFunction_Entry_List: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_LGenFunction_Entry_List); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_lgenCreatorFn_list); |
| v_EPTF_ExecCtrl_lgenCreatorFn_list[vl_currentSize] := pl_EPTF_ExecCtrl_LGenFunction_Entry_List[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_PhaseList_Declarators: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_PhaseList_Declarators); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_PhaseList_Declarators); |
| v_EPTF_ExecCtrl_PhaseList_Declarators[vl_currentSize] := pl_EPTF_ExecCtrl_PhaseList_Declarators[i]; |
| } |
| // load pl_EPTF_ExecCtrl_PhaseList_Declarators: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_ScenarioGroup_Declarators); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_ScenarioGroup_Declarators); |
| v_EPTF_ExecCtrl_ScenarioGroup_Declarators[vl_currentSize] := pl_EPTF_ExecCtrl_ScenarioGroup_Declarators[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_RegulatorNames: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_RegulatorNames); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_RegulatorNames); |
| v_EPTF_ExecCtrl_RegulatorNames[vl_currentSize] := pl_EPTF_ExecCtrl_RegulatorNames[i]; |
| } |
| // load pl_EPTF_ExecCtrl_RegulatedItems: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_RegulatedItems); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_RegulatedItemsCFG); |
| v_EPTF_ExecCtrl_RegulatedItemsCFG[vl_currentSize] := pl_EPTF_ExecCtrl_RegulatedItems[i]; |
| } |
| |
| // load pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList: |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList); i<size; i:=i+1) { |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_entityGroupDistributionCFG); |
| v_EPTF_ExecCtrl_entityGroupDistributionCFG[vl_currentSize] := pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList[i]; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setTimeFormat |
| // |
| // Purpose: |
| // Sets the timeformat for the timeElapsed variable |
| // |
| // Parameters: |
| // in <EPTF_ExecCtrl_timeFormat> pl_timeFormat : the new timeformat to set |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setTimeFormat(in EPTF_ExecCtrl_timeFormat pl_timeFormat) runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_timeFormat := pl_timeFormat; |
| } |
| |
| private function f_EPTF_ExecCtrl_handleLoadConfig(in EPTF_ExecCtrlClient_CT pl_client, in EPTF_ExecCtrlClient_LoadConfig pl_config) runs on EPTF_ExecCtrl_CT { |
| if (v_ExecCtrl_started) { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": Config received from ",pl_client," not loaded: ExecCtrl was already started. Config ignored: ", pl_config)); |
| return; |
| } |
| f_EPTF_ExecCtrl_loadConfig( |
| pl_config.pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList, |
| pl_config.pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList, |
| |
| pl_config.pl_EPTF_LGenBase_ScenarioDeclaratorList, |
| pl_config.pl_EPTF_LGenBase_tcTypeDeclaratorList, |
| |
| pl_config.pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList, |
| pl_config.pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList, |
| |
| pl_config.pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList, |
| |
| pl_config.pl_EPTF_ExecCtrl_TimeProfileDescrList, |
| pl_config.pl_EPTF_ExecCtrl_TimeProfileList, |
| pl_config.pl_EPTF_ExecCtrl_TimeProfile2TcList, |
| |
| pl_config.pl_EPTF_LGenBase_ScenarioTypeDeclaratorList, |
| pl_config.pl_EPTF_ExecCtrl_ScenarioInstanceTypeList, |
| |
| pl_config.pl_EPTF_ExecCtrl_LGenPool_Declarators, |
| pl_config.pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List, |
| |
| {},//pl_config.pl_EPTF_ExecCtrl_LGenFunction_Entry_List, |
| |
| pl_config.pl_EPTF_ExecCtrl_PhaseList_Declarators, |
| pl_config.pl_EPTF_ExecCtrl_ScenarioGroup_Declarators, |
| |
| pl_config.pl_EPTF_ExecCtrl_RegulatorNames, |
| pl_config.pl_EPTF_ExecCtrl_RegulatedItems, |
| |
| pl_config.pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList |
| ); |
| } |
| |
| private altstep as_EPTF_ExecCtrl_MgmtIf_handleLoadConfig() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrlClient_CT vl_client; |
| var EPTF_ExecCtrlClient_LoadConfig v_msg; |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrlClient_LoadConfig:?) -> value v_msg sender vl_client { |
| f_EPTF_ExecCtrl_debug("DEBUG: EPTF_ExecCtrlClient_LoadConfig received..."); |
| f_EPTF_ExecCtrl_handleLoadConfig(vl_client,v_msg); |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_initSc2grp |
| // |
| // Purpose: |
| // Preprocess <v_ExecCtrl_Scenarios2Grps> -> Only one scenario will be associated to each entityGrp |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_initSc2grp()runs on EPTF_ExecCtrl_CT { |
| var EPTF_LGenBase_TcMgmt_Scenarios2GrpList v_ExecCtrl_Scenarios2Grps_orig := v_ExecCtrl_Scenarios2Grps; |
| v_ExecCtrl_Scenarios2Grps := {}; |
| var integer vl_grp := 0; |
| for(var integer i:=0, size := sizeof(v_ExecCtrl_Scenarios2Grps_orig); i<size; i:=i+1) { |
| for(var integer j:=0, sizej := sizeof(v_ExecCtrl_Scenarios2Grps_orig[i].scenarioNames); j<sizej; j:=j+1) { |
| v_ExecCtrl_Scenarios2Grps[vl_grp] := { |
| v_ExecCtrl_Scenarios2Grps_orig[i].eGrpName, |
| { v_ExecCtrl_Scenarios2Grps_orig[i].scenarioNames[j] } |
| }; |
| vl_grp := vl_grp + 1; |
| } |
| } |
| } |
| |
| group TimeProfile { |
| |
| |
| // uses modulepar EPTF_ExecCtrl_TimeProfileDescrList tsp_EPTF_ExecCtrl_TimeProfileDescrList := {}; |
| // and modulepar EPTF_ExecCtrl_TimeProfile2TcList tsp_EPTF_ExecCtrl_TimeProfile2TcList := {}; |
| // to initialize the v_EPTF_ExecCtrl_ScTimeProfileListDB database |
| // only declarator2 is supported |
| private function f_EPTF_ExecCtrl_initScTimeProfileListDB() runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_ScTimeProfileDB := {}; |
| // going through the scenario instances: |
| for (var integer sidx := 0, size := sizeof(v_ExecCtrl_scenarios); sidx < size; sidx := sidx + 1) |
| { |
| var integer vl_sizeTCs := sizeof(v_ExecCtrl_scenarios[sidx].scData.tcList); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_sizeTCs := 1; |
| } |
| for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1) |
| { |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| f_EPTF_ExecCtrl_initProfileForSc(/*grp,*/sidx); |
| } else { |
| f_EPTF_ExecCtrl_initProfileForTc(/*grp,*/sidx,tcidx); |
| } |
| |
| } |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_TimeProfile2TcList: ", v_EPTF_ExecCtrl_TimeProfile2TcList)); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_TimeProfileDescrList: ", v_EPTF_ExecCtrl_TimeProfileDescrList)); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_ScTimeProfileDB: ", v_EPTF_ExecCtrl_ScTimeProfileDB)); |
| } |
| |
| // initializes the time profile database for a traffic case |
| private function f_EPTF_ExecCtrl_initProfileForTc( |
| // in integer grp, |
| in integer sidx, |
| in integer tcidx |
| ) runs on EPTF_ExecCtrl_CT { |
| |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx] := { |
| timeProfileIdList := {}, |
| timeProfileIdx := -1, |
| eventIdList := {} |
| }; // time prof not defined for this TC |
| |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[sidx].scData,tcidx) |
| var EPTF_ExecCtrl_TCName tcId := { |
| eGrpName := v_ExecCtrl_entityGroups[v_ExecCtrl_scenarios[sidx].eGroupIdx].name, |
| scName := v_ExecCtrl_scenarios[sidx].scData.name, |
| tcName := vl_tcName |
| } |
| |
| // find time profile for this tc: |
| for (var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_TimeProfile2TcList); i<size; i:=i+1) { |
| // if (v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId == tcId) { // this is syntactically erroneous |
| if (v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId.eGrpName == tcId.eGrpName |
| and v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId.scName == tcId.scName |
| and v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId.tcName == tcId.tcName) { |
| // time prof found |
| // find the time profile data: |
| var integer vl_timeProfileIdx := -1; |
| for (var integer tpIdx := 0, sizet := sizeof(v_EPTF_ExecCtrl_TimeProfileList); tpIdx<sizet; tpIdx:=tpIdx+1) { |
| if (v_EPTF_ExecCtrl_TimeProfileList[tpIdx].name == v_EPTF_ExecCtrl_TimeProfile2TcList[i].timeProfileName) { |
| vl_timeProfileIdx := tpIdx; |
| break; |
| } |
| } |
| |
| if(vl_timeProfileIdx == -1){ |
| f_EPTF_ExecCtrl_error(%definitionId&": Unable to find the time profile " &v_EPTF_ExecCtrl_TimeProfile2TcList[i].timeProfileName&" in v_EPTF_ExecCtrl_TimeProfileList"); |
| } |
| |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdx := vl_timeProfileIdx; |
| |
| // search time profile data for each profile in the list: |
| for(var integer k:=0, sizek := sizeof(v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList); k<sizek; k:=k+1) { |
| for(var integer j:=0, sizej := sizeof(v_EPTF_ExecCtrl_TimeProfileDescrList); j<sizej; j:=j+1) { |
| if (v_EPTF_ExecCtrl_TimeProfileDescrList[j].name == v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[k].timeProfileDescrName) { |
| // time profile found: |
| // append data into DB: |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList); |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList[vl_currentSize] := j; |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[vl_currentSize] := -1; // no event yet |
| break; |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| } |
| |
| // initializes the time profile database for a weighted scenario |
| private function f_EPTF_ExecCtrl_initProfileForSc( |
| // in integer grp, |
| in integer sidx |
| ) runs on EPTF_ExecCtrl_CT { |
| |
| var integer tcidx := 0; // tc 0 will contain the time profile data for the scenario CPS |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx] := { |
| timeProfileIdList := {}, |
| timeProfileIdx := -1, |
| eventIdList := {} |
| }; // time prof not defined for this TC |
| |
| var EPTF_ExecCtrl_SCName tcId := { |
| eGrpName := v_ExecCtrl_entityGroups[v_ExecCtrl_scenarios[sidx].eGroupIdx].name, |
| scName := v_ExecCtrl_scenarios[sidx].scData.name |
| } |
| |
| // find time profile for this tc: |
| for (var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_TimeProfile2TcList); i<size; i:=i+1) { |
| // if (v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId == tcId) { // this is syntactically erroneous |
| // TCName ignored in timeProfile data, because it is a weighted scenario! |
| if (v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId.eGrpName == tcId.eGrpName |
| and v_EPTF_ExecCtrl_TimeProfile2TcList[i].tcId.scName == tcId.scName) { |
| // time prof found |
| // find the time profile data: |
| var integer vl_timeProfileIdx := -1; |
| for (var integer tpIdx :=0, sizet := sizeof(v_EPTF_ExecCtrl_TimeProfileList); tpIdx<sizet; tpIdx:=tpIdx+1) { |
| if (v_EPTF_ExecCtrl_TimeProfileList[tpIdx].name == v_EPTF_ExecCtrl_TimeProfile2TcList[i].timeProfileName) { |
| vl_timeProfileIdx := tpIdx; |
| break; |
| } |
| } |
| |
| f_EPTF_Base_assert(%definitionId&": Unable to find the time profile " &v_EPTF_ExecCtrl_TimeProfile2TcList[i].timeProfileName&" in v_EPTF_ExecCtrl_TimeProfileList", vl_timeProfileIdx!=-1); |
| |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdx := vl_timeProfileIdx; |
| |
| // search time profile data for each profile in the list: |
| for(var integer k:=0, sizek := sizeof(v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList); k<sizek; k:=k+1) { |
| for(var integer j:=0, sizej := sizeof(v_EPTF_ExecCtrl_TimeProfileDescrList); j<sizej; j:=j+1) { |
| if (v_EPTF_ExecCtrl_TimeProfileDescrList[j].name == v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[k].timeProfileDescrName) { |
| // time profile found: |
| // append data into DB: |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList); |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList[vl_currentSize] := j; |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[vl_currentSize] := -1; // no event yet |
| break; |
| } |
| } |
| } |
| break; |
| } |
| } |
| |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getTimeProfileNameForTC |
| // |
| // Purpose: |
| // Returns the time profile name for a traffic case instance |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - the scenario instance idx |
| // pl_tcOfScIdx - *in integer* - the traffic case index in the scenario |
| // |
| // Return Value: |
| // charstring - name of the time profile ("" if no time profile is set) |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_getTimeProfileNameForTC( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx |
| ) runs on EPTF_ExecCtrl_CT return charstring { |
| var charstring vl_timeProfileName := "" |
| if (v_EPTF_ExecCtrl_ScTimeProfileDB[pl_scIdx].tcTimeProfile[pl_tcOfScIdx].timeProfileIdx != -1) { |
| vl_timeProfileName := v_EPTF_ExecCtrl_TimeProfileList[v_EPTF_ExecCtrl_ScTimeProfileDB[pl_scIdx].tcTimeProfile[pl_tcOfScIdx].timeProfileIdx].name; |
| } |
| return vl_timeProfileName; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startTimeProfiles |
| // |
| // Purpose: |
| // Starts all time profiles by scheduling their first event |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startTimeProfiles() runs on EPTF_ExecCtrl_CT { |
| |
| v_EPTF_ExecCtrl_startTime := T_EPTF_componentClock.read; // read the scheduler clock to store the time of start |
| for (var integer sidx := 0, size := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB); sidx < size; sidx := sidx + 1) |
| { |
| for (var integer tcidx := 0, tsize := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile); tcidx < tsize; tcidx := tcidx + 1) |
| { |
| f_EPTF_ExecCtrl_startProfileForTc(/*grp,*/sidx,tcidx); |
| |
| } |
| } |
| |
| f_EPTF_ExecCtrl_debug("**********TIMEPROF STARTED*************"); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_ScTimeProfileDB after start: ", v_EPTF_ExecCtrl_ScTimeProfileDB)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopTimeProfiles |
| // |
| // Purpose: |
| // stops the time profile execution |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopTimeProfiles() runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_startTime := -1.0; // this value is used to ignore additional time profile events |
| |
| for (var integer sidx := 0, size := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB); sidx < size; sidx := sidx + 1) |
| { |
| for (var integer tcidx := 0, tsize := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile); tcidx < tsize; tcidx := tcidx + 1) |
| { |
| // here you should include your code: |
| |
| for (var integer i:=0, lsize := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList); i<lsize; i:=i+1) { |
| var integer vl_eventIndex := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[i]; |
| // Cancel the event: |
| if (vl_eventIndex !=-1) { |
| if(not f_EPTF_SchedulerComp_CancelEvent(vl_eventIndex)) { |
| f_EPTF_ExecCtrl_warning(%definitionId& ": could not cancel event."); |
| } |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[i] := -1; |
| } |
| } // end of for i |
| } |
| } |
| f_EPTF_ExecCtrl_debug("**********TIMEPROF STOPPED*************"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startTime |
| // |
| // Purpose: |
| // Returns the start time of the test execution |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // float - the start time (-1.0 if not running) |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_startTime() runs on EPTF_ExecCtrl_CT return float { |
| return v_EPTF_ExecCtrl_startTime; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startAllScenarios |
| // |
| // Purpose: |
| // Starts all scenarios in ExecCtrl |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Starts all enabled scenarios. Also starts scenario groups |
| // and time profiles |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startAllScenarios() runs on EPTF_ExecCtrl_CT |
| { |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_scenarios); sc<size; sc:=sc+1) { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Checking scenario status"); |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[sc].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[sc].scData.name; |
| |
| if (f_EPTF_ExecCtrl_checkScenarioStatus({ |
| eGrpName := eGrpName, |
| scName := scenName |
| }, |
| t_ExecCtrl_scenarioReadyToStart)) |
| { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is ready to start")); |
| |
| // Start scenario on LGens |
| if (f_EPTF_ExecCtrl_scenarioEnabled(sc) |
| and f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(sc)) { |
| f_EPTF_ExecCtrl_startScenarioOnLGens(sc); |
| } |
| } |
| else { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is NOT ready to start")); |
| |
| //return |
| } |
| } |
| |
| f_EPTF_ExecCtrl_startAllScenarioGroups(); |
| |
| // f_EPTF_Logging_debug(tsp_debug_EPTF_ExecCtrl_UIVars, |
| // "All scenarios are ready to run"); |
| |
| // start the time profiles: |
| f_EPTF_ExecCtrl_startTimeProfiles(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startAllScenarioGroups |
| // |
| // Purpose: |
| // Starts all scenarios in ExecCtrl that are in scenario groups |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startAllScenarioGroups() runs on EPTF_ExecCtrl_CT { |
| for(var integer scGroupIdx :=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data); scGroupIdx<size; scGroupIdx:=scGroupIdx+1) { |
| f_EPTF_ExecCtrl_ScenarioGroup_start(scGroupIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopCurrentPhaseForAllScenarioGroups |
| // |
| // Purpose: |
| // Starts all scenarios in ExecCtrl that are in scenario groups |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopCurrentPhaseForAllScenarioGroups() runs on EPTF_ExecCtrl_CT { |
| for(var integer scGroupIdx :=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data); scGroupIdx<size; scGroupIdx:=scGroupIdx+1) { |
| f_EPTF_ExecCtrl_ScenarioGroup_stop(scGroupIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopAllScenarioGroups |
| // |
| // Purpose: |
| // Stops all scenario groups |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopAllScenarioGroups() runs on EPTF_ExecCtrl_CT { |
| for(var integer scGroupIdx :=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data); scGroupIdx<size; scGroupIdx:=scGroupIdx+1) { |
| f_EPTF_ExecCtrl_ScenarioGroup_stop(scGroupIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_terminateAllScenarioGroups |
| // |
| // Purpose: |
| // Terminates all scenario groups |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Stops all scenario groups so that the phase actions |
| // are not executed, all scenarios in the scenario groups |
| // are stopped. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_terminateAllScenarioGroups() runs on EPTF_ExecCtrl_CT { |
| for(var integer scGroupIdx :=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data); scGroupIdx<size; scGroupIdx:=scGroupIdx+1) { |
| f_EPTF_ExecCtrl_stopScenarioGroupOnLGens(scGroupIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopAllScenarios |
| // |
| // Purpose: |
| // Stops all scenarios in ExecCtrl |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Also stops time profiles and scenario groups. |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopAllScenarios() runs on EPTF_ExecCtrl_CT { |
| // stop the time profiles: |
| f_EPTF_ExecCtrl_stopTimeProfiles(); |
| |
| // stop scenario groups |
| f_EPTF_ExecCtrl_stopAllScenarioGroups(); |
| |
| // Stop scenarios |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_scenarios); sc<size; sc:=sc+1) { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Checking scenario status"); |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[sc].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[sc].scData.name; |
| |
| if (f_EPTF_ExecCtrl_checkScenarioStatus({ |
| eGrpName := eGrpName, |
| scName := scenName |
| }, |
| t_ExecCtrl_scenarioReadyToStop)) |
| { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is ready to stop")); |
| |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(sc)) { |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(sc); |
| } |
| |
| } |
| else { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is NOT ready to stop")); |
| |
| //return |
| } |
| } |
| |
| |
| // f_EPTF_Logging_debug(tsp_debug_EPTF_ExecCtrl_UIVars, |
| // "DEBUG: all scenarios are ready to stop"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_terminateAllScenarios |
| // |
| // Purpose: |
| // Terminates all scenarios in ExecCtrl |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Also stops time profiles and terminates scenario groups. |
| // Normal scenarios are stopped the same way as in |
| // <f_EPTF_ExecCtrl_stopAllScenarios> |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_terminateAllScenarios() runs on EPTF_ExecCtrl_CT { |
| // stop the time profiles: |
| f_EPTF_ExecCtrl_stopTimeProfiles(); |
| |
| // terminate scenario groups |
| f_EPTF_ExecCtrl_terminateAllScenarioGroups(); |
| |
| // Stop scenarios |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_scenarios); sc<size; sc:=sc+1) { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Checking scenario status"); |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[sc].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[sc].scData.name; |
| |
| if (f_EPTF_ExecCtrl_checkScenarioStatus({ |
| eGrpName := eGrpName, |
| scName := scenName |
| }, |
| t_ExecCtrl_scenarioReadyToStop)) |
| { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is ready to stop")); |
| |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(sc)) { |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(sc); |
| } |
| |
| } |
| else { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is NOT ready to stop")); |
| |
| //return |
| } |
| } |
| |
| |
| // f_EPTF_Logging_debug(tsp_debug_EPTF_ExecCtrl_UIVars, |
| // "DEBUG: all scenarios are ready to stop"); |
| } |
| |
| // starts a time profile by scheduling its first event |
| // only one event is running for each profile at a time. counters and data are passed in the eventId |
| private function f_EPTF_ExecCtrl_startProfileForTc( |
| // in integer grp, |
| in integer sidx, |
| in integer tcidx |
| ) runs on EPTF_ExecCtrl_CT { |
| |
| var integer timeProfileDataPos := 0; // current position in timeProfileData |
| var integer nofRepetition := 0; // current nofRepetition |
| |
| // go through in the list of time profiles for this Tc: |
| for (var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList); i<size; i:=i+1) { |
| // schedule the first event: |
| f_EPTF_ExecCtrl_TimeProfile_ScheduleEvent(sidx,tcidx,i,timeProfileDataPos,nofRepetition); |
| } // end of for i |
| |
| } |
| |
| // handles the time profile event |
| private function f_EPTF_ExecCtrl_TimeProfileEventHandler( |
| in EPTF_ScheduledAction pl_action, in integer pl_eventIndex |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": pl_action being handled: ", pl_action)); |
| |
| if (v_EPTF_ExecCtrl_startTime == -1.0) { |
| f_EPTF_ExecCtrl_debug("TimeProfile execution was stopped, event ignored."); |
| return true; // do not handle the event |
| } |
| |
| var integer sidx := pl_action.actionId[0]; |
| var integer tcidx := pl_action.actionId[1]; |
| var integer i := pl_action.actionId[2]; |
| var integer timeProfileDataPos := pl_action.actionId[3]; |
| var integer nofRepetition := pl_action.actionId[4]; |
| |
| |
| var integer vl_timeProfileIdx := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdx; |
| var integer vl_timeProfileId := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList[i]; |
| |
| // set CPS: |
| var float targetValue := f_EPTF_ExecCtrl_getTimeProfileTargetValue(sidx,tcidx,i,timeProfileDataPos); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| f_EPTF_ExecCtrl_setCps_SC(sidx,targetValue); |
| } else { |
| f_EPTF_ExecCtrl_setCps_TC(sidx,tcidx,targetValue); |
| } |
| |
| //reschedule event: |
| timeProfileDataPos := timeProfileDataPos + 1; |
| // end of time profile reached: |
| if (timeProfileDataPos==sizeof(v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId].timeProfileData)) { |
| // increase repetition: |
| nofRepetition := nofRepetition + 1; |
| // restore position to the beginning: |
| timeProfileDataPos := 0; |
| } |
| |
| // max repetition reached (-1: will continue to infty): |
| // (repetition reaches maxRepetition+1: the profile executed maxRepetition times + the first execution) |
| if (v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[i].nofRepetition != -1 |
| and nofRepetition == v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[i].nofRepetition + 1) { |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[i] := -1; // reset the event id |
| return true; // no more event scheduled |
| } |
| |
| // schedule the new event: |
| f_EPTF_ExecCtrl_TimeProfile_ScheduleEvent(sidx,tcidx,i,timeProfileDataPos,nofRepetition); |
| |
| return true; |
| } |
| |
| // schedules the time profile event |
| private function f_EPTF_ExecCtrl_TimeProfile_ScheduleEvent( |
| // in integer grp, |
| in integer sidx, |
| in integer tcidx, |
| in integer tpidx, // index in v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList |
| in integer timeProfileDataPos, |
| in integer nofRepetition |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_timeProfileIdx := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdx; |
| var integer vl_timeProfileId := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList[tpidx]; |
| |
| // f_EPTF_ExecCtrl_debug(log2str("vl_timeProfileIdx: ", vl_timeProfileIdx)); |
| // f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx]: ", v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx])); |
| // f_EPTF_ExecCtrl_debug(log2str("vl_timeProfileId: ", vl_timeProfileId)); |
| // f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId]: ", v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId])); |
| |
| var float vl_when := v_EPTF_ExecCtrl_startTime + |
| v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[tpidx].startTime |
| + v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId].timeProfileData[timeProfileDataPos].time |
| + int2float(nofRepetition)*v_EPTF_ExecCtrl_TimeProfileList[vl_timeProfileIdx].timeProfileList[tpidx].periodOfRepetition; |
| var EPTF_Scheduler_ActionHandler vl_actionHandler := refers(f_EPTF_ExecCtrl_TimeProfileEventHandler); |
| var EPTF_ActionId vl_action := { |
| //grp, |
| sidx, |
| tcidx, |
| tpidx, // index in v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList |
| timeProfileDataPos, // index in v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId].timeProfileData |
| nofRepetition // current nofRepetition |
| }; |
| |
| f_EPTF_ExecCtrl_debug(log2str("scheduling action: ", vl_action, " to: ", vl_when)); |
| |
| var integer vl_eventIndex; |
| if (f_EPTF_SchedulerComp_scheduleAction( |
| vl_when, |
| vl_actionHandler, |
| vl_action, |
| vl_eventIndex |
| )) {}; // to remove the warning |
| |
| // store event idx: |
| v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].eventIdList[tpidx] := vl_eventIndex; |
| |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_ScTimeProfileDB[",sidx,"].tcTimeProfile[",tcidx,"] after schedule: ", v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx])); |
| } |
| |
| // gets the target value from time profile data for a Traffic Case |
| private function f_EPTF_ExecCtrl_getTimeProfileTargetValue ( |
| // in integer grp, |
| in integer sidx, |
| in integer tcidx, |
| in integer i, |
| in integer timeProfileDataPos |
| ) runs on EPTF_ExecCtrl_CT return float { |
| var integer vl_timeProfileId := v_EPTF_ExecCtrl_ScTimeProfileDB[sidx].tcTimeProfile[tcidx].timeProfileIdList[i]; |
| return v_EPTF_ExecCtrl_TimeProfileDescrList[vl_timeProfileId].timeProfileData[timeProfileDataPos].targetValue; |
| } |
| |
| } // group TimeProfile |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setCps_TC |
| // |
| // Purpose: |
| // sets the Traffic case CPS in all related LGens |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - the scenario instace idx |
| // pl_tcOfScIdx - *in integer* - the tc of scenario idx |
| // cps - *in float* - CPS to set |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setCps_TC ( |
| // in integer grp, |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx, |
| in float cps |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| f_EPTF_Base_assert(%definitionId&": Cannot set traffic case CPS in the weighted scenario "& |
| v_ExecCtrl_scenarios[pl_scIdx].name, |
| not f_EPTF_ExecCtrl_isWeightedScenario(pl_scIdx)); |
| |
| var integer vl_tcIdx :=v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[pl_tcOfScIdx]; |
| f_EPTF_ExecCtrl_setCPSToReach_TC(vl_tcIdx,cps); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setCps_SC |
| // |
| // Purpose: |
| // sets the Scenario CPS in all related LGens |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - the scenario instace idx |
| // cps - *in float* - CPS to set |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setCps_SC ( |
| // in integer grp, |
| in integer pl_scIdx, |
| in float cps |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_setCPSToReach_SC(pl_scIdx,cps); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setStartDelay_TC |
| // |
| // Purpose: |
| // sets the Traffic case startDelay in all related LGens |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - the scenario instace idx |
| // pl_tcOfScIdx - *in integer* - the tc of scenario idx |
| // startDelay - *in float* - startDelay to set |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setStartDelay_TC ( |
| // in integer grp, |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx, |
| in float pl_startDelay |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| f_EPTF_Base_assert(%definitionId&": Cannot set traffic case StartDelay in the weighted scenario "& |
| v_ExecCtrl_scenarios[pl_scIdx].name, |
| not f_EPTF_ExecCtrl_isWeightedScenario(pl_scIdx)); |
| |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].startDelay := pl_startDelay; |
| f_EPTF_ExecCtrl_debug(log2str("updated v_ExecCtrl_scenarios[",pl_scIdx,"].scData.tcList[",pl_tcOfScIdx,"].startDelay: ", pl_startDelay)); |
| |
| f_EPTF_ExecCtrl_sendUpdatedStartDelay(pl_scIdx,pl_tcOfScIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getCPSToReach_TC |
| // |
| // Purpose: |
| // returns the target CPS of a traffic case instance |
| // |
| // Parameters: |
| // pl_tcIdx - *in integer* - id of the traffic case instance |
| // |
| // Return Value: |
| // float - the targetCPS (i.e. the cpsToReach) of the traffic case |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getCPSToReach_TC( |
| in integer pl_tcIdx |
| ) runs on EPTF_ExecCtrl_CT return float { |
| f_EPTF_Base_assert(%definitionId&": Invalid TC index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| f_EPTF_Base_assert(%definitionId&": cpsToReach is not available for the traffic case "& |
| f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)&": traffic case is in a weighted scenario: " |
| &f_EPTF_ExecCtrl_getScenarioInstanceName(vl_scIdx), |
| not f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)); |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScIdx].target.cpsToReach; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setCPSToReach_TC |
| // |
| // Purpose: |
| // Sets the target CPS of a traffic case instance |
| // |
| // Parameters: |
| // pl_tcIdx - *in integer* - id of the traffic case instance |
| // pl_cpsToReach - *in float* - the targetCPS (i.e. the cpsToReach) to set |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setCPSToReach_TC( |
| in integer pl_tcIdx, |
| in float pl_cpsToReach |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid TC index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| f_EPTF_Base_assert(%definitionId&": Cannot set cpsToReach for the traffic case "& |
| f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)&": traffic case is in a weighted scenario: " |
| &f_EPTF_ExecCtrl_getScenarioInstanceName(vl_scIdx), |
| not f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)); |
| |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScIdx].target.cpsToReach := pl_cpsToReach; |
| |
| f_EPTF_ExecCtrl_debug(log2str("updated v_ExecCtrl_scenarios[",vl_scIdx,"].scData.tcList[",vl_tcOfScIdx,"].target.cpsToReach: ", v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScIdx].target.cpsToReach)); |
| f_EPTF_ExecCtrl_sendUpdatedCps(vl_scIdx,vl_tcOfScIdx); |
| f_EPTF_ExecCtrl_callCPSChangedCallbacks_TC(pl_cpsToReach,v_ExecCtrl_scenarios[vl_scIdx].tcIdxList[vl_tcOfScIdx]); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getCPSToReach_SC |
| // |
| // Purpose: |
| // returns the target CPS of a scenario instance |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - id of the scenario instance |
| // |
| // Return Value: |
| // float - the targetCPS (i.e. the cpsToReach) of the scenario |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getCPSToReach_SC( |
| in integer pl_scIdx |
| ) runs on EPTF_ExecCtrl_CT return float { |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": CPSToReach is not available for non-weighted scenario: " |
| &f_EPTF_ExecCtrl_getScenarioInstanceName(pl_scIdx), |
| f_EPTF_ExecCtrl_isWeightedScenario(pl_scIdx)); |
| return v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setCPSToReach_SC |
| // |
| // Purpose: |
| // Sets the target CPS of a scenario instance |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - id of the scenario instance |
| // pl_cpsToReach - *in float* - the targetCPS (i.e. the cpsToReach) to set |
| // |
| // Return Value: |
| // float - the targetCPS (i.e. the cpsToReach) of the scenario |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setCPSToReach_SC( |
| in integer pl_scIdx, |
| in float pl_cpsToReach |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Cannot set scenario CPS in the non-weighted scenario "& |
| v_ExecCtrl_scenarios[pl_scIdx].name, |
| f_EPTF_ExecCtrl_isWeightedScenario(pl_scIdx)); |
| |
| v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach := pl_cpsToReach; |
| |
| f_EPTF_ExecCtrl_debug(log2str("updated v_ExecCtrl_scenarios[",pl_scIdx,"].scData.weightedScData.cpsToReach: ", v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach)); |
| f_EPTF_ExecCtrl_sendUpdatedScenarioCps(pl_scIdx); |
| f_EPTF_ExecCtrl_callCPSChangedCallbacks_SC(pl_cpsToReach,pl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getTCWeight |
| // |
| // Purpose: |
| // returns the weight of the traffic case instance in the weighted scenario |
| // |
| // Parameters: |
| // pl_tcIdx - *in integer* - id of the traffic case instance |
| // |
| // Return Value: |
| // float - the tcWeight of the traffic case |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getTCWeight( |
| in integer pl_tcIdx |
| ) runs on EPTF_ExecCtrl_CT return float { |
| f_EPTF_Base_assert(%definitionId&": Invalid index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| f_EPTF_Base_assert(%definitionId&": Traffic case weight is not available for the traffic case "& |
| f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)&": traffic case is not in a weighted scenario: " |
| &f_EPTF_ExecCtrl_getScenarioInstanceName(vl_scIdx), |
| f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)); |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScIdx].target.trafficWeight; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setTCWeight |
| // |
| // Purpose: |
| // Sets the weight of the traffic case instance in the weighted scenario |
| // |
| // Parameters: |
| // pl_tcIdx - *in integer* - id of the traffic case instance |
| // pl_tcWeight - *in float* - the weight of the traffic case |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setTCWeight( |
| in integer pl_tcIdx, |
| in float pl_tcWeight |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| f_EPTF_Base_assert(%definitionId&": Traffic case weight is not available for the traffic case "& |
| f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)&": traffic case is not in a weighted scenario: " |
| &f_EPTF_ExecCtrl_getScenarioInstanceName(vl_scIdx), |
| f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)); |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScIdx].target.trafficWeight := pl_tcWeight; |
| f_EPTF_ExecCtrl_sendUpdatedCps(vl_scIdx,vl_tcOfScIdx); |
| } |
| |
| group EPTF_ExecCtrl_Regulator { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getRegulatorNameVarName |
| // |
| // Purpose: |
| // Gives back the RegulatorName Variable Name from the idName and the regulatedItemData in hash. |
| // |
| // Parameters: |
| // pl_idName - *in* <EPTF_ExecCtrl_RegulatedItemName> - Regulated Item Name |
| // pl_regulatedItemDataIdInHash - *in* *integer* - regulatedItemData hash id |
| // |
| // Return Value: |
| // *charstring* - Variable name of RegulatorName |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_getRegulatorNameVarName(in EPTF_ExecCtrl_RegulatedItemName pl_idName, |
| in integer pl_regulatedItemDataIdInHash) |
| runs on EPTF_ExecCtrl_CT |
| return charstring{ |
| var EPTF_ExecCtrl_RegulatedItemId vl_regulatedItemData := f_EPTF_ExecCtrl_Regulator_getRegulatedItemDataById(pl_regulatedItemDataIdInHash); |
| // Regulator name |
| if (ischosen(pl_idName.cps_TC)) { |
| // "SC2." & "Traffic.Regulator." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); |
| return "Traffic.Regulator." & |
| pl_idName.cps_TC.eGrpName |
| &"."&int2str(vl_regulatedItemData.cps_TC.scenidx) |
| &"."&int2str(vl_regulatedItemData.cps_TC.tcidx); |
| } |
| if (ischosen(pl_idName.cps_SC)) { |
| // "Traffic.Regulator." & grpName&"."& int2str(sidx); |
| return "Traffic.Regulator." & |
| pl_idName.cps_SC.eGrpName |
| &"."&int2str(vl_regulatedItemData.cps_SC.scenidx); |
| } |
| if (ischosen(pl_idName.cps_TCInPhase)) { |
| // "SC2." & "Traffic.Regulator." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); |
| return "Traffic.Regulator." & |
| pl_idName.cps_TCInPhase.eGrpName |
| &"."&int2str(vl_regulatedItemData.cps_TCInPhase.scenidx) |
| &"."&int2str(vl_regulatedItemData.cps_TCInPhase.tcidx) |
| &".InPhase."&vl_regulatedItemData.cps_TCInPhase.phase; |
| } |
| if (ischosen(pl_idName.cps_SCInPhase)) { |
| // "Traffic.Regulator." & grpName&"."& int2str(sidx); |
| return "Traffic.Regulator." & |
| pl_idName.cps_SCInPhase.eGrpName |
| &"."&int2str(vl_regulatedItemData.cps_SCInPhase.scenidx) |
| &".InPhase."&vl_regulatedItemData.cps_SCInPhase.phase; |
| } |
| return ""; |
| } |
| |
| |
| // initializes the EPTF_ExecCtrl_Regulator, this is the main init function |
| private function f_EPTF_ExecCtrl_Regulator_init(in EPTF_CharstringList pl_regulatorNames, in EPTF_ExecCtrl_RegulatedItems pl_EPTF_ExecCtrl_RegulatedItems) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_Regulator_initRegulators(pl_regulatorNames); |
| f_EPTF_ExecCtrl_Regulator_initRegulateditems(pl_EPTF_ExecCtrl_RegulatedItems); |
| f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_Regulator_scenarioStateChangedCallback)); |
| f_EPTF_ExecCtrl_registerScenarioGroupPhaseChangedCallback(refers(f_EPTF_ExecCtrl_Regulator_scenarioGroupPhaseChangedCallback)); |
| f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_Regulator_trafficCaseStateChangedCallback)); |
| } |
| |
| // initializes v_EPTF_ExecCtrl_Regulators |
| private function f_EPTF_ExecCtrl_Regulator_initRegulators(in EPTF_CharstringList pl_regulatorNames) runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_Regulators := {}; |
| for(var integer i:=0, size := sizeof(pl_regulatorNames); i<size; i:=i+1) { |
| var integer vl_regulatorId := f_EPTF_ExecCtrl_Regulator_addRegulator(pl_regulatorNames[i]); |
| } |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_Regulators: ", v_EPTF_ExecCtrl_Regulators)); |
| } |
| |
| // initializes the regulator database by adding the new regulated items |
| private function f_EPTF_ExecCtrl_Regulator_initRegulateditems(in EPTF_ExecCtrl_RegulatedItems pl_EPTF_ExecCtrl_RegulatedItems) runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_RegulatedItems := {}; |
| v_EPTF_ExecCtrl_RegulatedItemIdsDB := {}; |
| for(var integer i:=0, size := sizeof(pl_EPTF_ExecCtrl_RegulatedItems); i<size; i:=i+1) { |
| if (-1==f_EPTF_ExecCtrl_Regulator_addRegulatedItem( |
| pl_EPTF_ExecCtrl_RegulatedItems[i].idName, |
| pl_EPTF_ExecCtrl_RegulatedItems[i].regulatorName, |
| pl_EPTF_ExecCtrl_RegulatedItems[i].weight, |
| pl_EPTF_ExecCtrl_RegulatedItems[i].enabled |
| )) {/*to remove the warning*/}; |
| } |
| |
| var integer vl_sizeScen := f_EPTF_ExecCtrl_numScenarios(); |
| var integer vl_sizeTCs; |
| |
| for (var integer sidx := 0; sidx < vl_sizeScen; sidx := sidx + 1) |
| { |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(sidx); |
| var charstring grpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring scenName := f_EPTF_ExecCtrl_getScenarioName(sidx); |
| vl_sizeTCs := f_EPTF_ExecCtrl_numTcOfScenario(sidx); |
| for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1) |
| { |
| var charstring tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(sidx,tcidx) |
| var charstring vl_regulatorName := ""; |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName; |
| var integer vl_scGrpidx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(sidx); |
| if (vl_scGrpidx==-1) { |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SC := {grpName,scenName}}; |
| } else { |
| vl_idName := {cps_TC := {grpName,scenName,tcName}}; |
| } |
| } else { |
| // for scenarios in scenario groups: it shows the regulator in the current phase |
| var EPTF_ExecCtrl_PhaseList_Instance phaseList := f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseList(vl_scGrpidx); |
| |
| // create variables for all phases: |
| for(var integer ph:=0; ph<f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListPhasesNum(vl_scGrpidx); ph:=ph+1) { |
| var charstring vl_phaseName := f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListPhaseName(vl_scGrpidx,ph); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SCInPhase := {grpName,scenName, vl_phaseName}}; |
| } else { |
| vl_idName := {cps_TCInPhase := {grpName,scenName,tcName, vl_phaseName}}; |
| } |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if (vl_regulatedItemId==-1) { |
| // add new regulated item: |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_addRegulatedItem(vl_idName,""); |
| } |
| } |
| // put regulator in CURRENT PHASE to the GUI: |
| var charstring vl_phaseName := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGrpidx); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SCInPhase := {grpName,scenName, vl_phaseName}}; |
| } else { |
| vl_idName := {cps_TCInPhase := {grpName,scenName,tcName, vl_phaseName}}; |
| } |
| } |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if (vl_regulatedItemId==-1) { |
| // add new regulated item: |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_addRegulatedItem(vl_idName,""); |
| } |
| } |
| } |
| |
| if(c_EPTF_Common_debugSwitch and f_EPTF_ExecCtrl_debugEnabled()) { |
| f_EPTF_ExecCtrl_debug("Regulator database initialized."); |
| f_EPTF_ExecCtrl_Regulator_logAll(); |
| } |
| } |
| |
| // start/stop relevant regulators if phase of the scenario group changes |
| private function f_EPTF_ExecCtrl_Regulator_scenarioGroupPhaseChangedCallback(in charstring pl_sgName, in integer pl_actualPhaseIdx) runs on EPTF_ExecCtrl_CT { |
| var integer vl_sgIdx := f_EPTF_ExecCtrl_ScenarioGroup_getIdx(pl_sgName); |
| |
| // start/stop regulators for all scenarios and traffic cases in the scenario group: |
| for (var integer i:=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data[vl_sgIdx].scenarios); i<size; i:=i+1) { |
| var integer vl_scIdx := v_ExecCtrl_ScenarioGroupInstanceDB.data[vl_sgIdx].scenarios[i].idx; |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| f_EPTF_ExecCtrl_Regulator_scenarioStateChangedCallback(vl_eGrpName,vl_scenName, ""); |
| // go through all traffic cases |
| for (var integer tcOfSc:=0; tcOfSc<f_EPTF_ExecCtrl_numTcOfScenario(vl_scIdx); tcOfSc:=tcOfSc+1) { |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,tcOfSc); |
| f_EPTF_ExecCtrl_Regulator_trafficCaseStateChangedCallback(vl_eGrpName,vl_scenName,vl_tcName,""); |
| } |
| } |
| } |
| |
| // check if the regulators belonging this scenario should be enabled/disabled and enable/disable them |
| private function f_EPTF_ExecCtrl_Regulator_scenarioStateChangedCallback(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| // find the regulators that regulate items in the current scenario: |
| var EPTF_IntegerList vl_regulatorIdxList := {}; |
| f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario(pl_eGrpName,pl_scName,vl_regulatorIdxList); |
| |
| for(var integer i:=0, size := sizeof(vl_regulatorIdxList); i<size; i:=i+1) { |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_regulatorIdxList[i]); |
| } |
| } |
| |
| // check if the regulators belonging this traffic case should be enabled/disabled and enable/disable them |
| private function f_EPTF_ExecCtrl_Regulator_trafficCaseStateChangedCallback(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_tcName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| // find the regulators that regulate items in the current scenario: |
| var EPTF_IntegerList vl_regulatorIdxList := {}; |
| f_EPTF_ExecCtrl_Regulator_findRegulatorsForTrafficCase(pl_eGrpName,pl_scName,pl_tcName,vl_regulatorIdxList); |
| |
| for(var integer i:=0, size := sizeof(vl_regulatorIdxList); i<size; i:=i+1) { |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_regulatorIdxList[i]); |
| } |
| } |
| |
| // if the status of the regulator changes to connected, check if the regulator should be enabled/disabled and enable/disable it |
| private function f_EPTF_ExecCtrl_Regulator_statusChangePostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var integer vl_regulatorId := pl_argList[0]; |
| |
| var integer vl_regulatorStatusIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(vl_regulatorId); |
| if (vl_regulatorStatusIdx!=-1) { |
| var EPTF_StatusLED vl_regulatorStatus := f_EPTF_Var_getStatusLEDValue(vl_regulatorStatusIdx); |
| if (vl_regulatorStatus == {led_yellow, "Registering..."}) { |
| var integer vl_regulatorCompRefInt := float2int(f_EPTF_Var_getFloatValue(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].currentLoadIdx)+0.1); |
| if (vl_regulatorCompRefInt!=0) { |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(vl_regulatorId); |
| var EPTF_Var_CT vl_regulatorCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(vl_regulatorCompRefInt)); |
| f_EPTF_ExecCtrl_debug(%definitionId&"Regulator """&vl_regulatorName&""" is connected, initializing variables..."); |
| |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx,true); |
| |
| var charstring vl_currentName := "EPTF_LoadRegulator."&c_EPTF_ExecCtrl_Regulator_totalValue&"."&vl_regulatorName; |
| f_EPTF_Var_resubscribeRemote(vl_regulatorCompRef,vl_currentName,realtime,v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx); |
| vl_currentName := "EPTF_LoadRegulator."&c_EPTF_ExecCtrl_Regulator_targetLoad&"."&vl_regulatorName; |
| f_EPTF_Var_resubscribeRemote(vl_regulatorCompRef,vl_currentName,realtime,v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx); |
| vl_currentName := "EPTF_LoadRegulator."&c_EPTF_ExecCtrl_Regulator_currentLoad&"."&vl_regulatorName; |
| f_EPTF_Var_resubscribeRemote(vl_regulatorCompRef,vl_currentName,realtime,v_EPTF_ExecCtrl_Regulators[vl_regulatorId].currentLoadIdx); |
| vl_currentName := "EPTF_LoadRegulator."&c_EPTF_ExecCtrl_Regulator_status&"."&vl_regulatorName; |
| f_EPTF_Var_resubscribeRemote(vl_regulatorCompRef,vl_currentName,realtime,v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx); |
| vl_currentName := "EPTF_LoadRegulator."&c_EPTF_ExecCtrl_Regulator_enable&"."&vl_regulatorName; |
| f_EPTF_Var_resubscribeRemote(vl_regulatorCompRef,vl_currentName,realtime,v_EPTF_ExecCtrl_Regulators[vl_regulatorId].enableIdx); |
| } |
| } |
| else if (vl_regulatorStatus == {led_green, "Connected"}) { |
| f_EPTF_ExecCtrl_debug(%definitionId&"Regulator is connected, checking if it should be started"); |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_regulatorId); |
| |
| } else if (vl_regulatorStatus == {led_red, "Disconnected"}) { |
| f_EPTF_ExecCtrl_debug(%definitionId&"Regulator is disconnected"); |
| |
| f_EPTF_Var_unsubscribe(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx); |
| f_EPTF_Var_unsubscribe(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx); |
| f_EPTF_Var_unsubscribe(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].currentLoadIdx); |
| f_EPTF_Var_unsubscribe(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx); |
| f_EPTF_Var_unsubscribe(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].enableIdx); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx,false); |
| } |
| } |
| } |
| |
| // the the regulated item to v_EPTF_ExecCtrl_RegulatedItemIdsDB for fast access |
| private function f_EPTF_ExecCtrl_Regulator_addToRegulatedItemIdsDB(in integer pl_regulatedItemId) runs on EPTF_ExecCtrl_CT { |
| // determinde egrpidx,scenidx,tcidx: |
| // currently egrpIdx is not used!!! |
| v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemId] := f_EPTF_ExecCtrl_Regulator_itemName2ItemId(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemId].idName); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_addRegulator |
| // |
| // Purpose: |
| // creates a regulator and returns the id of the regulator, |
| // if the regulator exists already, it returns its idx |
| // |
| // Parameters: |
| // pl_regulatorName - *in charstring* - the name of the regulator |
| // |
| // Return Value: |
| // integer - id of the regulator |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_addRegulator(in charstring pl_regulatorName) runs on EPTF_ExecCtrl_CT return integer { |
| if (pl_regulatorName == "") { |
| return -1; // empty name is not allowed |
| } |
| var integer vl_regulatorId := f_EPTF_ExecCtrl_Regulator_getRegulatorId(pl_regulatorName); |
| if (vl_regulatorId != -1) { |
| return vl_regulatorId; // regulator already registered |
| } |
| // add to regulator database: |
| vl_regulatorId := sizeof(v_EPTF_ExecCtrl_Regulators); |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId] := {pl_regulatorName, {}, 0,0,0,0,0}; |
| |
| // create an EPTF Variable that holds the targetValue: |
| var charstring vl_currentName := "EPTF_ExecCtrl."&c_EPTF_ExecCtrl_Regulator_totalValue&"."&pl_regulatorName; |
| f_EPTF_Var_newFloat( |
| vl_currentName, |
| 0.0, |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx |
| ); |
| f_EPTF_Var_addPostProcFn( |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].totalValueIdx, { refers(f_EPTF_ExecCtrl_Regulator_updateTotalValue), {vl_regulatorId}} |
| ); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set totalValue for regulator ",pl_regulatorName, " : ",vl_currentName)); |
| |
| // create an EPTF Variable that holds the targetLoad: |
| vl_currentName := "EPTF_ExecCtrl."&c_EPTF_ExecCtrl_Regulator_targetLoad&"."&pl_regulatorName; |
| f_EPTF_Var_newFloat( |
| vl_currentName, |
| 0.0, |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].targetLoadIdx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set targetLoad for regulator ",pl_regulatorName, " : ",vl_currentName)); |
| |
| // create an EPTF Variable that holds the currentLoad: |
| vl_currentName := "EPTF_ExecCtrl."&c_EPTF_ExecCtrl_Regulator_currentLoad&"."&pl_regulatorName; |
| f_EPTF_Var_newFloat( |
| vl_currentName, |
| 0.0, |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].currentLoadIdx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].currentLoadIdx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set currentLoad for regulator ",pl_regulatorName, " : ",vl_currentName)); |
| |
| // create an EPTF Variable that holds the status: |
| vl_currentName := "EPTF_ExecCtrl."&c_EPTF_ExecCtrl_Regulator_status&"."&pl_regulatorName; |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| {led_red, "Disconnected"}, |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx,false); |
| f_EPTF_Var_addPostProcFn( |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx, { refers(f_EPTF_ExecCtrl_Regulator_statusChangePostProc), {vl_regulatorId}} |
| ); |
| // FIXME: refactor needed to be able to disable var here |
| //f_EPTF_Var_setSubsCanAdjust(v_EPTF_ExecCtrl_Regulators[vl_regulatorId].statusIdx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set status for regulator ",pl_regulatorName, " : ",vl_currentName)); |
| |
| // create an EPTF Variable that holds the enable: |
| vl_currentName := "EPTF_ExecCtrl."&c_EPTF_ExecCtrl_Regulator_enable&"."&pl_regulatorName; |
| f_EPTF_Var_newBool( |
| vl_currentName, |
| false, |
| v_EPTF_ExecCtrl_Regulators[vl_regulatorId].enableIdx |
| ); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set the enable flag for regulator ",pl_regulatorName, " : ",vl_currentName)); |
| |
| return vl_regulatorId; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_getRegulatorId |
| // |
| // Purpose: |
| // returns the id of the regulator in v_EPTF_ExecCtrl_Regulators (same as in v_EPTF_ExecCtrl_RegulatorNames) |
| // |
| // Parameters: |
| // pl_regulatorName - *in charstring* - the name of the regulator |
| // |
| // Return Value: |
| // integer - id of the regulator |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_getRegulatorId(in charstring pl_regulatorName) runs on EPTF_ExecCtrl_CT return integer { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators); i<size; i:=i+1) { |
| if (v_EPTF_ExecCtrl_Regulators[i].name == pl_regulatorName) { |
| return i; |
| } |
| } |
| return -1; // not found |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_regulatorName |
| // |
| // Purpose: |
| // returns the name of the regulator from the index in v_EPTF_ExecCtrl_Regulators (same as in v_EPTF_ExecCtrl_RegulatorNames) |
| // |
| // Parameters: |
| // pl_regulatorId - *in integer* - the id of the regulator |
| // |
| // Return Value: |
| // charstring - name of the regulator ("" if not available) |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_Regulator_regulatorName(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return charstring { |
| var charstring vl_regulatorName := ""; |
| if (0<=pl_regulatorId and pl_regulatorId<sizeof(v_EPTF_ExecCtrl_RegulatorNames)) { |
| vl_regulatorName := v_EPTF_ExecCtrl_RegulatorNames[pl_regulatorId]; |
| } |
| return vl_regulatorName; |
| } |
| |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getNofRegulators() runs on EPTF_ExecCtrl_CT return integer { |
| return sizeof(v_EPTF_ExecCtrl_Regulators); |
| } |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return charstring { |
| return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].name; |
| } |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatorTotalValueIdxByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return integer { |
| return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].totalValueIdx; |
| } |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatorTargetLoadIdxByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return integer { |
| return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].targetLoadIdx; |
| } |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatorCurrentLoadIdxByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return integer { |
| return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].currentLoadIdx; |
| } |
| |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(in integer pl_regulatorId) runs on EPTF_ExecCtrl_CT return integer { |
| return v_EPTF_ExecCtrl_Regulators[pl_regulatorId].statusIdx; |
| } |
| |
| // add a regulated item into the database, |
| // creates the regulator data if needed and registers the regulated item into the regulator, |
| // updates v_EPTF_ExecCtrl_RegulatedItemIdsDB also |
| friend function f_EPTF_ExecCtrl_Regulator_addRegulatedItem( |
| in EPTF_ExecCtrl_RegulatedItemName pl_idName, |
| in charstring pl_regulatorName, // name in EPTF_ExecCtrl_Regulators: this regulator regulates this item |
| in float pl_weight := 1.0, // used to determine part of the total value |
| in boolean pl_enabled := true // regulation enabled |
| ) runs on EPTF_ExecCtrl_CT |
| return integer |
| { |
| // if (pl_idName == "") { |
| // return -1; // empty name is not allowed |
| // } |
| // check if the regulated item exists: |
| var boolean vl_regulatedItemIsWeighted := false; |
| var charstring vl_errorMsg := "Cannot regulate the CPS of the traffic case in a weighted scenario."; |
| var charstring vl_eGrpName, vl_scName, vl_tcName; |
| var boolean vl_inPhase := false; // all phases |
| var charstring vl_phase; // unbound for all phases! |
| if (ischosen(pl_idName.cps_TC)) { |
| vl_eGrpName := pl_idName.cps_TC.eGrpName; |
| vl_scName := pl_idName.cps_TC.scName; |
| vl_tcName := pl_idName.cps_TC.tcName; |
| } else if (ischosen(pl_idName.cps_SC)) { |
| vl_regulatedItemIsWeighted := true; |
| vl_errorMsg := "Cannot regulate the CPS of a non-weighted scenario."; |
| vl_eGrpName := pl_idName.cps_SC.eGrpName; |
| vl_scName := pl_idName.cps_SC.scName; |
| } else if (ischosen(pl_idName.cps_TCInPhase)) { |
| vl_eGrpName := pl_idName.cps_TCInPhase.eGrpName; |
| vl_scName := pl_idName.cps_TCInPhase.scName; |
| vl_tcName := pl_idName.cps_TCInPhase.tcName; |
| vl_phase := pl_idName.cps_TCInPhase.phase; |
| vl_inPhase := true; |
| if (vl_phase=="") { |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data: Regulated item "&log2str(pl_idName)&" has no phase."); |
| } |
| } else if (ischosen(pl_idName.cps_SCInPhase)) { |
| vl_regulatedItemIsWeighted := true; |
| vl_errorMsg := "Cannot regulate the CPS of a non-weighted scenario."; |
| vl_eGrpName := pl_idName.cps_SCInPhase.eGrpName; |
| vl_scName := pl_idName.cps_SCInPhase.scName; |
| vl_phase := pl_idName.cps_SCInPhase.phase; |
| vl_inPhase := true; |
| if (vl_phase=="") { |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data: Regulated item "&log2str(pl_idName)&" has no phases."); |
| } |
| } |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForScOfEGrp(vl_eGrpName,vl_scName); |
| if (vl_scIdx==-1) { |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data: Regulated item "&log2str(pl_idName)&" is not found in database." |
| &" Check the entity group- and scenario names."); |
| } |
| if (f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)!=vl_regulatedItemIsWeighted) { |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data for the regulated item "&log2str(pl_idName)&": "&vl_errorMsg); |
| } |
| // The scenario groups are initialized by f_EPTF_ExecCtrl_Phase_createScenarioGroups, |
| // check if the phase regulation is consistent with scenario groups: |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(vl_scIdx) == vl_inPhase) { |
| vl_errorMsg := "Phase setting is not consistent with scenario: The scenario is not in a scenario group but phase is specified or vice versa." |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data for the regulated item "&log2str(pl_idName)&": "&vl_errorMsg); |
| } |
| if (not vl_regulatedItemIsWeighted) { |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(vl_eGrpName,vl_scName,vl_tcName); |
| if ( vl_tcIdx==-1) { |
| f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data: Regulated item "&log2str(pl_idName)&" is not found in database." |
| &" Check the traffic case name."); |
| } |
| } |
| |
| |
| // check if it is already there: |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(pl_idName); |
| if (vl_regulatedItemId == -1) { |
| // if not found: append to regulatedItems database: |
| vl_regulatedItemId := sizeof(v_EPTF_ExecCtrl_RegulatedItems); |
| // set the values: |
| v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemId] := {pl_idName,pl_weight,pl_enabled,pl_regulatorName}; |
| } else { |
| f_EPTF_ExecCtrl_warning(%definitionId&": Cannot add regulated item to database: regulated item is already added: "&log2str(pl_idName)); |
| // regulated item is already in the database |
| // do not overwrite the existing values |
| } |
| |
| // also: add to the v_EPTF_ExecCtrl_RegulatedItemIdsDB: |
| f_EPTF_ExecCtrl_Regulator_addToRegulatedItemIdsDB(vl_regulatedItemId); |
| |
| // also: add the regulator: |
| var integer vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_addRegulator(pl_regulatorName); |
| |
| // register the regulated item into the regulator: |
| // if regulated, add to regulator data: |
| f_EPTF_ExecCtrl_Regulator_registerItem(vl_regulatorIdx,vl_regulatedItemId); |
| |
| return vl_regulatedItemId; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_getRegulatedItemId |
| // |
| // Purpose: |
| // returns the id of the regulatedItem |
| // |
| // Parameters: |
| // pl_idName - *in* <EPTF_ExecCtrl_RegulatedItemName> - the name of the regulated item |
| // |
| // Return Value: |
| // integer - the id of the regulated item |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(in EPTF_ExecCtrl_RegulatedItemName pl_idName) runs on EPTF_ExecCtrl_CT return integer { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_RegulatedItems); i<size; i:=i+1) { |
| if (v_EPTF_ExecCtrl_RegulatedItems[i].idName == pl_idName) { |
| return i; |
| } |
| } |
| return -1; // not found |
| } |
| |
| // returns the id of the regulatedItem |
| private function f_EPTF_ExecCtrl_Regulator_getRegulatedItemIdById(in EPTF_ExecCtrl_RegulatedItemId pl_id) runs on EPTF_ExecCtrl_CT return integer { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_RegulatedItemIdsDB); i<size; i:=i+1) { |
| if (v_EPTF_ExecCtrl_RegulatedItemIdsDB[i] == pl_id) { |
| return i; |
| } |
| } |
| return -1; // not found |
| } |
| |
| // returns the id of the regulatedItem |
| friend function f_EPTF_ExecCtrl_Regulator_getRegulatedItemDataById(in integer pl_id) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrl_RegulatedItemId { |
| return v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_id]; |
| } |
| |
| // append regulated item idx to regulatedItems of regulator pl_regulatorIdx |
| // checks also if the regulated item is regulated by some regulator |
| private function f_EPTF_ExecCtrl_Regulator_registerItem(in integer pl_regulatorIdx, in integer pl_itemIdx) runs on EPTF_ExecCtrl_CT { |
| if (pl_regulatorIdx==-1) { |
| return; // no regulator given |
| } |
| |
| // check if it is already in a regulator or not: |
| if ( v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].regulatorName != "" |
| and v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].regulatorName != v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].name) |
| { |
| f_EPTF_ExecCtrl_error(%definitionId&": Cannot set regulator name "&v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].name& |
| " to the item "&log2str(v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].idName)& |
| ": it is already regulated by " & v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].regulatorName); |
| } |
| |
| // register it into regulated items: |
| v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].regulatorName := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].name; |
| |
| // register it into the regulator: |
| f_EPTF_ExecCtrl_Regulator_addItem(pl_regulatorIdx,pl_itemIdx); |
| } |
| |
| // remove regulated item idx from regulatedItems of regulator pl_regulatorIdx |
| // removes also the regulated item from the regulator |
| private function f_EPTF_ExecCtrl_Regulator_deregisterItem(in integer pl_regulatorIdx, in integer pl_itemIdx) runs on EPTF_ExecCtrl_CT { |
| // check if it is already in a regulator or not: |
| |
| // deregister it from the regulated items: |
| v_EPTF_ExecCtrl_RegulatedItems[pl_itemIdx].regulatorName := ""; |
| |
| // deregister it from the regulator: |
| f_EPTF_ExecCtrl_Regulator_removeItem(pl_regulatorIdx,pl_itemIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_setTotalCps |
| // |
| // Purpose: |
| // sets the total CPS into the regulated items for this regulator. The total CPS is distributed according to the weights, only the enabled items are processed |
| // |
| // Parameters: |
| // pl_regulatorIdx - *in integer* - the id of the regulator |
| // pl_totalCps - *in float* - the total CPS to set |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_setTotalCps(in integer pl_regulatorIdx, in float pl_totalCps) runs on EPTF_ExecCtrl_CT { |
| if (pl_regulatorIdx == -1) { |
| return; // no regulator |
| } |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| |
| var float vl_sumWeight := 0.0; |
| |
| // sum the CPS-es: |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| |
| // check if the regulator regulates in the current phase: |
| if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| continue; |
| } |
| |
| // grpidx is not used currently! |
| //var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.grpidx; |
| if (v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].enabled and f_EPTF_ExecCtrl_Regulator_itemIsRunning(vl_regulatedItemIdx)) { |
| vl_sumWeight := vl_sumWeight + v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].weight; |
| } |
| } |
| |
| // set the CPS-es: |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| |
| // check if the regulator regulates in the current phase: |
| if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| continue; |
| } |
| |
| if (not v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].enabled |
| or not f_EPTF_ExecCtrl_Regulator_itemIsRunning(vl_regulatedItemIdx)) { |
| continue; |
| } |
| if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.scenidx; |
| var integer tcidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.tcidx; |
| // grpidx is not used currently! |
| var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.grpidx; |
| v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach := pl_totalCps * v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].weight/vl_sumWeight; |
| f_EPTF_ExecCtrl_setCps_TC(scenidx,tcidx, v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach); |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC.scenidx; |
| // grpidx is not used currently! |
| var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC.grpidx; |
| v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach := pl_totalCps * v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].weight/vl_sumWeight; |
| f_EPTF_ExecCtrl_setCps_SC(scenidx,v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach); |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase.scenidx; |
| var integer tcidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase.tcidx; |
| // grpidx is not used currently! |
| var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase.grpidx; |
| v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach := pl_totalCps * v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].weight/vl_sumWeight; |
| f_EPTF_ExecCtrl_setCps_TC(scenidx,tcidx, v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach); |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SCInPhase)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SCInPhase.scenidx; |
| // grpidx is not used currently! |
| var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SCInPhase.grpidx; |
| v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach := pl_totalCps * v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].weight/vl_sumWeight; |
| f_EPTF_ExecCtrl_setCps_SC(scenidx,v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach); |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_currentPhaseIsRegulated(in integer pl_regulatedItemIdx) runs on EPTF_ExecCtrl_CT return boolean { |
| if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_TC)) { |
| return true;// this item is regulated in all phases |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_SC)) { |
| return true;// this item is regulated in all phases |
| } |
| var integer sidx; |
| var charstring vl_phase; |
| if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_TCInPhase)) { |
| sidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_TCInPhase.scenidx; |
| vl_phase := v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_TCInPhase.phase; |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_SCInPhase)) { |
| sidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_SCInPhase.scenidx; |
| vl_phase := v_EPTF_ExecCtrl_RegulatedItemIdsDB[pl_regulatedItemIdx].cps_SCInPhase.phase; |
| } |
| |
| // check if current phase is the same as the regulated item's phase |
| var integer vl_scGrpidx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(sidx); |
| if (vl_scGrpidx==-1) { |
| //f_EPTF_ExecCtrl_error(%definitionId&": Invalid configuration data for the regulated item "&log2str(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx])&": " |
| // &"Phase setting is not consistent with scenario: The scenario is not in a scenario group but phase is specified or vice versa."); |
| return false; // this is not reached |
| } |
| |
| var integer vl_currentPhaseIdx := v_ExecCtrl_ScenarioGroupInstanceDB.data[vl_scGrpidx].groupPhaseList.actualPhaseIndex; |
| var charstring vl_currentPhaseName := v_ExecCtrl_ScenarioGroupInstanceDB.data[vl_scGrpidx].groupPhaseList.phases[vl_currentPhaseIdx].name; |
| if (vl_phase == vl_currentPhaseName) { |
| return true; |
| } |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkTrafficCaseStatus |
| // |
| // Purpose: |
| // Check if the execution state of a specified traffic case is consistent |
| // in all LGens |
| // |
| // Parameters: |
| // - pl_idName - *in* <EPTF_ExecCtrl_TCName> - the regulated item ID |
| // - pl_status - *in template charstring* - the desired state |
| // |
| // Return Value: |
| // *boolean* - true, if the execution state of a scenario matches the specifid state |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_checkTrafficCaseStatus(in EPTF_ExecCtrl_TCName pl_idName, in template charstring pl_status) runs on EPTF_ExecCtrl_CT return boolean |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| var charstring vl_currentName := "ExecCtrl.trafficCaseStatus."&pl_idName.eGrpName&"."&pl_idName.scName&"."&pl_idName.tcName; |
| var integer vl_idx := f_EPTF_Var_getId(vl_currentName); |
| if (vl_idx == -1) { |
| return false; |
| } |
| var EPTF_StatusLED vl_statusLED := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| var charstring vl_status := vl_statusLED.text; |
| if (not match(vl_status, pl_status)) { |
| return false; |
| } |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| return true; |
| } |
| |
| private function f_EPTF_ExecCtrl_Regulator_itemIsRunning(in integer pl_regulatedItemIdx) runs on EPTF_ExecCtrl_CT return boolean { |
| var charstring vl_varName; |
| |
| if (ischosen(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TC)) { |
| return f_EPTF_ExecCtrl_checkTrafficCaseStatus( |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TC, |
| c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning] |
| ); |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_SC)) { |
| return f_EPTF_ExecCtrl_checkScenarioStatus( |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_SC, |
| c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning] |
| ); |
| }else if (ischosen(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TCInPhase)) { |
| return f_EPTF_ExecCtrl_checkTrafficCaseStatus( |
| { |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TCInPhase.eGrpName, |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TCInPhase.scName, |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_TCInPhase.tcName |
| }, |
| c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning] |
| ); |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_SCInPhase)) { |
| return f_EPTF_ExecCtrl_checkScenarioStatus( |
| {v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_SCInPhase.eGrpName,v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName.cps_SCInPhase.scName}, |
| c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning] |
| ); |
| } |
| return false;// never reached |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_getTotalCps |
| // |
| // Purpose: |
| // returns the total CPS of the regulated items belonging to the given regulator, only the enabled items are processed |
| // |
| // Parameters: |
| // pl_regulatorIdx - *in integer* - the id of the regulator |
| // |
| // Return Value: |
| // float - the total CPS |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_getTotalCps(in integer pl_regulatorIdx) runs on EPTF_ExecCtrl_CT return float { |
| if (pl_regulatorIdx == -1) { |
| return 0.0; // no regulator |
| } |
| |
| var float vl_sumCps := 0.0; |
| |
| // sum the CPS-es: |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| // check if the regulator regulates in the current phase: |
| if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| continue; |
| } |
| if (v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].enabled |
| and f_EPTF_ExecCtrl_Regulator_itemIsRunning(vl_regulatedItemIdx) |
| ) { |
| if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.scenidx; |
| var integer tcidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.tcidx; |
| // grpidx is not used currently! |
| //var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.grpidx; |
| vl_sumCps := vl_sumCps + v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach; |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC.scenidx; |
| // grpidx is not used currently! |
| //var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC.grpidx; |
| vl_sumCps := vl_sumCps + v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach; |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase.scenidx; |
| var integer tcidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TCInPhase.tcidx; |
| // grpidx is not used currently! |
| //var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_TC.grpidx; |
| vl_sumCps := vl_sumCps + v_ExecCtrl_scenarios[scenidx].scData.tcList[tcidx].target.cpsToReach; |
| } else if (ischosen(v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SCInPhase)) { |
| var integer scenidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SCInPhase.scenidx; |
| // grpidx is not used currently! |
| //var integer grpidx := v_EPTF_ExecCtrl_RegulatedItemIdsDB[vl_regulatedItemIdx].cps_SC.grpidx; |
| vl_sumCps := vl_sumCps + v_ExecCtrl_scenarios[scenidx].scData.weightedScData.cpsToReach; |
| } |
| } |
| } |
| |
| return vl_sumCps; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_getRegulatorName |
| // |
| // Purpose: |
| // returns the name of the regulator for the given regulated item: |
| // |
| // Parameters: |
| // pl_regulatedItemIdx - *in integer* - the id of the regulated item |
| // |
| // Return Value: |
| // charstring - the name of the regulator the item is regulated by |
| // Empty string ("") is returned if no regulator found for this item |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_getRegulatorName(in integer pl_regulatedItemIdx) runs on EPTF_ExecCtrl_CT return charstring { |
| if (pl_regulatedItemIdx == -1) { |
| return ""; |
| } |
| if (sizeof(v_EPTF_ExecCtrl_RegulatedItems)<=pl_regulatedItemIdx) { |
| return ""; |
| } |
| return v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].regulatorName; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_setRegulatorName |
| // |
| // Purpose: |
| // sets the name of the regulator for the given regulated item: |
| // |
| // Parameters: |
| // pl_regulatedItemIdx - *in integer* - the id of the regulated item |
| // pl_regulatorName - *in charstring* - the name of the regulator |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_setRegulatorName(in integer pl_regulatedItemIdx, in charstring pl_regulatorName) runs on EPTF_ExecCtrl_CT { |
| if (pl_regulatedItemIdx == -1) { |
| return; |
| } |
| |
| var charstring vl_prevRegulatorName := v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].regulatorName; |
| var integer vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_addRegulator(vl_prevRegulatorName); |
| var integer vl_prevRegulatorIdx := vl_regulatorIdx; |
| f_EPTF_ExecCtrl_Regulator_deregisterItem(vl_regulatorIdx,pl_regulatedItemIdx); |
| |
| v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].regulatorName := pl_regulatorName; |
| |
| // also: add the regulator: |
| vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_addRegulator(pl_regulatorName); |
| |
| // register the regulated item into the regulator: |
| // if regulated, add to regulator data: |
| f_EPTF_ExecCtrl_Regulator_registerItem(vl_regulatorIdx,pl_regulatedItemIdx); |
| |
| if (vl_prevRegulatorIdx != -1) { |
| // try to stop the old regulator: |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_prevRegulatorIdx); |
| } |
| if (vl_regulatorIdx!=-1) { |
| // start the new regulator if needed: |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_regulatorIdx); |
| } |
| } |
| |
| // private: |
| |
| // append regulated item idx to regulatedItems of regulator pl_regulatorIdx |
| private function f_EPTF_ExecCtrl_Regulator_addItem(in integer pl_regulatorIdx, in integer pl_itemIdx) runs on EPTF_ExecCtrl_CT { |
| if (pl_regulatorIdx==-1) { |
| return; // no regulator given |
| } |
| // check if it is already there: |
| for (var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| if (v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i] == pl_itemIdx) { |
| return; // already there |
| } |
| } |
| |
| // register it into the regulator: |
| var integer vl_currentSize := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); |
| v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[vl_currentSize] := pl_itemIdx; |
| |
| // update the totalValue: |
| f_EPTF_Var_adjustContent(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].totalValueIdx,{floatVal := f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_regulatorIdx)}); |
| } |
| |
| // remove regulated item idx from the regulatedItems of regulator pl_regulatorIdx |
| private function f_EPTF_ExecCtrl_Regulator_removeItem(in integer pl_regulatorIdx, in integer pl_itemIdx) runs on EPTF_ExecCtrl_CT { |
| if (pl_regulatorIdx==-1) { |
| return; // no regulator given |
| } |
| var EPTF_IntegerList vl_regulatedItemIds_old := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds; |
| var integer vl_currentSize := 0; |
| v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds := {}; |
| |
| for (var integer i:=0, size := sizeof(vl_regulatedItemIds_old); i<size; i:=i+1) { |
| if (vl_regulatedItemIds_old[i] != pl_itemIdx) { |
| v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[vl_currentSize] := vl_regulatedItemIds_old[i]; |
| vl_currentSize := vl_currentSize + 1; |
| } |
| } |
| // update the totalValue: |
| f_EPTF_Var_adjustContent(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].totalValueIdx,{floatVal := f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_regulatorIdx)}); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemWeight |
| // |
| // Purpose: |
| // creates a referenced EPTF Var from the weight of the regulated item |
| // |
| // Parameters: |
| // pl_varName - *in charstring* - name of the EPTF Var to create |
| // pl_regulatedItemIdx - *in integer* - the id of the regulated item in v_EPTF_ExecCtrl_RegulatedItems |
| // pl_idx - *out integer* - index of the created variable |
| // |
| // Return Value: |
| // |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemWeight( |
| in charstring pl_varName, |
| in integer pl_regulatedItemIdx, |
| out integer pl_idx |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Var_newFloatRef( |
| pl_varName, v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].weight, pl_idx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemEnabled |
| // |
| // Purpose: |
| // creates a referenced EPTF Var from the weight of the regulated item |
| // |
| // Parameters: |
| // pl_varName - *in charstring* - name of the EPTF Var to create |
| // pl_regulatedItemIdx - *in integer* - the id of the regulated item in v_EPTF_ExecCtrl_RegulatedItems |
| // pl_idx - *out integer* - index of the created variable |
| // |
| // Return Value: |
| // |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemEnabled( |
| in charstring pl_varName, |
| in integer pl_regulatedItemIdx, |
| out integer pl_idx |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Var_newBoolRef( |
| pl_varName, v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].enabled, pl_idx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_nofRegulatedItems |
| // |
| // Purpose: |
| // Returns the number of regulated items |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // integer - number of regulated items |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_Regulator_nofRegulatedItems() runs on EPTF_ExecCtrl_CT return integer { |
| return sizeof(v_EPTF_ExecCtrl_RegulatedItems); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_itemId2ItemName |
| // |
| // Purpose: |
| // Converts the regulated item idx in v_EPTF_ExecCtrl_RegulatedItems to <EPTF_ExecCtrl_RegulatedItemName> |
| // |
| // Parameters: |
| // pl_regulatedItemIdx - *in integer* - the id of the regulated item in v_EPTF_ExecCtrl_RegulatedItems |
| // |
| // Return Value: |
| // EPTF_ExecCtrl_RegulatedItemName - the idName of the regulated item |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_Regulator_itemId2ItemName(in integer pl_regulatedItemIdx) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrl_RegulatedItemName { |
| return v_EPTF_ExecCtrl_RegulatedItems[pl_regulatedItemIdx].idName; |
| } |
| |
| private function f_EPTF_ExecCtrl_Regulator_itemName2ItemId(in EPTF_ExecCtrl_RegulatedItemName pl_idName) runs on EPTF_ExecCtrl_CT return EPTF_ExecCtrl_RegulatedItemId { |
| var EPTF_ExecCtrl_RegulatedItemId vl_itemId; |
| |
| var integer scenidx := c_ExecCtrl_invalidIdx; |
| if (ischosen(pl_idName.cps_TC)) { |
| // search in ScenDescr2 (descr1 is not supported!!) |
| scenidx := f_EPTF_ExecCtrl_getScenarioIdxForScOfEGrp(pl_idName.cps_TC.eGrpName, pl_idName.cps_TC.scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario type "&pl_idName.cps_TC.scName&" for entity group "&pl_idName.cps_TC.eGrpName&" in database.", scenidx!=-1); |
| |
| vl_itemId.cps_TC.scenidx := scenidx; |
| |
| for (var integer tcidx:=0, size := sizeof(v_ExecCtrl_scenarios[scenidx].scData.tcList);tcidx<size;tcidx:=tcidx+1) |
| { |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[scenidx].scData,tcidx) |
| if (vl_tcName == pl_idName.cps_TC.tcName) { |
| vl_itemId.cps_TC.tcidx := tcidx; |
| break; |
| } |
| } |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getEntityGroupIdx(pl_idName.cps_TC.eGrpName); |
| vl_itemId.cps_TC.grpidx := vl_eGrpIdx; // currently not used |
| |
| } else if (ischosen(pl_idName.cps_SC)) { |
| // search in WeightedScenarios |
| scenidx := f_EPTF_ExecCtrl_getScenarioIdxForScOfEGrp(pl_idName.cps_SC.eGrpName, pl_idName.cps_SC.scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario type "&pl_idName.cps_SC.scName&" for entity group "&pl_idName.cps_SC.eGrpName&" in database.", scenidx!=-1); |
| vl_itemId.cps_SC.scenidx := scenidx; |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getEntityGroupIdx(pl_idName.cps_SC.eGrpName); |
| vl_itemId.cps_SC.grpidx := vl_eGrpIdx; // currently not used |
| } else if (ischosen(pl_idName.cps_TCInPhase)) { |
| scenidx := f_EPTF_ExecCtrl_getScenarioIdxForScOfEGrp(pl_idName.cps_TCInPhase.eGrpName, pl_idName.cps_TCInPhase.scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario type "&pl_idName.cps_TCInPhase.scName&" for entity group "&pl_idName.cps_TCInPhase.eGrpName&" in database.", scenidx!=-1); |
| |
| vl_itemId.cps_TCInPhase.scenidx := scenidx; |
| |
| for (var integer tcidx:=0, size := sizeof(v_ExecCtrl_scenarios[scenidx].scData.tcList);tcidx<size;tcidx:=tcidx+1) |
| { |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[scenidx].scData,tcidx) |
| if (vl_tcName == pl_idName.cps_TCInPhase.tcName) { |
| vl_itemId.cps_TCInPhase.tcidx := tcidx; |
| break; |
| } |
| } |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getEntityGroupIdx(pl_idName.cps_TCInPhase.eGrpName); |
| vl_itemId.cps_TCInPhase.grpidx := vl_eGrpIdx; // currently not used |
| vl_itemId.cps_TCInPhase.phase := pl_idName.cps_TCInPhase.phase; |
| } else if (ischosen(pl_idName.cps_SCInPhase)) { |
| // search in WeightedScenarios |
| scenidx := f_EPTF_ExecCtrl_getScenarioIdxForScOfEGrp(pl_idName.cps_SCInPhase.eGrpName, pl_idName.cps_SCInPhase.scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario type "&pl_idName.cps_SCInPhase.scName&" for entity group "&pl_idName.cps_SCInPhase.eGrpName&" in database.", scenidx!=-1); |
| vl_itemId.cps_SCInPhase.scenidx := scenidx; |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getEntityGroupIdx(pl_idName.cps_SCInPhase.eGrpName); |
| vl_itemId.cps_SCInPhase.grpidx := vl_eGrpIdx; // currently not used |
| vl_itemId.cps_SCInPhase.phase := pl_idName.cps_SCInPhase.phase; |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": pl_idName ",pl_idName, " converted to vl_itemId: ", vl_itemId)); |
| |
| return vl_itemId |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_logAll |
| // |
| // Purpose: |
| // log the regulator database for debug purposes |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_logAll() runs on EPTF_ExecCtrl_CT { |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug("-----------Regulator database---------"); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_RegulatorNames: ",v_EPTF_ExecCtrl_RegulatorNames)); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_RegulatedItems: ",v_EPTF_ExecCtrl_RegulatedItems)); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_RegulatedItemIdsDB: ",v_EPTF_ExecCtrl_RegulatedItemIdsDB)); |
| f_EPTF_ExecCtrl_debug(log2str("v_EPTF_ExecCtrl_Regulators: ",v_EPTF_ExecCtrl_Regulators)); |
| f_EPTF_ExecCtrl_debug("---------Regulator database END--------"); |
| } |
| } |
| |
| // postproc fn to update targetValue for an regulator (pl_args[0]: regulatorId) |
| private function f_EPTF_ExecCtrl_Regulator_updateTotalValue( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var integer vl_regulatorIdx := pl_argList[0]; |
| |
| // check if regulator is running: |
| var EPTF_StatusLED v_regulatorStatus := f_EPTF_Var_getStatusLEDValue(v_EPTF_ExecCtrl_Regulators[vl_regulatorIdx].statusIdx); |
| f_EPTF_ExecCtrl_debug(%definitionId&": Status of regulator "& v_EPTF_ExecCtrl_Regulators[vl_regulatorIdx].name&": "& log2str(v_regulatorStatus)); |
| if (v_regulatorStatus.text == "Auto-off" or v_regulatorStatus.text == "Disabled") { |
| f_EPTF_ExecCtrl_debug(%definitionId&": TotalCps is not set for regulator "&v_EPTF_ExecCtrl_Regulators[vl_regulatorIdx].name&": Regulator is Disabled, or Auto-off"); |
| return; // do not update target value if regulator is in "auto-off" or disabled state |
| } |
| f_EPTF_ExecCtrl_Regulator_setTotalCps(vl_regulatorIdx, f_EPTF_Var_getFloatValue(pl_idx)); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario |
| // |
| // Purpose: |
| // find the regulators that regulate items in the current scenario |
| // |
| // Parameters: |
| // pl_eGrpName - *in charstring* - entity group name |
| // pl_scenName - *in charstring* - scenario name |
| // pl_regulatorIdxList - *out* <EPTF_IntegerList> - the regulator indexes that regulate items in the given scenario |
| // |
| // Return Value: |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_Regulator_findRegulatorsForScenario(in charstring pl_eGrpName,in charstring pl_scenName,out EPTF_IntegerList pl_regulatorIdxList) runs on EPTF_ExecCtrl_CT { |
| pl_regulatorIdxList := {}; |
| // go through all regulators and check if they regulate an item for this scenario |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators); i<size; i:=i+1) { |
| if (f_EPTF_ExecCtrl_Regulator_isRegulatesScenario(i,pl_eGrpName,pl_scenName)) { |
| pl_regulatorIdxList[sizeof(pl_regulatorIdxList)] := i; |
| } |
| } |
| } |
| |
| // check if the given regulator regulates an item for the given scenario |
| private function f_EPTF_ExecCtrl_Regulator_isRegulatesScenario(in integer pl_regulatorIdx,in charstring pl_eGrpName,in charstring pl_scenName) runs on EPTF_ExecCtrl_CT return boolean { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].idName; |
| // // check if the regulator regulates in the current phase: |
| // if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| // continue; |
| // } |
| var charstring vl_eGrpName := ""; |
| var charstring vl_scenName := ""; |
| if (ischosen(vl_idName.cps_SC)) { |
| vl_eGrpName := vl_idName.cps_SC.eGrpName; |
| vl_scenName := vl_idName.cps_SC.scName; |
| } else if (ischosen(vl_idName.cps_SCInPhase)) { |
| vl_eGrpName := vl_idName.cps_SCInPhase.eGrpName; |
| vl_scenName := vl_idName.cps_SCInPhase.scName; |
| } |
| if (vl_eGrpName == pl_eGrpName and vl_scenName == pl_scenName) { |
| return true; // regulated item found for the given scenario |
| } |
| } |
| return false; |
| } |
| |
| // find the regulators that regulate items in the current scenario |
| private function f_EPTF_ExecCtrl_Regulator_findRegulatorsForTrafficCase(in charstring pl_eGrpName,in charstring pl_scenName,in charstring pl_tcName,out EPTF_IntegerList vl_regulatorIdxList) runs on EPTF_ExecCtrl_CT { |
| vl_regulatorIdxList := {}; |
| // go through all regulators and check if they regulate an item for this scenario |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators); i<size; i:=i+1) { |
| if (f_EPTF_ExecCtrl_Regulator_isRegulatesTrafficCase(i,pl_eGrpName,pl_scenName,pl_tcName)) { |
| vl_regulatorIdxList[sizeof(vl_regulatorIdxList)] := i; |
| } |
| } |
| } |
| |
| // check if the given regulator regulates an item for the given scenario |
| private function f_EPTF_ExecCtrl_Regulator_isRegulatesTrafficCase(in integer pl_regulatorIdx,in charstring pl_eGrpName,in charstring pl_scenName,in charstring pl_tcName) runs on EPTF_ExecCtrl_CT return boolean { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].idName; |
| // // check if the regulator regulates in the current phase: |
| // if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| // continue; |
| // } |
| var charstring vl_eGrpName := ""; |
| var charstring vl_scenName := ""; |
| var charstring vl_tcName := ""; |
| if (ischosen(vl_idName.cps_TC)) { |
| vl_eGrpName := vl_idName.cps_TC.eGrpName; |
| vl_scenName := vl_idName.cps_TC.scName; |
| vl_tcName := vl_idName.cps_TC.tcName; |
| } else if (ischosen(vl_idName.cps_TCInPhase)) { |
| vl_eGrpName := vl_idName.cps_TCInPhase.eGrpName; |
| vl_scenName := vl_idName.cps_TCInPhase.scName; |
| vl_tcName := vl_idName.cps_TCInPhase.tcName; |
| } |
| if (vl_eGrpName == pl_eGrpName and vl_scenName == pl_scenName and vl_tcName == pl_tcName) { |
| return true; // regulated item found for the given scenario |
| } |
| } |
| return false; |
| } |
| |
| // enables the regulator (scenarios for any item is running): |
| // disables the regulator if the scenarios for all items are not running: |
| friend function f_EPTF_ExecCtrl_Regulator_startStop(in integer pl_regulatorIdx) runs on EPTF_ExecCtrl_CT { |
| // if the regulator is disconnected, do nothing: |
| var integer vl_regulatorStatusIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(pl_regulatorIdx); |
| if (vl_regulatorStatusIdx!=-1) { |
| var EPTF_StatusLED vl_regulatorStatus := f_EPTF_Var_getStatusLEDValue(vl_regulatorStatusIdx); |
| if (vl_regulatorStatus == {led_red, "Disconnected"}) { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Regulator "&v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].name&" is Disconnected, not started"); |
| return; // do not start/stop the regulator if it is disconnected |
| } |
| } |
| // check all regulated items for this regulator if any of their scenarios is running: |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds); i<size; i:=i+1) { |
| var integer vl_regulatedItemIdx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].regulatedItemIds[i]; |
| |
| // check if the regulator regulates in the current phase: |
| if (not f_EPTF_ExecCtrl_currentPhaseIsRegulated(vl_regulatedItemIdx)) { |
| continue; |
| } |
| |
| if (v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].enabled |
| and f_EPTF_ExecCtrl_Regulator_itemIsRunning(vl_regulatedItemIdx)) { |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := v_EPTF_ExecCtrl_RegulatedItems[vl_regulatedItemIdx].idName; |
| f_EPTF_ExecCtrl_debug(log2str("Regulator #",pl_regulatorIdx," is started, scenario/traffic case is running: ", vl_idName)); |
| |
| // update the totalValue if it was changed: |
| var float vl_newTotalCps := f_EPTF_ExecCtrl_Regulator_getTotalCps(pl_regulatorIdx); |
| if (f_EPTF_Var_getFloatValue(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].totalValueIdx)!=vl_newTotalCps) { |
| f_EPTF_Var_adjustContent(v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].totalValueIdx,{floatVal := vl_newTotalCps}); |
| } |
| |
| var integer vl_idx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].enableIdx; |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := true}); |
| return; |
| } |
| } |
| // no running scenario found, stop the regulator: |
| f_EPTF_ExecCtrl_debug(log2str("Regulator #",pl_regulatorIdx," is stopped, none of the scenarios/traffic cases are running")); |
| var integer vl_idx := v_EPTF_ExecCtrl_Regulators[pl_regulatorIdx].enableIdx; |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := false}); |
| } |
| |
| } // group EPTF_ExecCtrl_Regulator |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_loadConfigFromModulepars |
| // |
| // Purpose: |
| // Loads configuration data from the module parameters (appends existing config) |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_loadConfigFromModulepars() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Loading modulepars..."); |
| f_EPTF_ExecCtrl_loadConfig( |
| pl_EPTF_LGenBase_TcMgmt_EntityGrpDeclaratorList :=tsp_LGenBase_EntityGrpDeclarators, |
| pl_EPTF_LGenBase_TcMgmt_Scenarios2GrpList :=tsp_LGenBase_Scenarios2Grps, |
| |
| pl_EPTF_LGenBase_ScenarioDeclaratorList :=tsp_LGenBase_ScenarioDeclarators, |
| pl_EPTF_LGenBase_tcTypeDeclaratorList :=tsp_LGenBase_tcTypeDeclarators, |
| |
| pl_EPTF_LGenBase_TcMgmt_tcTypeDeclaratorList :=tsp_LGenBase_TcMgmt_tcTypeDeclarators2, |
| pl_EPTF_LGenBase_TcMgmt_ScenarioDeclaratorList :=tsp_LGenBase_TcMgmt_ScenarioDeclarators2, |
| |
| pl_EPTF_LGenBase_TcMgmt_WeightedScenarioDeclaratorList :=tsp_LGenBase_TcMgmt_WeightedScenarioDeclarators, |
| |
| pl_EPTF_ExecCtrl_TimeProfileDescrList := tsp_EPTF_ExecCtrl_TimeProfileDescrList, |
| pl_EPTF_ExecCtrl_TimeProfileList := tsp_EPTF_ExecCtrl_TimeProfileList, |
| pl_EPTF_ExecCtrl_TimeProfile2TcList := tsp_EPTF_ExecCtrl_TimeProfile2TcList, |
| |
| pl_EPTF_LGenBase_ScenarioTypeDeclaratorList := tsp_LGenBase_TcMgmt_ScenarioDeclarators3, |
| pl_EPTF_ExecCtrl_ScenarioInstanceTypeList := tsp_EPTF_ExecCtrl_Scenario2EntityGroupList, |
| |
| pl_EPTF_ExecCtrl_LGenPool_Declarators := tsp_EPTF_ExecCtrl_LGenPool_Declarators, |
| pl_EPTF_ExecCtrl_EntityGroup2LGenPool_List := tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List, |
| |
| pl_EPTF_ExecCtrl_LGenFunction_Entry_List := {}, |
| |
| pl_EPTF_ExecCtrl_PhaseList_Declarators := tsp_EPTF_ExecCtrl_PhaseList_Declarators, |
| pl_EPTF_ExecCtrl_ScenarioGroup_Declarators := tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators, |
| |
| pl_EPTF_ExecCtrl_RegulatorNames := tsp_EPTF_ExecCtrl_RegulatorNames, |
| pl_EPTF_ExecCtrl_RegulatedItems := tsp_EPTF_ExecCtrl_RegulatedItems, |
| |
| pl_EPTF_ExecCtrl_EntityGroupDistributionTypeList := tsp_EPTF_ExecCtrl_EntityGroupDistributionDeclarators |
| ); |
| //v_ExecCtrl_manualControl := tsp_ExecCtrl_manualControl; |
| v_EPTF_ExecCtrl_StartStopScenarioDisable := tsp_EPTF_ExecCtrl_StartStopScenarioDisable; |
| v_EPTF_ExecCtrl_StartStopTCDisable := tsp_EPTF_ExecCtrl_StartStopTCDisable; |
| f_EPTF_ExecCtrl_debug(%definitionId&": Modulepars loaded."); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_clearConfig |
| // |
| // Purpose: |
| // Clears the variables that store configuration from module parameters |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_clearConfig() runs on EPTF_ExecCtrl_CT { |
| // declarators: |
| v_ExecCtrl_manualControl := tsp_ExecCtrl_manualControl; |
| v_ExecCtrl_EntityGrpDeclarators := {};//tsp_LGenBase_EntityGrpDeclarators; |
| v_ExecCtrl_ScenarioDeclarators := {};//tsp_LGenBase_ScenarioDeclarators; |
| v_ExecCtrl_tcTypeDeclarators := {};//tsp_LGenBase_tcTypeDeclarators; |
| v_ExecCtrl_Scenarios2Grps := {};//tsp_LGenBase_Scenarios2Grps; |
| |
| |
| v_ExecCtrl_scenario2EntityGroups:= {};//tsp_EPTF_ExecCtrl_Scenario2EntityGroupList; |
| v_ExecCtrl_tcTypeDeclarators2 := {};//tsp_LGenBase_TcMgmt_tcTypeDeclarators2; |
| v_ExecCtrl_ScenarioDeclarators2 := {};//tsp_LGenBase_TcMgmt_ScenarioDeclarators2; |
| v_ExecCtrl_ScenarioDeclarators3 := {};//tsp_LGenBase_TcMgmt_WeightedScenarioDeclarators; |
| v_ExecCtrl_ScenarioDeclaratorsR3 := {};//tsp_LGenBase_TcMgmt_ScenarioDeclarators3; |
| |
| v_EPTF_ExecCtrl_TimeProfile2TcList := {};//tsp_EPTF_ExecCtrl_TimeProfile2TcList; |
| v_EPTF_ExecCtrl_TimeProfileList := {};//tsp_EPTF_ExecCtrl_TimeProfileList; |
| v_EPTF_ExecCtrl_TimeProfileDescrList := {};//tsp_EPTF_ExecCtrl_TimeProfileDescrList; |
| |
| // LGenPool declarators: |
| v_EPTF_ExecCtrl_lgenCreatorFn_list := {}; |
| v_EPTF_ExecCtrl_LGenPool_Declarators := {};//tsp_EPTF_ExecCtrl_LGenPool_Declarators; |
| v_EPTF_ExecCtrl_EntityGroup2LGenPools := {};//tsp_EPTF_ExecCtrl_EntityGroup2LGenPool_List; |
| |
| // phases: |
| v_EPTF_ExecCtrl_PhaseList_Declarators := {};//tsp_EPTF_ExecCtrl_PhaseList_Declarators; |
| v_EPTF_ExecCtrl_ScenarioGroup_Declarators := {};//tsp_EPTF_ExecCtrl_ScenarioGroup_Declarators; |
| |
| // FIXME: f_cleanupRegulators: |
| v_EPTF_ExecCtrl_RegulatorNames := {};//tsp_EPTF_ExecCtrl_RegulatorNames; |
| v_EPTF_ExecCtrl_RegulatedItemsCFG := {};//tsp_EPTF_ExecCtrl_RegulatedItems; |
| |
| // entity group distribution: |
| v_EPTF_ExecCtrl_entityGroupDistributionCFG := {}; // tsp_EPTF_ExecCtrl_EntityGroupDistributionDeclarators |
| |
| v_EPTF_ExecCtrl_StartStopScenarioDisable := {};//tsp_EPTF_ExecCtrl_StartStopScenarioDisable; |
| v_EPTF_ExecCtrl_StartStopTCDisable := {};//tsp_EPTF_ExecCtrl_StartStopTCDisable; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_cleanup_CT |
| // |
| // Purpose: |
| // Cleanup EPTF_ExecCtrl feature |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_cleanup_CT() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| |
| f_EPTF_ExecCtrl_stopTimeProfiles(); |
| f_EPTF_ExecCtrl_sendByeToAllClients(); |
| |
| v_EPTF_ExecCtrl_ScTimeProfileDB := {}; |
| deactivate(v_EPTF_ExecCtrl_defaultAltstep); |
| v_EPTF_ExecCtrl_defaultAltstep := null; |
| |
| // clear the configuration: |
| f_EPTF_ExecCtrl_clearConfig(); |
| |
| // entity group distribution DB: |
| v_EPTF_ExecCtrl_entityGroupDistribution := {}; |
| |
| // FIXME: f_cleanupRegulators: |
| v_EPTF_ExecCtrl_RegulatedItems := {}; |
| v_EPTF_ExecCtrl_RegulatedItemIdsDB := {}; |
| v_EPTF_ExecCtrl_Regulators := {}; |
| |
| v_EPTF_ExecCtrl_ScenarioGroupPhaseChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns := {}; |
| v_EPTF_ExecCtrl_onGroupFinishCallbackFns := {}; |
| v_EPTF_ExecCtrl_finalTestReportGeneratorFns := {}; |
| v_EPTF_ExecCtrl_finalTestReport := ""; |
| //v_ExecCtrl_endOfTest := false; // do not generate report after cleanup again |
| |
| v_ExecCtrl_nrOfClients := 0; |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer := {}; |
| v_ExecCtrl_started := false; |
| v_ExecCtrl_readyToRun := false; |
| v_ExecCtrl_allLGensCreated := false; |
| v_EPTF_ExecCtrl_startTime := -1.0; |
| v_ExecCtrl_nrOfExpectedClients := -1; |
| // EPTF R3 InstanceDB |
| v_ExecCtrl_pendingMsgCounter := 0; |
| v_ExecCtrl_pendingByeCounter := 0; |
| |
| v_ExecCtrl_cfgState := c_ExecCtrl_Cfg_WAITFOR_INIT; |
| |
| f_EPTF_ExecCtrl_cleanupTypeDB(); |
| f_EPTF_ExecCtrl_cleanupInstanceDB(); |
| |
| f_EPTF_ExecCtrl_Phase_cleanUp(); |
| f_EPTF_ExecCtrl_LGenFunctions_cleanupInstanceDB(); |
| f_EPTF_ExecCtrl_LGenPool_cleanupInstanceDB(); |
| |
| if (v_ExecCtrl_regulatedItemsHash != c_ExecCtrl_invalidIdx) { |
| f_EPTF_str2int_HashMap_Delete(c_ExecCtrl_regulatedItemsHashMapName); |
| v_ExecCtrl_regulatedItemsHash := c_ExecCtrl_invalidIdx; |
| } |
| if (v_ExecCtrl_statHandlerHash != c_ExecCtrl_invalidIdx) { |
| f_EPTF_str2int_HashMap_Delete(c_ExecCtrl_statHandlerHashMapName); |
| v_ExecCtrl_statHandlerHash := c_ExecCtrl_invalidIdx; |
| } |
| |
| v_ExecCtrl_initialized := false; |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| //v_ExecCtrl_loggingMaskId := c_EPTF_Logging_invalidMaskId; // to be able to log after cleanup |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_sendUpdatedActiveEntities |
| // |
| // Purpose: |
| // On-demand sending the Number of active entities of an entity group to LGens |
| // |
| // Parameters: |
| // - pl_eGrpIdx - *in integer* - index of the entity group in <v_ExecCtrl_entityGroups> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid group |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_sendUpdatedActiveEntities( |
| in integer pl_eGrpIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid EntityGrp index "&int2str(pl_eGrpIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_entityGroups))&").", |
| pl_eGrpIdx >= 0 and pl_eGrpIdx < sizeof(v_ExecCtrl_entityGroups)); |
| |
| if (v_ExecCtrl_cfgState != c_ExecCtrl_Cfg_CONFIGURED) { |
| return; // lgens not signed in yet |
| } |
| |
| var EPTF_IntegerList vl_entityDistributionDb := f_EPTF_ExecCtrl_splitActiveEntitiesOfEGrp(pl_eGrpIdx); |
| |
| // Sending to LGens |
| var integer vl_eGrpIdx := pl_eGrpIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCountActive := vl_entityDistributionDb[lgenidx]; |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_UpdateActiveEntities:{ |
| eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| activeEntities := vl_entityDistributionDb[lgenidx] |
| }) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| |
| f_EPTF_ExecCtrl_debug(log2str("Active Entities of Entity Group ",v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| " updated on LGen ",v_ExecCtrl_lgens[vl_lgenIdx].name," to: ", vl_entityDistributionDb[lgenidx])); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_sendUpdatedCps |
| // |
| // Purpose: |
| // On-demand sending the CPS of the traffic case to LGens |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - index of the scenario in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - index of the traffic case in <EPTF_ExecCtrl_ScenarioList>[pl_scIdx].scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_sendUpdatedCps( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| |
| if (v_ExecCtrl_cfgState != c_ExecCtrl_Cfg_CONFIGURED) { |
| return; // lgens not signed in yet |
| } |
| |
| var EPTF_FloatList vl_cpsDistributionDb := f_EPTF_ExecCtrl_splitCPSOfTc(pl_scIdx,pl_tcOfScIdx); |
| |
| // Sending to LGens |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_UpdateCps:{ |
| eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name, // Currently only for debug purposes |
| tcName:= vl_tcName, |
| cps := vl_cpsDistributionDb[lgenidx] |
| }) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| |
| f_EPTF_ExecCtrl_debug(log2str("CPS of Tc #",pl_tcOfScIdx," of Scenario ", v_ExecCtrl_scenarios[pl_scIdx].name," updated on LGen ",v_ExecCtrl_lgens[vl_lgenIdx].name," to: ", vl_cpsDistributionDb[lgenidx])); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_sendUpdatedScenarioCps |
| // |
| // Purpose: |
| // On-demand sending the CPS of the scenario to LGens |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - index of the scenario in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid scenarios |
| // |
| // Detailed Comments: |
| // Only relevant for weighted scenario |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_sendUpdatedScenarioCps( |
| in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| |
| if (v_ExecCtrl_cfgState != c_ExecCtrl_Cfg_CONFIGURED) { |
| return; // lgens not signed in yet |
| } |
| |
| var EPTF_FloatList vl_cpsDistributionOfScDb := f_EPTF_ExecCtrl_splitCPSOfSc(pl_scIdx); |
| |
| // Sending to LGens |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| f_EPTF_ExecCtrl_debug(log2str("CPS of Scenario ",v_ExecCtrl_scenarios[pl_scIdx].name," updated on LGen ",v_ExecCtrl_lgens[vl_lgenIdx].name," to: ", vl_cpsDistributionOfScDb[lgenidx])); |
| |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_UpdateScenarioCps:{ |
| eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name, // Currently only for debug purposes |
| cps := vl_cpsDistributionOfScDb[lgenidx] |
| }) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| // the CPS of all TCs and all SCs of the entity group is redistributed onto the LGens |
| private function f_EPTF_ExecCtrl_sendCurrentCPSForAllSCInEGrp(in integer pl_eGrpIdx) runs on EPTF_ExecCtrl_CT { |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_entityGroups[pl_eGrpIdx].scenarios); sc<size; sc:=sc+1) { |
| var integer vl_scIdx := v_ExecCtrl_entityGroups[pl_eGrpIdx].scenarios[sc]; |
| if (f_EPTF_ExecCtrl_isWeightedScenario(vl_scIdx)) { |
| f_EPTF_ExecCtrl_sendUpdatedScenarioCps(vl_scIdx); |
| } else { |
| for(var integer tc:=0, sizet := sizeof(v_ExecCtrl_scenarios[vl_scIdx].tcIdxList); tc<sizet; tc:=tc+1) { |
| f_EPTF_ExecCtrl_sendUpdatedCps(vl_scIdx,tc); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_sendUpdatedStartDelay |
| // |
| // Purpose: |
| // On-demand sending the StartDelay of the traffic case to LGens |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - index of the scenario in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - index of the traffic case in <EPTF_ExecCtrl_ScenarioList>[pl_scIdx].scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_sendUpdatedStartDelay( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid SC index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| |
| if (v_ExecCtrl_cfgState != c_ExecCtrl_Cfg_CONFIGURED) { |
| return; // lgens not signed in yet |
| } |
| |
| // Sending to LGens |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx); |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_UpdateStartDelay:{ |
| eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name, // Currently only for debug purposes |
| tcName:= vl_tcName, |
| startDelay := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].startDelay |
| }) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| |
| f_EPTF_ExecCtrl_debug(log2str("StartDalay of Tc #",pl_tcOfScIdx," of Scenario ", v_ExecCtrl_scenarios[pl_scIdx].name," updated on LGen ",v_ExecCtrl_lgens[vl_lgenIdx].name," to: ", |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].startDelay)); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_subscribeScenarioState |
| // |
| // Purpose: |
| // Subscribe for scenario state variable on all ExecCtrlClient/LGen, and create a local variable to calculate the overall scenario state |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_subscribeScenarioState( |
| in integer pl_scIdx |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| var charstring vl_eType; |
| var charstring vl_varName := ""; |
| var integer vl_idx; |
| vl_varName := "ExecCtrlClient.scenarioStatus."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var EPTF_IntegerList vl_args := {}; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Subscribing on LGen (", v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_lgenIdx].name, " to variable : ", vl_varName)); |
| |
| f_EPTF_ExecCtrl_debug(log2str("Subscribing for (grp / scenName): ", |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, " / ", |
| v_ExecCtrl_scenarios[pl_scIdx].scData.name)); |
| |
| f_EPTF_Var_subscribeRemote( |
| f_EPTF_Var_downcast(f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef)), |
| vl_varName, |
| realtime, |
| vl_idx, |
| vl_varName&"."&v_ExecCtrl_lgens[vl_lgenIdx].name |
| ); |
| |
| // append variable index to the list: |
| vl_args[sizeof(vl_args)] := vl_idx; |
| f_EPTF_ExecCtrl_debug(log2str("New variable created: ", vl_varName&"."&v_ExecCtrl_lgens[vl_lgenIdx].name)); |
| } // lgenidx |
| |
| vl_varName := "ExecCtrl.scenarioStatus."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| f_EPTF_Var_newStatusLED(vl_varName,{led_black, "Timeout"},vl_idx); |
| f_EPTF_Var_subscribeLocal( |
| vl_idx, |
| { |
| calcFn := { |
| funcRef := refers(f_EPTF_ExecCtrl_scenarioStateCalcFn), |
| argList := vl_args, |
| nonVarArgList := {pl_scIdx} |
| } |
| } |
| ); |
| |
| // add postproc that will call scenarioStateChangedCallbacks |
| var integer vl_prevStatusIdx; // this var is needed to call callbacks only when state changes |
| f_EPTF_Var_newCharstring(vl_varName&".prevValue","",vl_prevStatusIdx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_scenarioStatePostProc), {pl_scIdx, vl_prevStatusIdx}} |
| ); |
| // call the postproc now: |
| f_EPTF_ExecCtrl_scenarioStatePostProc(vl_idx,{pl_scIdx, vl_prevStatusIdx}); |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createTrafficCaseVariablesOfSc |
| // |
| // Purpose: |
| // Creates all traffic case variables for a scenario |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createTrafficCaseVariablesOfSc( |
| in integer pl_scIdx |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| // go through all traffic cases of the scenario: |
| for(var integer tc:=0, size := sizeof(v_ExecCtrl_scenarios[pl_scIdx].tcIdxList); tc<size; tc:=tc+1) { |
| var integer vl_tcIdx := v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[tc]; |
| f_EPTF_ExecCtrl_subscribeTrafficCaseState(vl_tcIdx); |
| f_EPTF_ExecCtrl_createExecTimeForTc(vl_tcIdx); |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_subscribeTrafficCaseState |
| // |
| // Purpose: |
| // Subscribe for traffic case state variable on all ExecCtrlClient/LGen, and create a local variable to calculate the overall traffic case state |
| // |
| // Parameters: |
| // - pl_tcIdx - *in integer* - the traffic case index in <EPTF_ExecCtrl_TrafficCaseList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_subscribeTrafficCaseState( |
| in integer pl_tcIdx |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var integer vl_tcOfScenarioIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| |
| var integer vl_idx; |
| var charstring vl_varName := "ExecCtrlClient.trafficCaseStatus."& |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[vl_scIdx].scData.name&"."&f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScenarioIdx); |
| |
| var EPTF_IntegerList vl_args := {}; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Subscribing on LGen (", v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_lgenIdx].name, " to variable : ", vl_varName)); |
| |
| f_EPTF_ExecCtrl_debug(log2str("Subscribing for (grp / scenName): ", |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, " / ", |
| v_ExecCtrl_scenarios[vl_scIdx].scData.name)); |
| |
| f_EPTF_Var_subscribeRemote( |
| f_EPTF_Var_downcast(f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef)), |
| vl_varName, |
| realtime, |
| vl_idx, |
| vl_varName&"."&v_ExecCtrl_lgens[vl_lgenIdx].name |
| ); |
| |
| // append variable index to the list: |
| vl_args[sizeof(vl_args)] := vl_idx; |
| f_EPTF_ExecCtrl_debug(log2str("New variable created: ", vl_varName&"."&v_ExecCtrl_lgens[vl_lgenIdx].name)); |
| } // lgenidx |
| |
| vl_varName := "ExecCtrl.trafficCaseStatus."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[vl_scIdx].scData.name&"."&f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScenarioIdx) |
| f_EPTF_Var_newStatusLED(vl_varName,{led_black, "Timeout"},vl_idx); |
| f_EPTF_Var_subscribeLocal( |
| vl_idx, |
| { |
| calcFn := { |
| funcRef := refers(f_EPTF_ExecCtrl_scenarioStateCalcFn), |
| argList := vl_args, |
| nonVarArgList := {vl_scIdx} |
| } |
| } |
| ); |
| |
| // add postproc that will call trafficCaseStateChangedCallbacks |
| var integer vl_prevStatusIdx; // this var is needed to call callbacks only when state changes |
| f_EPTF_Var_newCharstring(vl_varName&".prevValue","",vl_prevStatusIdx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_trafficCaseStatePostProc), {pl_tcIdx, vl_prevStatusIdx}} |
| ); |
| // call the postproc now: |
| f_EPTF_ExecCtrl_trafficCaseStatePostProc(vl_idx,{pl_tcIdx, vl_prevStatusIdx}); |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createExecTimeForTc |
| // |
| // Purpose: |
| // Create the variable that shows the execTime of a traffic case |
| // |
| // Parameters: |
| // - pl_tcIdx - *in integer* - the traffic case index in <EPTF_ExecCtrl_TrafficCaseList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createExecTimeForTc( |
| in integer pl_tcIdx |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var integer vl_tcOfScenarioIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| |
| var integer vl_statId := f_EPTF_StatMeasure_newStat_chrono(); |
| f_EPTF_StatMeasure_stop_chrono(vl_statId); |
| // save the id into the onGroupFinish database: |
| v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.execTimeStatId := vl_statId; |
| |
| // add a callback that updates the stat periodically: |
| f_EPTF_Var_addSyncCallBackFn(refers(f_EPTF_ExecCtrl_updateExecTimeForTcSyncCallBack), {vl_statId}); |
| } |
| |
| // the function that updates the execTime stats pl_argList[0] : the statId |
| private function f_EPTF_ExecCtrl_updateExecTimeForTcSyncCallBack(in EPTF_IntegerList pl_argList) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_StatMeasure_update_chrono(pl_argList[0]); |
| } |
| |
| // this function starts and stops the execTime statistics for the traffic case |
| private function f_EPTF_ExecCtrl_execTimeUpdate_TCStateChangedCallbackFn( |
| in charstring pl_eGrpName, |
| in charstring pl_scName, |
| in charstring pl_tcName, |
| in charstring pl_state |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_eGrpName,pl_scName,pl_tcName); |
| var integer vl_statId := -1; |
| |
| //HM85637 |
| if(isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.execTimeStatId)) { |
| vl_statId := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.execTimeStatId; |
| } |
| |
| if (vl_statId==-1) { |
| return; |
| } |
| // start the chronometer when TC state changes to running: |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]) { |
| f_EPTF_StatMeasure_resetStat(vl_statId); |
| f_EPTF_StatMeasure_addData_chrono(vl_statId); |
| return; |
| } |
| // reset the chronometer to 0 when TC state changes to idle |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateIdle]) { |
| f_EPTF_StatMeasure_resetStat(vl_statId); |
| f_EPTF_StatMeasure_stop_chrono(vl_statId); |
| return; |
| } |
| // stop chrono in any other case: |
| f_EPTF_StatMeasure_stop_chrono(vl_statId); |
| } |
| |
| // returns the execTime of the traffic case (does not refresh the stat) |
| private function f_EPTF_ExecCtrl_getExecTimeForTc( |
| in integer pl_tcIdx |
| ) runs on EPTF_ExecCtrl_CT return float { |
| return f_EPTF_StatMeasure_getTime_chrono(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.execTimeStatId); |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_scenarioStateCalcFn |
| // |
| // Purpose: |
| // CalcFn function to calculate the statusLED from the scenario states in LGens |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the statusLED |
| // - pl_argList - *in* <EPTF_IntegerList> - list of scenario State variables for LGens |
| // - pl_nonVarArgList - *in* <EPTF_IntegerList> - entity group and scenario idx |
| // - pl_retVal - *inout* <EPTF_Var_DirectContent> - the new value of the statusLED |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // If the states are the same for all LGens, the state is set to the one |
| // calculated by <f_EPTF_ExecCtrl_stateStrToEPTF_StatusLED>. |
| // If the states are different, the state is set to : {led_yellow,"Mixed"} |
| // If pl_argList is empty, the state is set to: {led_black,"Off"} |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_scenarioStateCalcFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_IntegerList pl_nonVarArgList, inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_ExecCtrl_CT { |
| pl_retVal := {statusLEDVal := {led_yellow, "Mixed"} }; // invalid |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&"()"); |
| f_EPTF_ExecCtrl_debug(log2str("pl_idx: ", pl_idx)); |
| f_EPTF_ExecCtrl_debug(log2str("pl_argList: ", pl_argList)); |
| } |
| |
| var EPTF_Var_DirectContent vl_content1; |
| var boolean sync := true; |
| if (sizeof(pl_argList) == 0) { |
| // no LGens |
| sync := true; |
| vl_content1 := {charstringVal := "Off"}; |
| } else { |
| // LGen list is not empty |
| var EPTF_Var_DirectContent vl_content2; |
| var integer vl_LGenScenarioStateVarIdx := pl_argList[0]; |
| f_EPTF_Var_getContent(vl_LGenScenarioStateVarIdx, vl_content1); |
| for (var integer i:=1, size := sizeof(pl_argList); i<size; i:=i+1) { |
| vl_LGenScenarioStateVarIdx := pl_argList[i]; |
| f_EPTF_Var_getContent(vl_LGenScenarioStateVarIdx, vl_content2); |
| if (vl_content1 != vl_content2) { |
| sync := false; |
| break; |
| } |
| } |
| } |
| if (sync) { |
| f_EPTF_ExecCtrl_debug(log2str("Scenario state is in sync for scenario ", f_EPTF_Var_getName(pl_idx), " : ", vl_content1)); |
| pl_retVal := { |
| statusLEDVal := f_EPTF_ExecCtrl_stateStrToEPTF_StatusLED(vl_content1.charstringVal) |
| } |
| } |
| |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stateStrToEPTF_StatusLED |
| // |
| // Purpose: |
| // Converts c_EPTF_LGenBase_stateNames to statusLED |
| // |
| // Parameters: |
| // - pl_state - *in charstring* - stateName |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_stateStrToEPTF_StatusLED(in charstring pl_state) return EPTF_StatusLED { |
| var EPTF_StatusLED vl_led; |
| select (pl_state) { |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateIdle]) { |
| vl_led := { |
| color := led_blue, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateAborting]) { |
| vl_led := { |
| color := led_red, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]) { |
| vl_led := { |
| color := led_green, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateTerminated]) { |
| vl_led := { |
| color := led_blue, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateFinished]) { |
| vl_led := { |
| color := led_yellow, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateStopped]) { |
| vl_led := { |
| color := led_blue, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateAborted]) { |
| vl_led := { |
| color := led_blue, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStatePaused]) { |
| vl_led := { |
| color := led_blue, |
| text := pl_state |
| } |
| } |
| case (c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateStopping]) { |
| vl_led := { |
| color := led_red, |
| text := pl_state |
| } |
| } |
| case else { |
| vl_led := { |
| color := led_black, |
| text := pl_state |
| } |
| } |
| } |
| return vl_led; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_scenarioStatePostProc |
| // |
| // Purpose: |
| // Postproc fn to call ScenarioStateChangedCallbacks |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the statusLED |
| // - pl_argList - *in* <EPTF_IntegerList> - index of the scenario instance |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // This postproc is used on the statusLED variable of the scenario (ExecCtrl.scenarioStatus) |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_scenarioStatePostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_prevStatusIdx := pl_argList[1]; |
| |
| var EPTF_StatusLED vl_status := f_EPTF_Var_getStatusLEDValue(pl_idx); |
| var charstring vl_prevStatus := f_EPTF_Var_getCharstringValue(vl_prevStatusIdx); |
| |
| // do nothing if status not changed: |
| if (vl_prevStatus==vl_status.text) { |
| return; |
| } |
| // update prevStatus (no subscribers => adjustContent is not needed, setContent is faster): |
| f_EPTF_Var_setContent(vl_prevStatusIdx,{charstringVal:=vl_status.text}); |
| |
| // call callback functions (eGrpName,scenName,statusTxt) |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| f_EPTF_ExecCtrl_callScenarioStateChangedCallbacks(vl_eGrpName,vl_scenName,vl_status.text); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_registerScenarioStateChangedCallback |
| // |
| // Purpose: |
| // Register a scenario stateChange callback function, that is called when the states of the scenarios in all LGens reach the same state |
| // |
| // Parameters: |
| // - pl_scenarioStateChangedCallback - *in* <EPTF_ExecCtrl_ScenarioStateChangedCallbackFn> - reference to the callback function |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(in EPTF_ExecCtrl_ScenarioStateChangedCallbackFn pl_scenarioStateChangedCallback) runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns[sizeof(v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns)] := pl_scenarioStateChangedCallback; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_callScenarioStateChangedCallbacks |
| // |
| // Purpose: |
| // Calls all scenarioStateChange callback functions |
| // |
| // Parameters: |
| // - pl_eGrpName - *in charstring* - name of the entity group |
| // - pl_scName - *in charstring* - name of the scenario |
| // - pl_state - *in charstring* - state of the scenario (see <c_EPTF_LGenBase_stateNames> in <EPTF_CLL_LGenBase_Definitions> for possible values) |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_callScenarioStateChangedCallbacks(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns); i<size; i:=i+1) { |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("ExecCtrl: scenarioStateChangedCallback: ", v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns[i], " called")); |
| f_EPTF_ExecCtrl_debug(log2str("Args: pl_eGrpName: ", pl_eGrpName, " pl_scName: ", pl_scName, " pl_state: ",pl_state)) |
| } |
| v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns[i].apply(pl_eGrpName,pl_scName,pl_state); |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("ExecCtrl: scenarioStateChangedCallback: ", v_EPTF_ExecCtrl_ScenarioStateChangedCallbackFns[i], " done")); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_trafficCaseStatePostProc |
| // |
| // Purpose: |
| // Postproc fn to call TrafficCaseStateChangedCallbacks |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the statusLED |
| // - pl_argList - *in* <EPTF_IntegerList> - index of the trafficCase instance |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // This postproc is used on the statusLED variable of the traffic case (ExecCtrl.trafficCaseStatus) |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_trafficCaseStatePostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var integer vl_tcIdx := pl_argList[0]; |
| var integer vl_prevStatusIdx := pl_argList[1]; |
| |
| var EPTF_StatusLED vl_status := f_EPTF_Var_getStatusLEDValue(pl_idx); |
| var charstring vl_prevStatus := f_EPTF_Var_getCharstringValue(vl_prevStatusIdx); |
| |
| // do nothing if status not changed: |
| if (vl_prevStatus==vl_status.text) { |
| return; |
| } |
| // update prevStatus (no subscribers => adjustContent is not needed, setContent is faster): |
| f_EPTF_Var_setContent(vl_prevStatusIdx,{charstringVal:=vl_status.text}); |
| |
| // call callback functions (eGrpName,scenName,statusTxt) |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[vl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[vl_tcIdx].tcOfScenarioIdx; |
| |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx); |
| f_EPTF_ExecCtrl_callTrafficCaseStateChangedCallbacks(vl_eGrpName,vl_scenName,vl_tcName,vl_status.text); |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback |
| // |
| // Purpose: |
| // Register a trafficCase stateChange callback function, that is called when the states of the trafficCases in all LGens reach the same state |
| // |
| // Parameters: |
| // - pl_trafficCaseStateChangedCallback - *in* <EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn> - reference to the callback function |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(in EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFn pl_trafficCaseStateChangedCallback) runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns[sizeof(v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns)] := pl_trafficCaseStateChangedCallback; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_callTrafficCaseStateChangedCallbacks |
| // |
| // Purpose: |
| // Calls all trafficCaseStateChange callback functions |
| // |
| // Parameters: |
| // - pl_eGrpName - *in charstring* - name of the entity group |
| // - pl_scName - *in charstring* - name of the trafficCase |
| // - pl_tcName - *in charstring* - name of the trafficCase |
| // - pl_state - *in charstring* - state of the trafficCase (see <c_EPTF_LGenBase_stateNames> in <EPTF_CLL_LGenBase_Definitions> for possible values) |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_callTrafficCaseStateChangedCallbacks(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_tcName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| //f_EPTF_ExecCtrl_debug(%definitionId&": ", pl_eGrpName, " pl_scName: ", pl_scName, " pl_tcName: ", pl_tcName, " pl_state: ",pl_state); |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns); i<size;i:=i+1) { |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("ExecCtrl: trafficCaseStateChangedCallback: ", v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns[i], " called")); |
| f_EPTF_ExecCtrl_debug(log2str("Args: pl_eGrpName: ", pl_eGrpName, " pl_scName: ", pl_scName, " pl_tcName: ", pl_tcName, " pl_state: ",pl_state)) |
| } |
| v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns[i].apply(pl_eGrpName,pl_scName,pl_tcName,pl_state); |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("ExecCtrl: trafficCaseStateChangedCallback: ", v_EPTF_ExecCtrl_TrafficCaseStateChangedCallbackFns[i], " done")); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createStartStopScenario |
| // |
| // Purpose: |
| // Creates a variable that can be used to start/stop the scenario |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createStartStopScenario( |
| in integer pl_scIdx |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| var charstring vl_eType; |
| var integer vl_startScenarioVarIdx; |
| var integer vl_stopScenarioVarIdx; |
| var charstring vl_varName := "ExecCtrl.scenarioStatus."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var integer vl_scenarioStateVarIdx := f_EPTF_Var_getId(vl_varName); |
| |
| // Start Scenario |
| vl_varName := "ExecCtrl.startScenario."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| f_EPTF_Var_newBool(vl_varName,false,vl_startScenarioVarIdx); |
| // Stop Scenario |
| vl_varName := "ExecCtrl.stopScenario."&v_ExecCtrl_entityGroups[vl_eGrpIdx].name&"."&v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| f_EPTF_Var_newBool(vl_varName,false,vl_stopScenarioVarIdx); |
| |
| var EPTF_IntegerList vl_args := {}; |
| |
| // Start Scenario |
| f_EPTF_Var_addGuardFn( |
| vl_startScenarioVarIdx, |
| { |
| funcRef := refers(f_EPTF_ExecCtrl_startScenarioGuardFn), |
| argList := {pl_scIdx,vl_scenarioStateVarIdx,vl_stopScenarioVarIdx} |
| } |
| ); |
| |
| // Stop Scenario |
| f_EPTF_Var_addGuardFn( |
| vl_stopScenarioVarIdx, |
| { |
| funcRef := refers(f_EPTF_ExecCtrl_stopScenarioGuardFn), |
| argList := {pl_scIdx,vl_scenarioStateVarIdx,vl_startScenarioVarIdx} |
| } |
| ); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startScenarioGuardFn |
| // |
| // Purpose: |
| // GuardFn function to start/stop the scenario |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the runScenario variable |
| // - pl_argList - *in* <EPTF_IntegerList> - not used |
| // - pl_newContent - *in* <EPTF_Var_DirectContent> - the new value of the runScenario |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // if the scenario is not running: starts the scenario and sets it to true |
| // if the scenario is not stopped: stops the scenario and sets the value to false |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_startScenarioGuardFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_ExecCtrl_CT return boolean { |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_scenarioStateVarIdx := pl_argList[1]; |
| var integer vl_stopScenarioVarIdx := pl_argList[2]; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| // var EPTF_Var_DirectContent vl_scenarioState; |
| // f_EPTF_Var_getContent(vl_scenarioStateVarIdx,vl_scenarioState); |
| // if (vl_scenarioState.statusLEDVal.text=="Running") { |
| // if (pl_newContent.boolVal==true) { |
| // f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| // return false; // new value is not accepted |
| // } |
| // }// else { |
| if (pl_newContent.boolVal==true) { |
| |
| // check if button is disabled: |
| if (f_EPTF_ExecCtrl_isDisabledStartStopScenario( |
| {vl_eGrpName, vl_scenName} |
| )) { |
| f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| return false; |
| } |
| |
| // uncheck the other: |
| f_EPTF_Var_adjustContent(vl_stopScenarioVarIdx,{boolVal := false}) |
| // start scenario: |
| f_EPTF_ExecCtrl_startScenarioOnLGens(vl_scIdx); |
| } |
| // } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopScenarioGuardFn |
| // |
| // Purpose: |
| // GuardFn function to start/stop the scenario |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the runScenario variable |
| // - pl_argList - *in* <EPTF_IntegerList> - not used |
| // - pl_newContent - *in* <EPTF_Var_DirectContent> - the new value of the runScenario |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // if the scenario is not running: starts the scenario and sets it to true |
| // if the scenario is not stopped: stops the scenario and sets the value to false |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_stopScenarioGuardFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_ExecCtrl_CT return boolean { |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_scenarioStateVarIdx := pl_argList[1]; |
| var integer vl_startScenarioVarIdx := pl_argList[2]; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| // var EPTF_Var_DirectContent vl_scenarioState; |
| // f_EPTF_Var_getContent(vl_scenarioStateVarIdx,vl_scenarioState); |
| // if (vl_scenarioState.statusLEDVal.text=="Idle" |
| // or vl_scenarioState.statusLEDVal.text=="Stopped" |
| // or vl_scenarioState.statusLEDVal.text=="Aborted" |
| // or vl_scenarioState.statusLEDVal.text=="Finished" |
| // or vl_scenarioState.statusLEDVal.text=="Paused" |
| // ) { |
| // if (pl_newContent.boolVal==true) { |
| // f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| // return false; // new value is not accepted |
| // } |
| // }// else { |
| if (pl_newContent.boolVal==true) { |
| |
| // check if button is disabled: |
| if (f_EPTF_ExecCtrl_isDisabledStartStopScenario( |
| {vl_eGrpName, vl_scenName} |
| )) { |
| f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| return false; |
| } |
| |
| // uncheck the other: |
| f_EPTF_Var_adjustContent(vl_startScenarioVarIdx,{boolVal := false}) |
| // start scenario: |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(vl_scIdx); |
| } |
| // } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_enableStartStopScenario |
| // |
| // Purpose: |
| // Adds or enables start/stop scenario button |
| // |
| // Parameters: |
| // - pl_scIdName - *in* <EPTF_ExecCtrl_SCName> - entity group and scenario name |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_enableStartStopScenario(in EPTF_ExecCtrl_SCName pl_scIdName) runs on EPTF_ExecCtrl_CT { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopScenarioIdx(pl_scIdName); |
| if (vl_idx!=-1) { |
| v_EPTF_ExecCtrl_StartStopScenarioDisable[vl_idx].disabled := false; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_disableStartStopScenario |
| // |
| // Purpose: |
| // Adds or disables start/stop scenario button |
| // |
| // Parameters: |
| // - pl_scIdName - *in* <EPTF_ExecCtrl_SCName> - entity group and scenario name |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_disableStartStopScenario(in EPTF_ExecCtrl_SCName pl_scIdName) runs on EPTF_ExecCtrl_CT { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopScenarioIdx(pl_scIdName); |
| if (vl_idx!=-1) { |
| v_EPTF_ExecCtrl_StartStopScenarioDisable[vl_idx].disabled := true; |
| return; |
| } |
| // add new item |
| vl_idx := sizeof(v_EPTF_ExecCtrl_StartStopScenarioDisable); |
| v_EPTF_ExecCtrl_StartStopScenarioDisable[vl_idx].disabled := true; |
| v_EPTF_ExecCtrl_StartStopScenarioDisable[vl_idx].scIdName := pl_scIdName; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_disableScenariosForPhaseGroups |
| // |
| // Purpose: |
| // Disables scenarios that are in scenarioGroups |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_disableScenariosForPhaseGroups() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started..."); |
| f_EPTF_ExecCtrl_debug(log2str("v_ExecCtrl_ScenarioGroupInstanceDB: ", v_ExecCtrl_ScenarioGroupInstanceDB)); |
| for(var integer scGroup:=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data); scGroup<size;scGroup:=scGroup+1) { |
| for(var integer sc:=0, sizesc := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data[scGroup].scenarios); sc<sizesc; sc:=sc+1) { |
| // FIXME: check if it is not a removed item (FBQ element is busy) |
| var charstring vl_scName := v_ExecCtrl_ScenarioGroupInstanceDB.data[scGroup].scenarios[sc].name; |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxByInstanceName(vl_scName); |
| f_EPTF_ExecCtrl_debug(log2str("Disabling scenarioStartStop for scenario: ", vl_scName)); |
| if (vl_scIdx==-1) { |
| f_EPTF_ExecCtrl_debug(log2str("Scenario not found: ", vl_scName)); |
| continue; |
| } |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scTypeName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| var EPTF_ExecCtrl_SCName vl_scIdName := { |
| vl_eGrpName, |
| vl_scTypeName |
| }; |
| f_EPTF_ExecCtrl_disableStartStopScenario(vl_scIdName); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup |
| // |
| // Purpose: |
| // Checks if a scenario belongs to a scenario group |
| // |
| // Parameters: |
| // - pl_scIdName - *in* <EPTF_ExecCtrl_SCName> - entity group and scenario name |
| // |
| // Return Value: |
| // boolean |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Returns true if the scenario does not belong to any scenario group |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| return boolean { |
| return (f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(pl_scIdx)==-1) |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_isDisabledStartStopScenario |
| // |
| // Purpose: |
| // Checks if start/stop scenario button is disabled |
| // |
| // Parameters: |
| // - pl_scIdName - *in* <EPTF_ExecCtrl_SCName> - entity group and scenario name |
| // |
| // Return Value: |
| // boolean - true if disabled, false if not (if not specified it is considered to be false (enabled)) |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_isDisabledStartStopScenario(in EPTF_ExecCtrl_SCName pl_scIdName) runs on EPTF_ExecCtrl_CT return boolean { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopScenarioIdx(pl_scIdName); |
| if (vl_idx!=-1 and v_EPTF_ExecCtrl_StartStopScenarioDisable[vl_idx].disabled) { |
| return true; |
| } |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getStartStopScenarioIdx |
| // |
| // Purpose: |
| // Returns the idx of the start/stop scenario button item |
| // |
| // Parameters: |
| // - pl_scIdName - *in* <EPTF_ExecCtrl_SCName> - entity group and scenario name |
| // |
| // Return Value: |
| // integer - the index in v_EPTF_ExecCtrl_StartStopScenarioDisable of the enable data |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getStartStopScenarioIdx(in EPTF_ExecCtrl_SCName pl_scIdName) runs on EPTF_ExecCtrl_CT return integer { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_StartStopScenarioDisable); i<size;i:=i+1) { |
| if (v_EPTF_ExecCtrl_StartStopScenarioDisable[i].scIdName == pl_scIdName) { |
| return i; |
| } |
| } |
| return -1; // not found |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createStartStopAllTC |
| // |
| // Purpose: |
| // Calls <f_EPTF_ExecCtrl_createStartStopTC> for all traffic cases for the specified eGrp and scen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createStartStopAllTC( |
| in integer pl_scIdx |
| ) runs on EPTF_ExecCtrl_CT { |
| var charstring scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| |
| for(var integer i:=0, size := sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList); i<size; i:=i+1) { |
| f_EPTF_ExecCtrl_createStartStopTC(pl_scIdx,i); |
| f_EPTF_ExecCtrl_createResetStatsTC(pl_scIdx,i); |
| f_EPTF_ExecCtrl_createResetFSMStatsTC(pl_scIdx,i); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createStartStopTC |
| // |
| // Purpose: |
| // Creates a variable that can be used to start/stop the TC |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - the tclist index in <EPTF_ExecCtrl_ScenarioList>.scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios and traffic case |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createStartStopTC( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx |
| ) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var charstring tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| |
| var integer vl_startTCVarIdx; |
| var integer vl_stopTCVarIdx; |
| var charstring vl_varName;// := "ExecCtrl.scenarioStatus."&eGrpName&"."&scenName; |
| // var integer vl_scenarioStateVarIdx := f_EPTF_Var_getId(vl_varName); |
| |
| // Start TC |
| vl_varName := "ExecCtrl.startTC."&eGrpName&"."&scenName&"."&tcName; |
| f_EPTF_Var_newBool(vl_varName,false,vl_startTCVarIdx); |
| // Stop Tc |
| vl_varName := "ExecCtrl.stopTC."&eGrpName&"."&scenName&"."&tcName; |
| f_EPTF_Var_newBool(vl_varName,false,vl_stopTCVarIdx); |
| |
| var EPTF_IntegerList vl_args := {}; |
| |
| // Start Tc |
| f_EPTF_Var_addGuardFn( |
| vl_startTCVarIdx, |
| { |
| funcRef := refers(f_EPTF_ExecCtrl_startTCGuardFn), |
| argList := {pl_scIdx,pl_tcOfScIdx/*,vl_scenarioStateVarIdx*/,vl_stopTCVarIdx} |
| } |
| ); |
| |
| // Stop Tc |
| f_EPTF_Var_addGuardFn( |
| vl_stopTCVarIdx, |
| { |
| funcRef := refers(f_EPTF_ExecCtrl_stopTCGuardFn), |
| argList := {pl_scIdx,pl_tcOfScIdx/*,vl_scenarioStateVarIdx*/,vl_startTCVarIdx} |
| } |
| ); |
| |
| // create same with integers: |
| // Control buttons (start/stop): |
| // start tc button: |
| var charstring vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&eGrpName&".SC."&scenName&".TC."&tcName&".ControlButtons.Start"; |
| |
| var integer vl_startTcVarIdx,vl_stopTcVarIdx; |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_startTcVarIdx); |
| |
| // stop tc button: |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&eGrpName&".SC."&scenName&".TC."&tcName&".ControlButtons.Stop"; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_stopTcVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn( |
| vl_startTcVarIdx, { refers(f_EPTF_ExecCtrl_UIVars_startTc_PostProc), {pl_scIdx,pl_tcOfScIdx,vl_startTcVarIdx,vl_stopTcVarIdx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_stopTcVarIdx, { refers(f_EPTF_ExecCtrl_UIVars_stopTc_PostProc), {pl_scIdx,pl_tcOfScIdx,vl_startTcVarIdx,vl_stopTcVarIdx}} ); |
| |
| // call f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback to initialize button status: |
| vl_currentName := "ExecCtrl.trafficCaseStatus."&eGrpName&"."&scenName&"."&tcName; |
| var integer vl_idx := f_EPTF_Var_getId(vl_currentName); |
| if (vl_idx != -1) { |
| var EPTF_StatusLED vl_EPTF_StatusLED := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| f_EPTF_ExecCtrl_startStopTc_tcStateChangedCallback(eGrpName,scenName,tcName,vl_EPTF_StatusLED.text); |
| } |
| |
| // disable start/stop tc buttons if tc is in scenario group: |
| if (not f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(pl_scIdx)) { |
| f_EPTF_Var_setSubsCanAdjust(vl_startTcVarIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopTcVarIdx,false); |
| } |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createResetStatsTC |
| // |
| // Purpose: |
| // Creates a variable that can be used to reset some TC stats |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - the tclist index in <EPTF_ExecCtrl_ScenarioList>.scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios and traffic case |
| // |
| // Detailed Comments: |
| // The created variable can be used to reset the following TC stats: |
| // -Start |
| // -Success |
| // -Fail |
| // -Timeout |
| // -Error |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createResetStatsTC(in integer pl_scIdx, in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var charstring tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| |
| var integer vl_resetStatsTcVarIdx; |
| var charstring vl_varName := "ExecCtrl.resetStatsTC."&eGrpName&"."&scenName&"."&tcName; |
| f_EPTF_Var_newInt(vl_varName, 0, vl_resetStatsTcVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn(vl_resetStatsTcVarIdx, {refers(f_EPTF_ExecCtrl_UIVars_resetStatsTc_PostProc), {pl_scIdx, pl_tcOfScIdx}}); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| private function f_EPTF_ExecCtrl_createResetStatsAllTC() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_resetStatsTcVarIdx; |
| var charstring vl_varName := "ExecCtrl.resetStatsAllTC"; |
| f_EPTF_Var_newInt(vl_varName, 0, vl_resetStatsTcVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn(vl_resetStatsTcVarIdx, {refers(f_EPTF_ExecCtrl_UIVars_resetStatsAllTc_PostProc), {}}); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_createResetFSMStatsTC |
| // |
| // Purpose: |
| // Creates a variable that can be used to reset the FSM stats of a Traffic Case |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - the tclist index in <EPTF_ExecCtrl_ScenarioList>.scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios and traffic case |
| // |
| // Detailed Comments: |
| // The created variable can be used to reset the following TC stats: |
| // -Start |
| // -Success |
| // -Fail |
| // -Timeout |
| // -Error |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_createResetFSMStatsTC(in integer pl_scIdx, in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var charstring tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| |
| var integer vl_resetStatsTcVarIdx; |
| var charstring vl_varName := "ExecCtrl.resetFSMStatsTC."&eGrpName&"."&scenName&"."&tcName; |
| f_EPTF_Var_newInt(vl_varName, 0, vl_resetStatsTcVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn(vl_resetStatsTcVarIdx, {refers(f_EPTF_ExecCtrl_UIVars_resetFSMStatsTc_PostProc), {pl_scIdx, pl_tcOfScIdx}}); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| private function f_EPTF_ExecCtrl_createResetFSMStatsAllTC() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "& %definitionId&": start"); |
| |
| var integer vl_resetStatsTcVarIdx; |
| var charstring vl_varName := "ExecCtrl.resetFSMStatsAllTC"; |
| f_EPTF_Var_newInt(vl_varName, 0, vl_resetStatsTcVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn(vl_resetStatsTcVarIdx, {refers(f_EPTF_ExecCtrl_UIVars_resetFSMStatsAllTc_PostProc), {}}); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startTCGuardFn |
| // |
| // Purpose: |
| // GuardFn function to start/stop the TC |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the runScenario variable |
| // - pl_argList - *in* <EPTF_IntegerList> - not used |
| // - pl_newContent - *in* <EPTF_Var_DirectContent> - the new value of the runScenario |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // if the scenario is not running: starts the scenario and sets it to true |
| // if the scenario is not stopped: stops the scenario and sets the value to false |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_startTCGuardFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_ExecCtrl_CT return boolean { |
| |
| var integer vl_scIdx := pl_argList[0]; |
| // var integer vl_scenarioStateVarIdx := pl_argList[2]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_stopTCVarIdx := pl_argList[2]; |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| var charstring tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx) |
| |
| if (pl_newContent.boolVal==true) { |
| |
| // check if button is disabled: |
| if (f_EPTF_ExecCtrl_isDisabledStartStopTC( |
| {eGrpName, scenName, tcName} |
| )) { |
| f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| return false; |
| } |
| |
| // // uncheck the other: |
| // f_EPTF_Var_adjustContent(vl_stopTCVarIdx,{boolVal := false}) |
| // start TC: |
| f_EPTF_ExecCtrl_startTCOnLGens(vl_scIdx,vl_tcOfScIdx); |
| return true; |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopTCGuardFn |
| // |
| // Purpose: |
| // GuardFn function to start/stop the TC |
| // |
| // Parameters: |
| // - pl_idx - *in integer* - idx of the EPTF Variable containing the runScenario variable |
| // - pl_argList - *in* <EPTF_IntegerList> - not used |
| // - pl_newContent - *in* <EPTF_Var_DirectContent> - the new value of the runScenario |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // if the scenario is not running: starts the scenario and sets it to true |
| // if the scenario is not stopped: stops the scenario and sets the value to false |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_stopTCGuardFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_Var_DirectContent pl_newContent) runs on EPTF_ExecCtrl_CT return boolean { |
| var integer vl_scIdx := pl_argList[0]; |
| // var integer vl_scenarioStateVarIdx := pl_argList[2]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_startTCVarIdx := pl_argList[2]; |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| var charstring tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx) |
| |
| if (pl_newContent.boolVal==true) { |
| |
| // check if button is disabled: |
| if (f_EPTF_ExecCtrl_isDisabledStartStopTC( |
| {eGrpName, scenName, tcName} |
| )) { |
| f_EPTF_Var_refreshContent(pl_idx); // update the gui with the previous value |
| return false; |
| } |
| |
| // // uncheck the other: |
| // f_EPTF_Var_adjustContent(vl_startTCVarIdx,{boolVal := false}) |
| // stop TC: |
| f_EPTF_ExecCtrl_stopTCOnLGens(vl_scIdx,vl_tcOfScIdx); |
| return true; |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_enableStartStopTC |
| // |
| // Purpose: |
| // Adds or enables start/stop TC button |
| // |
| // Parameters: |
| // - pl_tcIdName - *in* <EPTF_ExecCtrl_TCName> - entity group scenario and traffic case name |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_enableStartStopTC(in EPTF_ExecCtrl_TCName pl_tcIdName) runs on EPTF_ExecCtrl_CT { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopTCIdx(pl_tcIdName); |
| if (vl_idx!=-1) { |
| v_EPTF_ExecCtrl_StartStopTCDisable[vl_idx].disabled := false; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_disableStartStopTC |
| // |
| // Purpose: |
| // Adds or disables start/stop TC button |
| // |
| // Parameters: |
| // - pl_tcIdName - *in* <EPTF_ExecCtrl_SCName> - entity group scenario and traffic case name |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_disableStartStopTC(in EPTF_ExecCtrl_TCName pl_tcIdName) runs on EPTF_ExecCtrl_CT { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopTCIdx(pl_tcIdName); |
| if (vl_idx!=-1) { |
| v_EPTF_ExecCtrl_StartStopTCDisable[vl_idx].disabled := true; |
| return; |
| } |
| // add new item |
| vl_idx := sizeof(v_EPTF_ExecCtrl_StartStopTCDisable); |
| v_EPTF_ExecCtrl_StartStopTCDisable[vl_idx].disabled := true; |
| v_EPTF_ExecCtrl_StartStopTCDisable[vl_idx].tcIdName := pl_tcIdName; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_isDisabledStartStopTC |
| // |
| // Purpose: |
| // Checks if start/stop TC button is disabled |
| // |
| // Parameters: |
| // - pl_tcIdName - *in* <EPTF_ExecCtrl_TCName> - entity group scenario and traffic case name |
| // |
| // Return Value: |
| // boolean - true if disabled, false if not (if not specified it is considered to be false (enabled)) |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_isDisabledStartStopTC(in EPTF_ExecCtrl_TCName pl_tcIdName) runs on EPTF_ExecCtrl_CT return boolean { |
| var integer vl_idx := f_EPTF_ExecCtrl_getStartStopTCIdx(pl_tcIdName); |
| if (vl_idx!=-1 and v_EPTF_ExecCtrl_StartStopTCDisable[vl_idx].disabled) { |
| return true; |
| } |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getStartStopTCIdx |
| // |
| // Purpose: |
| // Returns the idx of the start/stop TC button item |
| // |
| // Parameters: |
| // - pl_tcIdName - *in* <EPTF_ExecCtrl_TCName> - entity group scenario and traffic case name |
| // |
| // Return Value: |
| // integer - the index in v_EPTF_ExecCtrl_StartStopTCDisable of the enable data |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getStartStopTCIdx(in EPTF_ExecCtrl_TCName pl_tcIdName) runs on EPTF_ExecCtrl_CT return integer { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_StartStopTCDisable); i<size;i:=i+1) { |
| if (v_EPTF_ExecCtrl_StartStopTCDisable[i].tcIdName == pl_tcIdName) { |
| return i; |
| } |
| } |
| return -1; // not found |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startScenarioOnLGensByName |
| // |
| // Purpose: |
| // Start a scenario on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_eGrpName - *in charstring* - the entityGroup name |
| // - pl_scenName - *in charstring* - the scenarioName |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // Avoid using this function! It uses hashMap to find the scenario index. |
| // Kept for backward compatibility. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startScenarioOnLGensByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scenName) |
| runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scenName); |
| if(vl_scIdx == -1){ |
| f_EPTF_ExecCtrl_error(%definitionId&": Cannot find scenario "&pl_scenName&" of entity group "&pl_eGrpName&" in database."); |
| } |
| |
| f_EPTF_ExecCtrl_startScenarioOnLGens(vl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startScenarioOnLGens |
| // |
| // Purpose: |
| // Start a scenario on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startScenarioOnLGens( |
| in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| |
| f_EPTF_ExecCtrl_resetGroupFinishDataForSc(pl_scIdx); |
| |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("Sending start scenario to LGen (", v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef, ") ", |
| v_ExecCtrl_lgens[vl_lgenIdx].name, " for scenario (grp / scenName): ", vl_eGrpName, " / ", vl_scenName)); |
| } |
| |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_StartScenario:{ eGrpName := vl_eGrpName, scenarioName := vl_scenName}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopScenarioOnLGensByName |
| // |
| // Purpose: |
| // Stops a scenario on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_eGrpName - *in charstring* - the entityGroup name |
| // - pl_scenName - *in charstring* - the scenarioName |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // Avoid using this function! It uses hashMap to find the scenario index. |
| // Kept for backward compatibility. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopScenarioOnLGensByName( |
| in charstring pl_eGrpName, |
| in charstring pl_scenName) |
| runs on EPTF_ExecCtrl_CT |
| { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scenName); |
| if(vl_scIdx == -1){ |
| f_EPTF_ExecCtrl_error(%definitionId&": Cannot find scenario "&pl_scenName&" of entity group "&pl_eGrpName&" in database."); |
| } |
| |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(vl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopScenarioOnLGens |
| // |
| // Purpose: |
| // Stops a scenario on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopScenarioOnLGens( |
| in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_StopScenario:{eGrpName := vl_eGrpName,scenarioName := vl_scenName}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_resetScenarioOnLGens |
| // |
| // Purpose: |
| // Reset a scenario on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid gropus and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_resetScenarioOnLGens( |
| in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_resetScenarioOnLGens_private(pl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopScenarioGroupOnLGens |
| // |
| // Purpose: |
| // Stops a scenario group on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scGrpIdx - *in integer* - the scenario group index |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopScenarioGroupOnLGens(in integer pl_scGrpIdx) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_ScenarioGroup_stopExecution(pl_scGrpIdx); |
| for (var integer i:=0, size := sizeof(v_ExecCtrl_ScenarioGroupInstanceDB.data[pl_scGrpIdx].scenarios); i<size; i:=i+1) { |
| var integer vl_scIdx := v_ExecCtrl_ScenarioGroupInstanceDB.data[pl_scGrpIdx].scenarios[i].idx; |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(vl_scIdx); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startTCOnLGens |
| // |
| // Purpose: |
| // Start a traffic case on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - index of the traffic case in <EPTF_ExecCtrl_ScenarioList>[pl_scIdx].scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_startTCOnLGens( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| |
| f_EPTF_ExecCtrl_resetGroupFinishDataForTc(v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[pl_tcOfScIdx]); |
| |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("Sending start traffic case to LGen (", v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_lgenIdx].name)); |
| |
| f_EPTF_ExecCtrl_debug(log2str("TC desc (grp / scenName / TcName): ", vl_eGrpName, " / ", vl_scenName, " / ", vl_tcName)); |
| } |
| |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_StartTrafficCase:{ eGrpName := vl_eGrpName, scenName := vl_scenName, tcName := vl_tcName}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_stopTCOnLGens |
| // |
| // Purpose: |
| // Stop a traffic case on ExecCtrlClient/LGen |
| // |
| // Parameters: |
| // - pl_scIdx - *in integer* - the scenario index in <EPTF_ExecCtrl_ScenarioList> |
| // - pl_tcOfScIdx - *in integer* - index of the traffic case in <EPTF_ExecCtrl_ScenarioList>[pl_scIdx].scData.tcList |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and scenarios |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_stopTCOnLGens( |
| in integer pl_scIdx, |
| in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[pl_scIdx].scData.name; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[pl_scIdx].scData,pl_tcOfScIdx) |
| |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("Sending start traffic case to LGen (", v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_lgenIdx].name)); |
| |
| f_EPTF_ExecCtrl_debug(log2str("TC desc (grp / scenName / TcName): ", vl_eGrpName, " / ", vl_scenName, " / ", vl_tcName)); |
| } |
| |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_StopTrafficCase:{ eGrpName := vl_eGrpName, scenName := vl_scenName, tcName := vl_tcName}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_singleShotTc |
| // |
| // Purpose: |
| // Start a traffic case on ExecCtrlClient/LGen only for one entity (single shot) |
| // |
| // Parameters: |
| // - pl_tcIdx - *in integer* - the traffic case instance index in <EPTF_ExecCtrl_TrafficCaseList> |
| // - pl_eIdx - *in integer* - index of the entity in the entity group relative to the EGrp offset (-1 for auto selection, default) |
| // - pl_enableLog - *in boolean* - true if logging should be enabled for the singleShot (default: false) |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - the specified indexes should point to valid groups and traffic case |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_singleShotTc( |
| in integer pl_tcIdx, |
| in integer pl_eIdx := -1, |
| in boolean pl_enableLog := false) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid tc index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScenarioIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| |
| var charstring vl_eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring vl_scenName := v_ExecCtrl_scenarios[vl_scIdx].scData.name; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScenarioIdx); |
| var integer vl_eOffsetOfLGen; |
| |
| // check if pl_eIdx is below the entity group size: |
| if(pl_eIdx!=-1 and pl_eIdx>=v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount) { |
| f_EPTF_ExecCtrl_warning(log2str("Cannot start singleShot on entity group ",vl_eGrpName&" for scenario "&vl_scenName&" and traffic case "&vl_tcName, |
| ": The entity index ",pl_eIdx, " is out of range. Should be in the range [0..", v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount-1,"]")); |
| return; |
| } |
| |
| // find the LGen that contains the entity: |
| var integer vl_selectedLGenIdx := -1; // invalid |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) |
| { |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| |
| if (pl_eIdx==-1) { |
| vl_selectedLGenIdx := vl_lgenIdx; |
| vl_eOffsetOfLGen := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eOffset; |
| break; // automatically select the first available LGen |
| } |
| |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eOffset>pl_eIdx and vl_selectedLGenIdx==-1) { |
| // cannot find the LGen |
| f_EPTF_ExecCtrl_debug(log2str("Cannot find the LGen (LGen offset is greater than ", pl_eIdx)); |
| break; // this LGen is the first that is allocated above pl_eIdx => previous LGen is The One |
| } |
| // if LGen contains the entity: |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eOffset+v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount>pl_eIdx) { |
| vl_selectedLGenIdx := vl_lgenIdx; // this LGen contains the entity |
| f_EPTF_ExecCtrl_debug(log2str("The LGen to start singleShot for the entity at ",pl_eIdx, " is: (", v_ExecCtrl_lgens[vl_selectedLGenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_selectedLGenIdx].name)); |
| vl_eOffsetOfLGen := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eOffset; |
| break; |
| } |
| } // lgenidx |
| |
| if (vl_selectedLGenIdx==-1) { |
| f_EPTF_ExecCtrl_warning(log2str("Cannot start singleShot on entity group ",vl_eGrpName&" for scenario "&vl_scenName&" and traffic case "&vl_tcName, |
| ": Unable to find the LGen that contains the entity at index ",pl_eIdx)); |
| return; |
| } |
| |
| if(c_EPTF_Common_debugSwitch) { |
| f_EPTF_ExecCtrl_debug(log2str("Sending singleShot of traffic case to LGen (", v_ExecCtrl_lgens[vl_selectedLGenIdx].lgenCompRef, "): ", |
| v_ExecCtrl_lgens[vl_selectedLGenIdx].name)); |
| |
| f_EPTF_ExecCtrl_debug(log2str("TC desc (grp / scenName / TcName): ", vl_eGrpName, " / ", vl_scenName, " / ", vl_tcName)); |
| } |
| |
| var integer vl_eIdx := pl_eIdx; |
| if (pl_eIdx!=-1) { |
| vl_eIdx:=pl_eIdx-vl_eOffsetOfLGen; // remove the offset of the LGen: gives eIdx on LGen |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_SingleShotTc:{ |
| eGrpName := vl_eGrpName, scName := vl_scenName, tcName := vl_tcName, |
| eIdx := vl_eIdx, |
| enableLog := pl_enableLog |
| }) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_selectedLGenIdx].lgenCompRef); |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkScenarioStatus |
| // |
| // Purpose: |
| // Check if the execution state of a specified scenario is consistent |
| // in all LGens |
| // |
| // Parameters: |
| // - pl_idName - *in* <EPTF_ExecCtrl_TCName> - the regulated item ID |
| // - pl_status - *in template charstring* - the desired state |
| // |
| // Return Value: |
| // *boolean* - true, if the execution state of a scenario matches the specifid state |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_checkScenarioStatus(in EPTF_ExecCtrl_SCName pl_idName, in template charstring pl_status) runs on EPTF_ExecCtrl_CT return boolean |
| { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started"); |
| |
| var charstring vl_currentName := "ExecCtrl.scenarioStatus."&pl_idName.eGrpName&"."&pl_idName.scName; |
| var integer vl_idx := f_EPTF_Var_getId(vl_currentName); |
| if (vl_idx == -1) { |
| return false; |
| } |
| var EPTF_StatusLED vl_status := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| var charstring vl_scenStatus := vl_status.text; |
| if (not match(vl_scenStatus, pl_status)) { |
| return false; |
| } |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkAllScenarios |
| // |
| // Purpose: |
| // Check all scenarios in ExecCtrl |
| // |
| // Parameters: |
| // Scenario status set as a charstring template |
| // |
| // Return Value: |
| // boolean - true if all statuses match the the set |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Check all scenarios in ExecCtrl whether they are |
| // in a status set or not |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_checkAllScenarios(in template charstring pl_scenarioStatus) runs on EPTF_ExecCtrl_CT return boolean |
| { |
| var boolean vl_verdict := true; |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_scenarios); sc<size and vl_verdict==true; sc:=sc+1) { |
| f_EPTF_ExecCtrl_debug(%definitionId&": Checking scenario status"); |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[sc].eGroupIdx; |
| var charstring eGrpName := v_ExecCtrl_entityGroups[vl_eGrpIdx].name; |
| var charstring scenName := v_ExecCtrl_scenarios[sc].scData.name; |
| |
| if (f_EPTF_ExecCtrl_checkScenarioStatus({ |
| eGrpName := eGrpName, |
| scName := scenName |
| }, |
| pl_scenarioStatus)) |
| { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is in a status: ",pl_scenarioStatus)); |
| } |
| else { |
| f_EPTF_ExecCtrl_debug(log2str( |
| "Scenario: {", eGrpName, |
| ", ", scenName, |
| " is NOT in a status: ",pl_scenarioStatus)); |
| vl_verdict := false; |
| } |
| } |
| return vl_verdict; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_scenarioEnabled |
| // |
| // Purpose: |
| // Checks if the scenario is enabled |
| // |
| // Parameters: |
| // pl_scIdx - *in integer* - scenario index |
| // |
| // Return Value: |
| // boolean |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // For non-weighted scenarios it returned true always in R2. |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_scenarioEnabled(in integer pl_scIdx) runs on EPTF_ExecCtrl_CT return boolean { |
| // FIXME: shall non-weighted scenarios be always enabled? This is how it was in R2! |
| return v_ExecCtrl_scenarios[pl_scIdx].scData.enabled; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Altstep: as_EPTF_ExecCtrl_MgmtIf_groupFinished |
| // |
| // Purpose: |
| // Receive groupFinished from ExecCtrlClient |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private altstep as_EPTF_ExecCtrl_MgmtIf_groupFinished() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrlClient_CT vl_sender; |
| var EPTF_ExecCtrlClient_GroupFinished v_msg; |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrlClient_GroupFinished:?) -> value v_msg sender vl_sender { |
| f_EPTF_ExecCtrl_debug("DEBUG: EPTF_ExecCtrlClient_GroupFinished received..."); |
| // find lgenIdx for pl_LGenCompRef |
| var integer vl_lgenIdx := f_EPTF_ExecCtrl_getLGenIdx(int2str(f_EPTF_Base_upcast(vl_sender))); |
| f_EPTF_ExecCtrl_handleGroupFinished(vl_lgenIdx,v_msg.tcId,v_msg.condition,v_msg.thresholds); |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_handleGroupFinished |
| // |
| // Purpose: |
| // Registers the groupFinish event received from the LGen, notifies all LGens if necessary |
| // |
| // Parameters: |
| // - pl_lgenIdx - *in integer* - LGen Idx in v_ExecCtrl_lgens |
| // - pl_tcIdx - *in integer* - the tc Idx |
| // - pl_condition - *in* <EPTF_LGenBase_ConditionTrue> - cause of group finish (true for those that are fired) |
| // - pl_currentCounters - *in* <EPTF_IntegerList> - the current value of the onGroupFinishCounters for the conditions fired |
| // |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_handleGroupFinished( |
| in integer pl_lgenIdx, |
| in EPTF_ExecCtrl_TCName pl_tcId, |
| in EPTF_LGenBase_ConditionTrue pl_condition, |
| in EPTF_IntegerList pl_currentCounters |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_tcId.eGrpName,pl_tcId.scName,pl_tcId.tcName); |
| f_EPTF_Base_assert(%definitionId&": Invalid tc : "&pl_tcId.eGrpName&"."&pl_tcId.scName&"."&pl_tcId.tcName,-1 != vl_tcIdx); |
| // onGroupFinishCondition: |
| var EPTF_ExecCtrl_GrpFinishConditionTypes vl_grpFinishConditionTypes := f_EPTF_ExecCtrl_condition2GrpFinishConditionType(pl_condition); |
| for(var integer i:=0, size := sizeof(vl_grpFinishConditionTypes);i<size; i:=i+1) { |
| if (vl_grpFinishConditionTypes[i]==-1) { |
| continue; |
| } |
| |
| f_EPTF_ExecCtrl_handlePauseTC( |
| pl_lgenIdx := pl_lgenIdx, |
| pl_tcId := pl_tcId, |
| pl_grpFinishConditionType := vl_grpFinishConditionTypes[i], |
| pl_currentCounters := pl_currentCounters |
| ); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_checkGroupFinishForAllLGensGuard( |
| in EPTF_ScheduledAction pl_action, |
| in integer pl_eventIndex |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| var integer vl_tcIdx := pl_action.actionId[0]; |
| var integer vl_groupFinishConditionType := pl_action.actionId[1]; |
| |
| var integer vl_currentCounterSum; |
| if (f_EPTF_ExecCtrl_checkIfAllLGensArePaused(vl_tcIdx,vl_groupFinishConditionType,vl_currentCounterSum)) { |
| // if all LGens are paused (e.g. other group finish condition was detected on the running LGen, => all LGen became paused) |
| // simulate a pause for this condition and call the f_EPTF_ExecCtrl_handlePauseTC to "register" it |
| |
| var integer vl_lgenIdx := 0; //simulate pause for the 0-th LGen |
| |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[vl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var integer vl_lgenIdxInEGrp := f_EPTF_ExecCtrl_getLGenIdxInEGrpForLGenAndEgrp(vl_lgenIdx,vl_eGrpIdx); |
| |
| var EPTF_IntegerList vl_counters := {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; |
| // use the current counters of the selected LGen: |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx ] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx][vl_lgenIdxInEGrp].currentCounter; |
| } |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx][vl_lgenIdxInEGrp].currentCounter; |
| } |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofFailIdx][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinishNofFailIdx] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofFailIdx][vl_lgenIdxInEGrp].currentCounter; |
| } |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx][vl_lgenIdxInEGrp].currentCounter; |
| } |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofErrorIdx][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinishNofErrorIdx] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofErrorIdx][vl_lgenIdxInEGrp].currentCounter; |
| } |
| if (isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinish_RangeLoops][vl_lgenIdxInEGrp].currentCounter)) { |
| vl_counters[c_EPTF_ExecCtrl_groupFinish_RangeLoops] := v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinish_RangeLoops][vl_lgenIdxInEGrp].currentCounter; |
| } |
| |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[vl_tcIdx].tcOfScenarioIdx; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx) |
| var EPTF_ExecCtrl_TCName vl_tcId := { |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| v_ExecCtrl_scenarios[vl_scIdx].scData.name, |
| vl_tcName |
| } |
| f_EPTF_ExecCtrl_handlePauseTC( |
| pl_lgenIdx := vl_lgenIdx, |
| pl_tcId := vl_tcId, |
| pl_grpFinishConditionType := vl_groupFinishConditionType, |
| pl_currentCounters := vl_counters |
| ); |
| } else { |
| // send pause to all LGens that did not finish to pause the traffic case |
| f_EPTF_ExecCtrl_sendPauseTCToAllClients(vl_tcIdx, vl_groupFinishConditionType); |
| } |
| |
| // if all LGens are paused: |
| // request the current counters |
| // redistribute the remaining counters and calculate the updated condition counters |
| // send groupFinished==false to LGens to restart the traffic case |
| |
| v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[vl_groupFinishConditionType] := -1; |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_sendGroupFinishedToAllClients |
| // |
| // Purpose: |
| // Sends groupFinished notification to all LGens |
| // |
| // Parameters: |
| // - pl_tcIdx - *in integer* - the tc Idx |
| // - pl_cause - *in* <EPTF_LGenBase_finishCallbackCause> - cause of group finish |
| // - local - *in boolean* - true if local, false if global evaluated group finish condition |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_sendGroupFinishedToAllClients( |
| in integer pl_tcIdx, |
| in EPTF_LGenBase_ConditionTrue pl_condition, |
| in EPTF_ExecCtrl_OnGroupFinish_LGenStatusList pl_newLimits := {} |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx) |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| var EPTF_ExecCtrl_TCName vl_tcId := { |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| v_ExecCtrl_scenarios[vl_scIdx].scData.name, |
| vl_tcName |
| } |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| var integer vl_newThreshold := -1; |
| if (sizeof(pl_newLimits)>0) { |
| vl_newThreshold := pl_newLimits[lgenidx].currentCounter; |
| f_EPTF_Base_assert("LGen Index does not match", pl_newLimits[lgenidx].lgenIdx == vl_lgenIdx); |
| } |
| var EPTF_IntegerList vl_newThresholds := {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}; |
| var EPTF_ExecCtrl_GrpFinishConditionTypes vl_conditionTypes := f_EPTF_ExecCtrl_condition2GrpFinishConditionType(pl_condition); |
| for(var integer i:=0;i<sizeof(vl_conditionTypes); i:=i+1) { |
| vl_newThresholds[vl_conditionTypes[i]] := vl_newThreshold; |
| } |
| if (pl_condition.anythingFinished |
| or vl_newThreshold != v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[vl_conditionTypes[0]][lgenidx]) { |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrlClient_GroupFinished : {vl_tcId,pl_condition, vl_newThresholds}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| //reset groupFinish.conditionStatus for this LGen for all conditions when LGen resumes the traffic case execution (all conditions are updated) |
| |
| if (pl_condition.anythingFinished) { |
| // add current condition (LGen remains paused): |
| f_EPTF_ExecCtrl_accumulateConditions(pl_condition, v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.groupFinishedPerLGen[lgenidx]); |
| } else { |
| // clear current condition (condition is updated): |
| f_EPTF_ExecCtrl_clearGroupFinishConditionFired(pl_condition,v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.groupFinishedPerLGen[lgenidx]); |
| } |
| if(not pl_condition.anythingFinished |
| and not f_EPTF_ExecCtrl_checkGroupFinishConditionFired(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.groupFinishedPerLGen[lgenidx])) { |
| // if no more condition remains and condition is not fulfilled (LGen resumes): |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofExecStartIdx],lgenidx); |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofSuccessIdx],lgenidx); |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofFailIdx],lgenidx); |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx],lgenidx); |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinishNofErrorIdx],lgenidx); |
| f_EPTF_ExecCtrl_deleteItem(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[c_EPTF_ExecCtrl_groupFinish_RangeLoops],lgenidx); |
| } |
| } else { |
| // threshold for this condition was not changed => LGen remains paused, |
| // leave the groupFinish.conditionStatus for this LGen for all conditions on the previous value |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_deleteItem(inout EPTF_ExecCtrl_OnGroupFinish_LGenStatusList pl_lgenStatusList, in integer pl_lgenIdx) { |
| var EPTF_ExecCtrl_OnGroupFinish_LGenStatusList vl_lgenStatusList; |
| for (var integer i:=0; i<sizeof(pl_lgenStatusList); i:=i+1) { |
| if (i==pl_lgenIdx) { |
| continue; |
| } |
| if(isbound(pl_lgenStatusList[i])) { |
| vl_lgenStatusList[i] := pl_lgenStatusList[i]; |
| } |
| } |
| if(isbound(vl_lgenStatusList)) { |
| pl_lgenStatusList := vl_lgenStatusList; |
| } else { |
| pl_lgenStatusList := {}; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_clearGroupFinishConditionFired |
| // |
| // Purpose: |
| // Clears the finish conditions given in the pl_source from pl_dest |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_clearGroupFinishConditionFired( |
| in EPTF_LGenBase_ConditionTrue pl_source, |
| inout EPTF_LGenBase_ConditionTrue pl_dest |
| ) { |
| pl_dest.nrOfExecStart := pl_dest.nrOfExecStart and pl_dest.nrOfExecStart xor pl_source.nrOfExecStart; |
| pl_dest.nrOfSuccesses := pl_dest.nrOfSuccesses and pl_dest.nrOfSuccesses xor pl_source.nrOfSuccesses |
| pl_dest.nrOfFails := pl_dest.nrOfFails and pl_dest.nrOfFails xor pl_source.nrOfFails |
| pl_dest.nrOfErrors := pl_dest.nrOfErrors and pl_dest.nrOfErrors xor pl_source.nrOfErrors |
| pl_dest.nrOfTimeouts := pl_dest.nrOfTimeouts and pl_dest.nrOfTimeouts xor pl_source.nrOfTimeouts |
| pl_dest.nrOfRangeLoop := pl_dest.nrOfRangeLoop and pl_dest.nrOfRangeLoop xor pl_source.nrOfRangeLoop |
| pl_dest.execTime := pl_dest.execTime and pl_dest.execTime xor pl_source.execTime |
| pl_dest.entitiesFinished := pl_dest.entitiesFinished and pl_dest.entitiesFinished xor pl_source.entitiesFinished |
| pl_dest.availableEntitiesFinished := pl_source.availableEntitiesFinished and pl_source.availableEntitiesFinished xor pl_source.availableEntitiesFinished |
| pl_dest.customFinishCondition := pl_dest.customFinishCondition and pl_dest.customFinishCondition xor pl_source.customFinishCondition |
| pl_dest.anythingFinished := pl_dest.anythingFinished and pl_dest.anythingFinished xor pl_source.anythingFinished |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkGroupFinishConditionFired |
| // |
| // Purpose: |
| // Checks if any of the finish conditions given in the pl_source are true |
| // Ignores anythingFinished |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_checkGroupFinishConditionFired( |
| 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_ExecCtrl_accumulateConditions |
| // |
| // Purpose: |
| // Accumulates the finish conditions given in the pl_newConditionsDetected to pl_dest |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_accumulateConditions( |
| in EPTF_LGenBase_ConditionTrue pl_newConditionsDetected, |
| inout EPTF_LGenBase_ConditionTrue pl_dest |
| ) { |
| if(not isbound(pl_dest)) { |
| pl_dest := pl_newConditionsDetected; |
| } else { |
| // accumulate the flags: |
| f_EPTF_ExecCtrl_setGroupFinishConditionFired(pl_newConditionsDetected,pl_dest); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setGroupFinishConditionFired |
| // |
| // Purpose: |
| // Registers the finish conditions fired |
| // (Copy of f_EPTF_LGenBase_setGroupFinishConditionFired) |
| /////////////////////////////////////////////////////////// |
| friend function f_EPTF_ExecCtrl_setGroupFinishConditionFired( |
| in EPTF_LGenBase_ConditionTrue pl_source, |
| inout EPTF_LGenBase_ConditionTrue pl_dest) |
| { |
| 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_ExecCtrl_sendPauseTCToAllClients |
| // |
| // Purpose: |
| // Sends pause TC request to all LGens |
| // |
| // Parameters: |
| // - pl_tcIdx - *in integer* - the tc Idx |
| // - pl_groupFinishConditionType - *in* <EPTF_ExecCtrl_GrpFinishConditionType> - the type of the evaluated group finish condition |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_sendPauseTCToAllClients( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_groupFinishConditionType |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScIdx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,vl_tcOfScIdx) |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| if (isbound(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[pl_groupFinishConditionType][lgenidx])) { |
| continue; // already paused |
| } |
| var EPTF_ExecCtrl_TCName vl_tcId := { |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| v_ExecCtrl_scenarios[vl_scIdx].scData.name, |
| vl_tcName |
| } |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrlClient_PauseTC : {vl_tcId,pl_groupFinishConditionType,{}}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| // accumulate condition for LGen: |
| var EPTF_LGenBase_ConditionTrue vl_condition := f_EPTF_ExecCtrl_grpFinishConditionType2Condition(pl_groupFinishConditionType); |
| f_EPTF_ExecCtrl_accumulateConditions(vl_condition, v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.groupFinishedPerLGen[lgenidx]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Altstep: as_EPTF_ExecCtrl_MgmtIf_pauseTC |
| // |
| // Purpose: |
| // Receive pauseTC from ExecCtrlClient |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private altstep as_EPTF_ExecCtrl_MgmtIf_pauseTC() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrlClient_CT vl_sender; |
| var EPTF_ExecCtrlClient_PauseTC v_msg; |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrlClient_PauseTC:?) -> value v_msg sender vl_sender { |
| f_EPTF_ExecCtrl_debug("DEBUG: EPTF_ExecCtrlClient_PauseTC received..."); |
| // find lgenIdx for pl_LGenCompRef |
| var integer vl_lgenIdx := f_EPTF_ExecCtrl_getLGenIdx(int2str(f_EPTF_Base_upcast(vl_sender))); |
| f_EPTF_ExecCtrl_handlePauseTC(vl_lgenIdx,v_msg.tcId,v_msg.conditionType,v_msg.counters); |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_handlePauseTC |
| // |
| // Purpose: |
| // Handles incoming PauseTC events from clients, |
| // redistributes the group finish threshold accoring to the current progress |
| // |
| // Parameters: |
| // - pl_lgenIdx - *in integer* - LGen Idx in v_ExecCtrl_lgens |
| // - pl_tcIdx - *in integer* - the tc Idx |
| // - pl_grpFinishConditionType - *in* <EPTF_ExecCtrl_GrpFinishConditionType> - the type of the evaluated group finish condition |
| // - pl_currentCounters - *in* <EPTF_IntegerList> - the counters of all group finish conditions |
| // |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_handlePauseTC( |
| in integer pl_lgenIdx, |
| in EPTF_ExecCtrl_TCName pl_tcId, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_grpFinishConditionType, |
| in EPTF_IntegerList pl_currentCounters |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(pl_tcId.eGrpName,pl_tcId.scName,pl_tcId.tcName); |
| f_EPTF_Base_assert(%definitionId&": Invalid tc : "&pl_tcId.eGrpName&"."&pl_tcId.scName&"."&pl_tcId.tcName,-1 != vl_tcIdx); |
| |
| |
| // find lgenIdxInEGrp for pl_lgenIdx |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[vl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| var integer vl_lgenIdxInEGrp := f_EPTF_ExecCtrl_getLGenIdxInEGrpForLGenAndEgrp(pl_lgenIdx,vl_eGrpIdx); |
| |
| var EPTF_LGenBase_ConditionTrue vl_condition := f_EPTF_ExecCtrl_grpFinishConditionType2Condition(pl_grpFinishConditionType); |
| f_EPTF_ExecCtrl_accumulateConditions(vl_condition, v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedPerLGen[vl_lgenIdxInEGrp]); |
| for(var integer i:=0; i<sizeof(pl_currentCounters); i:=i+1) { |
| if (pl_currentCounters[i]<0) { |
| continue; |
| } |
| // // backup previous data: |
| // if(isbound(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[i][vl_lgenIdxInEGrp].currentCounter)) { |
| // v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[i][vl_lgenIdxInEGrp] := |
| // v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[i][vl_lgenIdxInEGrp].currentCounter; |
| // } |
| // use vl_lgenIdxInEGrp to update the counter value in v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[pl_grpFinishConditionType] |
| v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[i][vl_lgenIdxInEGrp].lgenIdx := pl_lgenIdx; |
| v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[i][vl_lgenIdxInEGrp].currentCounter := pl_currentCounters[i]; |
| } |
| |
| |
| // if all LGens are paused: |
| var integer vl_currentCounterSum; |
| if (f_EPTF_ExecCtrl_checkIfAllLGensArePaused(vl_tcIdx,pl_grpFinishConditionType,vl_currentCounterSum)) { |
| var integer vl_threshold := f_EPTF_ExecCtrl_getThreshold(vl_tcIdx,pl_grpFinishConditionType); |
| var EPTF_ExecCtrl_OnGroupFinish_LGenStatusList vl_distributedThreshold := {}; |
| if(vl_threshold>vl_currentCounterSum) { |
| // redistribute the remaining counters and calculate the updated condition counters |
| f_EPTF_ExecCtrl_recalculateConditionLimits(vl_tcIdx,pl_grpFinishConditionType,vl_currentCounterSum,vl_threshold,vl_distributedThreshold); |
| //vl_condition:=c_EPTF_LGenBase_emptyConditionTrue |
| vl_condition.anythingFinished:=c_EPTF_LGenBase_emptyConditionTrue.anythingFinished; |
| // send anythingFinished==false to LGens to restart the traffic case => |
| // modify the group finish condition limits, condition shows which limit has to be modified |
| } else { |
| // group finished |
| //set final counter values (at group finish): |
| f_EPTF_ExecCtrl_recalculateConditionLimits(vl_tcIdx,pl_grpFinishConditionType,vl_currentCounterSum,vl_threshold,vl_distributedThreshold); |
| f_EPTF_ExecCtrl_setOnGroupFinished(vl_tcIdx,pl_grpFinishConditionType); |
| f_EPTF_ExecCtrl_callOnGroupFinishCallbackFns(vl_tcIdx,pl_grpFinishConditionType); |
| // cause.anythingFinished is true: group finish condition is fulfilled => send to all LGens to finish the traffic |
| } |
| f_EPTF_ExecCtrl_sendGroupFinishedToAllClients(vl_tcIdx,vl_condition,vl_distributedThreshold); |
| |
| // cancel guard: |
| if (v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType] != -1) { |
| f_EPTF_SchedulerComp_CancelEvent(v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType]); |
| v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType] := -1; |
| } |
| } else { |
| // start guard to check if any other LGen does not finish in time: |
| if (v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType] == -1 |
| and tsp_EPTF_ExecCtrl_GroupFinishedGuardTime > 0.0 |
| ) { |
| // start guard for these conditions: |
| // nrOfExecStart , |
| // nrOfSuccesses , |
| // nrOfFails , |
| // nrOfErrors , |
| // nrOfTimeouts |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofExecStartIdx |
| or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofSuccessIdx |
| or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofFailIdx |
| or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx |
| or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishNofErrorIdx |
| //or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_RangeLoops // this is not needed because rangeLoops are not redistributed |
| ) { |
| if(not f_EPTF_SchedulerComp_scheduleAction( |
| f_EPTF_Base_getRelTimeInSecs() + tsp_EPTF_ExecCtrl_GroupFinishedGuardTime, |
| refers(f_EPTF_ExecCtrl_checkGroupFinishForAllLGensGuard), |
| {vl_tcIdx,pl_grpFinishConditionType}, |
| v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType] |
| )) { |
| f_EPTF_ExecCtrl_error(%definitionId& ": Could not schedule group finish condition guard."); |
| } |
| } |
| // does not start guard for these (wait until they are finished on all LGens): |
| // nrOfRangeLoop , |
| // execTime , |
| // entitiesFinished , |
| // availableEntitiesFinished , |
| // customFinish |
| // condition types: |
| // c_EPTF_ExecCtrl_groupFinish_ExecTime, |
| // c_EPTF_ExecCtrl_groupFinish_RangeLoops, |
| // c_EPTF_ExecCtrl_groupFinish_EntitiesFinished, |
| // c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished, |
| // c_EPTF_ExecCtrl_groupFinish_Custom |
| } |
| } |
| |
| // v_ExecCtrl_trafficCases[vl_tcIdx].groupFinishData.onGroupFinish.groupFinishedGuardTimerId[pl_grpFinishConditionType] := -1; |
| } |
| |
| private function f_EPTF_ExecCtrl_checkIfAllLGensArePaused( |
| in integer pl_tcIdx, |
| in integer pl_grpFinishConditionType, |
| out integer pl_currentCounterSum |
| ) runs on EPTF_ExecCtrl_CT return boolean { |
| pl_currentCounterSum := 0; |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| for(var integer i:=0; i<sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); i:=i+1) { |
| // if no entities are allocated on the LGen |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[i].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| if (not isbound(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[pl_grpFinishConditionType][i])) { |
| return false; |
| } |
| pl_currentCounterSum := pl_currentCounterSum + v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[pl_grpFinishConditionType][i].currentCounter; |
| } |
| return true; |
| } |
| |
| private function f_EPTF_ExecCtrl_recalculateConditionLimits( |
| in integer pl_tcIdx, |
| in integer pl_grpFinishConditionType, |
| in integer pl_currentCounterSum, |
| in integer pl_threshold, |
| out EPTF_ExecCtrl_OnGroupFinish_LGenStatusList pl_distributedThreshold |
| ) runs on EPTF_ExecCtrl_CT { |
| var integer vl_remainingCounter := pl_threshold - pl_currentCounterSum; |
| var integer vl_toDistribute := vl_remainingCounter; |
| pl_distributedThreshold := v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatus[pl_grpFinishConditionType]; |
| |
| // use delta between previous run and the current for better estimation |
| // sum up all the counter increments: |
| var integer vl_deltaCounterSum := 0; |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| for(var integer i:=0; i<sizeof(pl_distributedThreshold);i:=i+1) { |
| var integer vl_prevCounter := 0; |
| if (isbound(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i])) { |
| vl_prevCounter := v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i]; |
| } |
| if (not isbound(pl_distributedThreshold[i])) { |
| pl_distributedThreshold[i].currentCounter := 0; |
| pl_distributedThreshold[i].lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[i].lgenIdx; |
| } |
| vl_deltaCounterSum := vl_deltaCounterSum + |
| pl_distributedThreshold[i].currentCounter - vl_prevCounter; |
| } |
| |
| // set remaining to the LGen at the random index between 0 and sizeof(pl_distributedThreshold): |
| var integer vl_remainingIdx := float2int(int2float(sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList))*rnd()); |
| |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_remainingIdx].eCountActive == 0) { |
| // if the chosen remaining LGen has no active entities: choose the first with active entities |
| vl_remainingIdx := 0; |
| } |
| for(var integer i:=0; i<sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); i:=i+1) { |
| |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[i].eCountActive == 0) { |
| if (i==vl_remainingIdx) { |
| vl_remainingIdx := vl_remainingIdx + 1; // this remaining has no active entities => choose next one |
| } |
| v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i] := 0; |
| pl_distributedThreshold[i].currentCounter := 0; |
| continue; // no active entities on this LGen |
| } |
| |
| if (not isbound(pl_distributedThreshold[i])) { |
| pl_distributedThreshold[i].currentCounter := 0; |
| pl_distributedThreshold[i].lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[i].lgenIdx; |
| } |
| |
| if (i==vl_remainingIdx) { |
| continue; // skip this, it will receive the remaining after the cycle |
| } |
| |
| var integer vl_limitIncrement |
| if (vl_deltaCounterSum==0) { |
| vl_limitIncrement := vl_remainingCounter/sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } else { |
| var integer vl_prevCounter := 0; |
| if (isbound(v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i])) { |
| vl_prevCounter := v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i]; |
| } |
| |
| if (pl_distributedThreshold[i].currentCounter==0 and vl_toDistribute>1) { |
| vl_limitIncrement := 1; // give 1 to the LGen with 0 prev threshold, but activeEntities>0 |
| } else { |
| vl_limitIncrement := (vl_remainingCounter* |
| (pl_distributedThreshold[i].currentCounter-vl_prevCounter) |
| )/vl_deltaCounterSum; |
| if (vl_limitIncrement==vl_remainingCounter and vl_limitIncrement>1) { |
| vl_limitIncrement := vl_limitIncrement - 1; |
| } |
| } |
| } |
| // backup previous values: |
| v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][i] := pl_distributedThreshold[i].currentCounter; |
| pl_distributedThreshold[i].currentCounter := pl_distributedThreshold[i].currentCounter + vl_limitIncrement; |
| vl_toDistribute := vl_toDistribute - vl_limitIncrement; |
| } |
| // backup previous values: |
| v_ExecCtrl_trafficCases[pl_tcIdx].groupFinishData.onGroupFinish.conditionStatusPrev[pl_grpFinishConditionType][vl_remainingIdx] := pl_distributedThreshold[vl_remainingIdx].currentCounter; |
| pl_distributedThreshold[vl_remainingIdx].currentCounter := pl_distributedThreshold[vl_remainingIdx].currentCounter + vl_toDistribute; |
| } |
| |
| |
| // returns the threshold value. (-1 if not available) |
| friend function f_EPTF_ExecCtrl_getThreshold( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType |
| ) |
| runs on EPTF_ExecCtrl_CT |
| return integer { |
| if (not v_ExecCtrl_initialized) { |
| return -1; // not available |
| } |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScidx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishNofExecStartIdx) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfExecStart==omit |
| ) { |
| return -1; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfExecStart.count; |
| } |
| |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishNofSuccessIdx) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfSuccesses==omit |
| ) { |
| return -1; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfSuccesses.count; |
| } |
| |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishNofFailIdx) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfFails==omit |
| ) { |
| return -1; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfFails.count; |
| } |
| |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishNofTimeoutIdx) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfTimeouts==omit |
| ) { |
| return -1; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfTimeouts.count; |
| } |
| |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishNofErrorIdx) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfErrors==omit |
| ) { |
| return -1; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfErrors.count; |
| } |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_RangeLoops) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfRangeLoop==omit |
| ) { |
| return -1; // threshold not available |
| } |
| // return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count; |
| // return the number of LGens * v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count: |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count |
| * sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } |
| |
| // these are not split: |
| // nrOfRangeLoop , |
| // execTime , |
| // entitiesFinished , |
| // availableEntitiesFinished , |
| // customFinish , |
| // anythingFinished |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_ExecTime) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.execTime==omit |
| ) { |
| return -1; // threshold not available |
| } |
| // return the number of LGens: |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| return sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_EntitiesFinished) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.entitiesFinished==omit |
| ) { |
| return -1; // threshold not available |
| } |
| // return the number of LGens: |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| return sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.availableEntitiesFinished==omit |
| ) { |
| return -1; // threshold not available |
| } |
| // return the number of LGens: |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| return sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_Custom) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.customFinish==omit |
| ) { |
| return -1; // threshold not available |
| } |
| // return the number of LGens: |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[vl_scIdx].eGroupIdx; |
| return sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); |
| } |
| // unsupported condition: |
| return -1; |
| } |
| |
| // returns the threshold value for float type contitions (e.g. execTime). (-1 if not available) |
| friend function f_EPTF_ExecCtrl_getThresholdFloat( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType |
| ) |
| runs on EPTF_ExecCtrl_CT |
| return float { |
| if (not v_ExecCtrl_initialized) { |
| return -1.0; // not available |
| } |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScidx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_ExecTime) { |
| if (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.execTime==omit |
| ) { |
| return -1.0; // threshold not available |
| } |
| return v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.execTime.time; |
| } |
| // unsupported condition: |
| return -1.0; |
| } |
| |
| // returns the threshold value for boolean type contitions (entitiesFinished, availableEntitiesFinished). (-1 if not available) |
| friend function f_EPTF_ExecCtrl_getThresholdBoolean( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType |
| ) |
| runs on EPTF_ExecCtrl_CT |
| return boolean { |
| if (not v_ExecCtrl_initialized) { |
| return false; // not available |
| } |
| var integer vl_scIdx := v_ExecCtrl_trafficCases[pl_tcIdx].scenarioIdx; |
| var integer vl_tcOfScidx := v_ExecCtrl_trafficCases[pl_tcIdx].tcOfScenarioIdx; |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_EntitiesFinished |
| or pl_conditionType==c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished) { |
| return (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.entitiesFinished!=omit) |
| or (v_ExecCtrl_scenarios[vl_scIdx].scData.tcList[vl_tcOfScidx].trafficStartFinishConditionsAndActions.availableEntitiesFinished!=omit); |
| } |
| // unsupported condition: |
| return false; |
| } |
| |
| // OnGroupFinishCallBack function to update the GroupFinishStatusLED of the traffic case on the GUI |
| private function f_EPTF_ExecCtrl_setLEDForOnGroupFinishCallBack( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType |
| ) runs on EPTF_ExecCtrl_CT { |
| |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx); |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| |
| // GroupFinishStatusLED |
| var integer vl_idx := f_EPTF_Var_getId(vl_namePrefix&".GroupFinishStatusLED"); |
| if(vl_idx!=-1) { |
| f_EPTF_ExecCtrl_debug("Updating GroupFinishStatusLED for tc: "&f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)); |
| f_EPTF_Var_adjustContent(vl_idx,{statusLEDVal := f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinish(pl_tcIdx,pl_conditionType)}); |
| } |
| // GroupFinishCondStatusLED |
| var integer vl_tcStatId := f_EPTF_ExecCtrl_grpFinishConditionType2TcStatId(pl_conditionType); |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_Custom) { |
| // do nothing with GroupFinishCondStatusLED-s |
| } else if (vl_tcStatId!=c_EPTF_ExecCtrl_tcStatId_Unknown) { |
| vl_idx := f_EPTF_Var_getId(vl_namePrefix&".GroupFinishCondStatusLED."&c_EPTF_ExecCtrl_tcStatNames[vl_tcStatId]); |
| if(vl_idx!=-1) { |
| f_EPTF_ExecCtrl_debug("Updating GroupFinishCondStatusLED for "&c_EPTF_ExecCtrl_tcStatNames[vl_tcStatId]&" for tc: "&f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)); |
| f_EPTF_Var_adjustContent(vl_idx,{statusLEDVal := f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinishCond(pl_tcIdx,pl_conditionType)}); |
| } |
| } else { |
| // reset GroupFinishCondStatusLED for all groupFinish conditions: |
| f_EPTF_ExecCtrl_debug("Updating GroupFinishCondStatusLED for all conditions in tc: "&f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)); |
| for(var integer st:=0; st<sizeof(c_EPTF_ExecCtrl_tcStatNames);st:=st+1) { |
| var EPTF_ExecCtrl_GrpFinishConditionType vl_grpFinishConditionType := f_EPTF_ExecCtrl_UIVars_tcStatId2GrpFinishConditionType(st); |
| if (vl_grpFinishConditionType == c_EPTF_ExecCtrl_groupFinishConditionUnknown) { |
| continue; // no conditions for these stats |
| } |
| vl_idx := f_EPTF_Var_getId(vl_namePrefix&".GroupFinishCondStatusLED."&c_EPTF_ExecCtrl_tcStatNames[st]); |
| if(vl_idx!=-1) { |
| var EPTF_StatusLED vl_currentLED := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| if (vl_currentLED.color==led_blue or (vl_currentLED == c_EPTF_ExecCtrl_UIVars_GroupFinishCondStatusLED_init)) { |
| continue; // led is blue or condition is not monitored |
| } |
| f_EPTF_ExecCtrl_debug("Updating GroupFinishCondStatusLED for "&c_EPTF_ExecCtrl_tcStatNames[st]&" for tc: "&f_EPTF_ExecCtrl_getTrafficCaseName(pl_tcIdx)); |
| f_EPTF_Var_adjustContent(vl_idx,{statusLEDVal := f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinishCond(pl_tcIdx,vl_grpFinishConditionType)}); |
| } |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_grpFinishConditionType2TcStatId( |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_grpFinishConditionType |
| ) return EPTF_ExecCtrl_TcStatId { |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinishConditionUnknown) { |
| return c_EPTF_ExecCtrl_tcStatId_Unknown; |
| } |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_RangeLoops) { |
| return c_EPTF_ExecCtrl_tcStatId_RangeLoops; |
| } |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_EntitiesFinished |
| or pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished) { |
| return c_EPTF_ExecCtrl_tcStatId_FinTraffic; |
| } |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_ExecTime) { |
| return c_EPTF_ExecCtrl_tcStatId_ExecTime; |
| } |
| if (pl_grpFinishConditionType==c_EPTF_ExecCtrl_groupFinish_Custom) { |
| return c_EPTF_ExecCtrl_tcStatId_Unknown; // no stat for custom |
| } |
| // the rest are in the same order: simply adding the offset of Starts works: |
| return pl_grpFinishConditionType + c_EPTF_ExecCtrl_tcStatId_Starts; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Altstep: as_EPTF_ExecCtrl_MgmtIf |
| // |
| // Purpose: |
| // Management interface handler of EPTF_ExecCtrl feature |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| private altstep as_EPTF_ExecCtrl_MgmtIf() runs on EPTF_ExecCtrl_CT |
| { |
| |
| // [] as_EPTF_ExecCtrl_MgmtIf_ExecStatus() { repeat;} |
| [] as_EPTF_ExecCtrl_MgmtIf_handleLoadConfig(); |
| [] as_EPTF_ExecCtrl_MgmtIf_groupFinished(); |
| [] as_EPTF_ExecCtrl_MgmtIf_pauseTC(); |
| [] as_EPTF_ExecCtrl_MgmtIf_handleEntityResourceInfo(); |
| [] as_EPTF_ExecCtrl_MgmtIf_handlePhaseMsgs(); |
| [] as_EPTF_ExecCtrl_MgmtIf_handleReadytoRun(); |
| [] as_EPTF_ExecCtrl_MgmtIf_handleCreateFSMStats(); |
| [] as_EPTF_ExecCtrl_MgmtIf_handleByeMsgs(); |
| [] as_EPTF_ExecCtrl_handleAllLGensCreated(); |
| [] as_EPTF_ExecCtrl_handleEofTest(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_behavior |
| // |
| // Purpose: |
| // Main behavior of EPTF_ExecCtrl feature |
| // |
| // Parameters: |
| // - pl_selfName - *in charstring* - the name of the component |
| // - pl_nrOfClients - *in integer* - the number of the connected EPTF_ExecCtrlClient components |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_behavior( |
| in charstring pl_selfName, |
| in integer pl_nrOfClients |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| // f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| //f_EPTF_ExecCtrl_loadConfig(pl_EPTF_ExecCtrl_LGenFunction_Entry_List := p_fn_list); |
| f_EPTF_ExecCtrl_init_CT(pl_selfName, pl_nrOfClients); |
| |
| f_EPTF_Base_wait4Shutdown(); // main alt-loop |
| |
| // f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| } // group EPTF_ExecCtrl |
| |
| /////////////////////////////////////////////////////////// |
| // Group: R3 |
| // |
| // Purpose: |
| // Functions introduced in the R3 release |
| // |
| /////////////////////////////////////////////////////////// |
| group R3 { |
| |
| /////////////////////////////////////////////////////////// |
| // Type: EPTF_ExecCtrl_Condition_FN |
| // |
| // Purpose: |
| // General function that check a condition |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // boolean - True if condition is fulfilled, false otherwise |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Used by <f_EPTF_ExecCtrl_waitForCondition> |
| // |
| /////////////////////////////////////////////////////////// |
| type function EPTF_ExecCtrl_Condition_FN() runs on self return boolean; |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_waitForCondition |
| // |
| // Purpose: |
| // general function to wait for any condition (until the conditionFn returns true) |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Can be used in alt statements to wake up when the condition is true |
| // The user can block execution until a given event (=the event when the condition reported |
| // by the pl_condFn becomes true) by calling this function. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_waitForCondition(in EPTF_ExecCtrl_Condition_FN pl_condFn) { |
| timer t_wait := 0.0; |
| t_wait.start; |
| alt { |
| [pl_condFn!=null and pl_condFn.apply()] t_wait.timeout; |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkReadyToRun |
| // |
| // Purpose: |
| // Returns true when ExecCtrl is readyToRun |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // boolean - true if the ReadyToRun event in ExecCtrl occurs |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // Can be used in alt statements to wake up when ExecCtrl is readyToRun |
| // Usage: If the user would like a callback to the event when all ExecCtrlClients reported |
| // ReadyToRun, this is what he should do: |
| // Write the following altstep: |
| // altstep as_My_ReadyToRunCallBack () runs on My_ExcCtrl_Extending_CT { |
| // [f_EPTF_ExecCtrl_checkReadyToRun()] t_my_ExecCtrl_ReadyToRun.timeout { |
| // // User handler functions to call: |
| // f_My_ReadyToRunCallBack_handler(); |
| // } |
| // } |
| // Then in the init function of My_ExcCtrl_Extending_CT put this code: |
| // t_my_ExecCtrl_ReadyToRun.start(0.0); // this timer should be declared inside My_ExcCtrl_Extending_CT |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_checkReadyToRun() |
| runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| return v_ExecCtrl_readyToRun; |
| } |
| |
| |
| group EntityGroupCreation { |
| |
| private function f_EPTF_ExecCtrl_checkPendingMsgs() |
| runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| // Since the f_EPTF_ExecCtrl_updateProgressbar sends a message to the uihandler => if uihandlerCT=execCtrlCT, it generates infinite loop |
| //f_EPTF_ExecCtrl_updateProgressbar(10.0/int2float((sizeof(v_ExecCtrl_lgens)+1)*(sizeof(v_ExecCtrl_scenarios)+sizeof(v_ExecCtrl_trafficCases)+1))); // random noise (max 10%) |
| return (v_ExecCtrl_pendingMsgCounter==0); |
| } |
| |
| |
| // returns the number of LGens the EGrp is distributed on (does not count LGens with eCount==0) |
| private function f_EPTF_ExecCtrl_getNofLGensForEGrp(in integer pl_eGrpIdx) |
| runs on EPTF_ExecCtrl_CT return integer { |
| var integer vl_lgenNum := 0; |
| for(var integer i:=0, size := sizeof(v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList); i<size; i:=i+1) { |
| if (v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].eCount==0) { |
| continue; // eGrp is not created on the LGen |
| } |
| vl_lgenNum := vl_lgenNum + 1; |
| } |
| return vl_lgenNum; |
| } |
| |
| private function f_EPTF_ExecCtrl_getCurrentLGenNumForEGrp(in integer pl_lgenIdx, in integer pl_eGrpIdx) |
| runs on EPTF_ExecCtrl_CT return integer { |
| var integer vl_currentLGenNum := -1; // first LGen will get 0 |
| for(var integer i:=0, size := sizeof(v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList); i<size; i:=i+1) { |
| if (v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].eCount==0) { |
| continue; // eGrp is not created on the LGen |
| } |
| vl_currentLGenNum := vl_currentLGenNum + 1; |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].lgenIdx; |
| if (vl_lgenIdx==pl_lgenIdx) { |
| return vl_currentLGenNum; |
| } |
| } |
| return -1; |
| } |
| |
| // creates the Entity Group on the LGens |
| private function f_EPTF_ExecCtrl_createEntityGroupOnLGens(in integer pl_eGrpIdx) |
| runs on EPTF_ExecCtrl_CT { |
| f_EPTF_Base_assert(%definitionId&": Invalid eGrp index "&int2str(pl_eGrpIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_entityGroups))&").", |
| pl_eGrpIdx >= 0 and pl_eGrpIdx < sizeof(v_ExecCtrl_entityGroups)); |
| |
| var EPTF_ExecCtrl_CreateEntityGrp vl_createEGrp; |
| v_ExecCtrl_pendingMsgCounter := 0; |
| var integer vl_totalLGenNum := f_EPTF_ExecCtrl_getNofLGensForEGrp(pl_eGrpIdx); |
| var integer vl_currentLGenNum := -1; // first LGen will get 0 |
| for(var integer i:=0, size := sizeof(v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList); i<size; i:=i+1) { |
| if (v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].eCount==0) { |
| continue; // eGrp is not created on the LGen |
| } |
| vl_currentLGenNum := vl_currentLGenNum + 1; |
| vl_createEGrp := { |
| name := v_ExecCtrl_entityGroups[pl_eGrpIdx].name, |
| eType := v_ExecCtrl_entityGroups[pl_eGrpIdx].eType, |
| gOffset := v_ExecCtrl_entityGroups[pl_eGrpIdx].eOffset, |
| gCount := v_ExecCtrl_entityGroups[pl_eGrpIdx].eCount, |
| eOffset := v_ExecCtrl_entityGroups[pl_eGrpIdx].eOffset+v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].eOffset, |
| eCount := v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].eCount, |
| trafficCorrigation := int2float(vl_currentLGenNum)/int2float(vl_totalLGenNum) |
| } |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[pl_eGrpIdx].lgenList[i].lgenIdx; |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_CreateEntityGrp:vl_createEGrp) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter + 1; |
| } |
| if (v_ExecCtrl_pendingMsgCounter==0) { |
| f_EPTF_ExecCtrl_debug(log2str("Entity Group ",v_ExecCtrl_entityGroups[pl_eGrpIdx].name, " is not created on any LGen.")); |
| return; // this return is not necessary but prevents the printout at the end |
| } |
| // wait until resource info is received from all LGens: |
| var EPTF_ExecCtrl_Condition_FN vl_checkPending := refers(f_EPTF_ExecCtrl_checkPendingMsgs); |
| f_EPTF_ExecCtrl_waitForCondition(vl_checkPending); |
| // timer t_wait := 1e-6; |
| // t_wait.start; |
| // alt { |
| // [v_ExecCtrl_pendingMsgCounter==0] t_wait.timeout; |
| // } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Entity Group ",v_ExecCtrl_entityGroups[pl_eGrpIdx].name, " is created on LGens.")); |
| } |
| |
| // creates all Entity Groups with the given eType on the LGen |
| // returns true if entity groups were created, false if not |
| private function f_EPTF_ExecCtrl_createEntityGroupsOnLGen(in integer pl_lgenIdx,in charstring pl_eType) |
| runs on EPTF_ExecCtrl_CT |
| return boolean { |
| f_EPTF_Base_assert(%definitionId&": Invalid LGen index "&int2str(pl_lgenIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_lgens))&").", |
| pl_lgenIdx >= 0 and pl_lgenIdx < sizeof(v_ExecCtrl_lgens)); |
| |
| var EPTF_ExecCtrl_CreateEntityGrpList vl_createEGrpList := {}; |
| // go through all eGroups of this LGen: |
| for(var integer e:=0, size := sizeof(v_ExecCtrl_lgens[pl_lgenIdx].eGroups); e<size; e:=e+1) { |
| var integer vl_eGrpIdx := v_ExecCtrl_lgens[pl_lgenIdx].eGroups[e].eGrpIdx; |
| // Process only those groups that have the given eType: |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].eType != pl_eType) { |
| continue; |
| } |
| // the Idx of the lgen entry in the eGroup for this LGen |
| var integer vl_lgenIdxInEGrp := v_ExecCtrl_lgens[pl_lgenIdx].eGroups[e].lgenIdxInEGrp; |
| |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_lgenIdxInEGrp].eCount==0) { |
| continue; // eGrp is not created on the LGen |
| } |
| |
| var integer vl_totalLGenNum := f_EPTF_ExecCtrl_getNofLGensForEGrp(vl_eGrpIdx); |
| var integer vl_currentLGenNum := f_EPTF_ExecCtrl_getCurrentLGenNumForEGrp(pl_lgenIdx,vl_eGrpIdx); |
| |
| vl_createEGrpList[sizeof(vl_createEGrpList)] := { |
| name := v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| eType := v_ExecCtrl_entityGroups[vl_eGrpIdx].eType, |
| gOffset := v_ExecCtrl_entityGroups[vl_eGrpIdx].eOffset, |
| gCount := v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount, |
| eOffset := v_ExecCtrl_entityGroups[vl_eGrpIdx].eOffset+v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_lgenIdxInEGrp].eOffset, |
| eCount := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_lgenIdxInEGrp].eCount, |
| trafficCorrigation := int2float(vl_currentLGenNum)/int2float(vl_totalLGenNum) |
| } |
| } |
| if (sizeof(vl_createEGrpList)>0) { |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_CreateEntityGrpList:vl_createEGrpList) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[pl_lgenIdx].lgenCompRef); |
| f_EPTF_ExecCtrl_debug(log2str("Entity Groups ",vl_createEGrpList, " are created on LGen ", v_ExecCtrl_lgens[pl_lgenIdx].name)); |
| return true; |
| } |
| return false; |
| } |
| |
| // allocates and creates all entity groups on all LGens |
| // All entity groups with same eType are processed together (one message per eType) |
| private function f_EPTF_ExecCtrl_configureEntityGroups() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started..."); |
| var EPTF_CharstringList vl_eTypeList := f_EPTF_ExecCtrl_findETypes(); |
| for(var integer et :=0, size := sizeof(vl_eTypeList); et<size; et := et+1) { |
| // find eGroups with current eType: |
| f_EPTF_ExecCtrl_debug(log2str("Processing EGroups with eType ",vl_eTypeList[et])); |
| var EPTF_IntegerList vl_eGrpIdxList := f_EPTF_ExecCtrl_findEGroups(vl_eTypeList[et]); |
| var integer vl_numEGrps := sizeof(vl_eGrpIdxList); |
| for(var integer i:=0; i<vl_numEGrps; i:=i+1) { |
| f_EPTF_ExecCtrl_allocateEntityGroup(vl_eGrpIdxList[i]); |
| } |
| f_EPTF_ExecCtrl_dumpInstanceDB(); |
| // send create group to lgens and wait the response (=resource update) |
| if (vl_numEGrps==0) { |
| return; // nothing to do |
| } |
| // go through all LGens: |
| v_ExecCtrl_pendingMsgCounter := 0; |
| for(var integer i:=0, csize := sizeof(v_ExecCtrl_lgens); i<csize; i:=i+1) { |
| var integer vl_lgenIdx := i; |
| if (f_EPTF_ExecCtrl_createEntityGroupsOnLGen(vl_lgenIdx,vl_eTypeList[et])) { |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter + 1; |
| } |
| } |
| if (v_ExecCtrl_pendingMsgCounter==0) { |
| f_EPTF_ExecCtrl_debug(log2str("No Entity Group with eType ", vl_eTypeList[et], " was created.")); |
| continue; // this continue is not necessary |
| } |
| // wait until resource info is received from all LGens: |
| var EPTF_ExecCtrl_Condition_FN vl_checkPending := refers(f_EPTF_ExecCtrl_checkPendingMsgs); |
| f_EPTF_ExecCtrl_waitForCondition(vl_checkPending); |
| } |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| // sends all clients a endOfConfig message and waits for readyToRun |
| private function f_EPTF_ExecCtrl_endOfConfig() runs on EPTF_ExecCtrl_CT { |
| v_ExecCtrl_pendingMsgCounter := 0; |
| for(var integer lgenIdx:=0, size := sizeof(v_ExecCtrl_lgens); lgenIdx<size; lgenIdx:=lgenIdx+1) { |
| if (v_ExecCtrl_lgens[lgenIdx].lgenCompRef==-1) { |
| continue; // do not send packet to LGen if LGen exited |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_EndOfConfig:{v_ExecCtrl_dataSourceCompRef}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenIdx].lgenCompRef); |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter + 1; |
| } |
| // wait until response (ReadyToRun) is received from all LGens: |
| var EPTF_ExecCtrl_Condition_FN vl_checkPending := refers(f_EPTF_ExecCtrl_checkPendingMsgs); |
| f_EPTF_ExecCtrl_waitForCondition(vl_checkPending); |
| f_EPTF_ExecCtrl_createIteratorVars(); |
| f_EPTF_ExecCtrl_setStatusEndOfConfig(); |
| } |
| |
| // this function is called when the readyToRun from all clients arrived |
| // also flips the v_ExecCtrl_readyToRun flag to true |
| private function f_EPTF_ExecCtrl_readyToRun() runs on EPTF_ExecCtrl_CT { |
| // create variables |
| f_EPTF_ExecCtrl_createScenarioVariables(); |
| f_EPTF_ExecCtrl_createGUI_vars(); |
| if(v_ExecCtrl_dataSourceCompRef != null){ |
| f_EPTF_DataSourceClient_sendReady(c_ExecCtrl_DataSource_sourceId, f_EPTF_Base_selfName()); |
| if (v_ExecCtrl_progressEnabled and v_ExecCtrl_progressBarUIHandler_Idx!=-1) { |
| f_EPTF_Var_adjustContent(v_ExecCtrl_progressBarUIHandler_Idx,{charstringVal := "ExecCtrl: Ready."}); |
| } |
| } |
| |
| f_EPTF_ExecCtrl_setStatusReadyToRun(); |
| |
| // flip readyToRun flag to true: |
| v_ExecCtrl_readyToRun := true; |
| // How to call readyToRun == true callbacks: |
| // This altstep will catch the readyToRun == true event instantly: |
| // alt{ |
| // [f_EPTF_ExecCtrl_checkReadyToRun()] t_user_readyToRunTimer_startedWithZeroTime.timeout { f_userDefinedCallback(userArgs); } |
| // } |
| // This is how the ExecCtrlUIHandler will catch the readyToRun event too |
| } |
| |
| private altstep as_EPTF_ExecCtrl_MgmtIf_handleReadytoRun() runs on EPTF_ExecCtrl_CT { |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_ReadyToRun:?) { |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter - 1; |
| f_EPTF_ExecCtrl_updateProgressbar(100.0/int2float(sizeof(v_ExecCtrl_lgens))); // ReadyToRun 0-100% |
| repeat; |
| } |
| } |
| |
| private altstep as_EPTF_ExecCtrl_MgmtIf_handleCreateFSMStats() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrl_CreateFSMStats vl_msg; |
| var EPTF_ExecCtrlClient_CT vl_client; |
| [not v_ExecCtrl_processingCreateFSMStats] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_CreateFSMStats:?) -> value vl_msg sender vl_client { |
| f_EPTF_ExecCtrl_handleCreateFSMStats(vl_msg, vl_client); |
| repeat; |
| } |
| } |
| |
| // stores new FSMStats into database and calls FSMStatCreatedCallbacks |
| private function f_EPTF_ExecCtrl_handleCreateFSMStats( |
| in EPTF_ExecCtrl_CreateFSMStats pl_createFSMStats, |
| in EPTF_ExecCtrlClient_CT pl_client |
| ) runs on EPTF_ExecCtrl_CT { |
| v_ExecCtrl_processingCreateFSMStats := true; |
| var EPTF_LGenBase_StatisticListOfTCList vl_statList := pl_createFSMStats; |
| var EPTF_LGenBase_StatisticListOfTCList vl_newStatList := {}; |
| |
| var charstring vl_statName,vl_shName; |
| var charstring vl_eGrpName,vl_scTypeName,vl_tcName; |
| var EPTF_StatHandler_StatMethod vl_statMethod; |
| var EPTF_Var_DirectContent vl_resetValue; |
| |
| // for each stat |
| for(var integer i:=0; i<sizeof(vl_statList);i:=i+1) { |
| vl_eGrpName:=vl_statList[i].entityGroup; |
| vl_scTypeName:=vl_statList[i].scenario; |
| vl_tcName:=vl_statList[i].tc; |
| |
| for(var integer st:=0; st<sizeof(vl_statList[i].stats);st:=st+1) { |
| vl_statName := vl_statList[i].stats[st].declaredName; |
| vl_shName := vl_statList[i].stats[st].statName; |
| vl_statMethod := vl_statList[i].stats[st].statMethod; |
| vl_resetValue := vl_statList[i].stats[st].statResetValue; |
| |
| // declare stat: |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getTrafficCaseIdx(vl_eGrpName,vl_scTypeName,vl_tcName); |
| v_EPTF_ExecCtrl_statHandler_autoSelector := vl_tcIdx; // use the same statHandler for FSM stats and TC stats |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| pl_statName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&".FSMStats."&vl_statName, |
| pl_statMethod := vl_statMethod, |
| pl_statResetValue := vl_resetValue |
| )) {/*cannot happen*/} else { |
| f_EPTF_ExecCtrl_debug(%definitionId&": f_EPTF_StatHandlerClient_declareStat: "&vl_statName); |
| }; |
| |
| var EPTF_Var_SubscriptionMode vl_subscriptionMode := sampledAtSync; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionMode := pull; |
| } |
| // register stat: |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_registerAggregatedStat( |
| pl_sourceStatHandler := pl_client, |
| pl_sourceStatName := vl_shName, |
| pl_targetStatName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&".FSMStats."&vl_statName, |
| pl_subscriptionMode := vl_subscriptionMode, |
| pl_wait4response := true//tsp_EPTF_ExecCtrl_StatHandler_wait4response |
| )) {/*cannot happen*/}; |
| } |
| // filter stats with no statList: |
| if (sizeof(vl_statList[i].stats)>0) { |
| vl_newStatList[sizeof(vl_newStatList)] := vl_statList[i]; |
| } |
| } |
| |
| f_EPTF_ExecCtrl_storeFSMStats(vl_newStatList); |
| v_ExecCtrl_processingCreateFSMStats := false; |
| } |
| |
| // stores new FSMStats into database and calls FSMStatCreatedCallbacks |
| private function f_EPTF_ExecCtrl_storeFSMStats( |
| in EPTF_ExecCtrl_CreateFSMStats pl_createFSMStats |
| ) runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrl_CreateFSMStats vl_newFSMStats := {}; |
| for(var integer st:=0, size := sizeof(pl_createFSMStats); st<size;st:=st+1) { |
| // check if it was not already added: |
| var boolean vl_found := false; |
| for(var integer i:=0, csize := sizeof(v_ExecCtrl_FSMStats); i<csize;i:=i+1) { |
| if (v_ExecCtrl_FSMStats[i]==pl_createFSMStats[st]) { |
| vl_found:= true; |
| break; // i-cycle |
| } |
| } |
| if(not vl_found) { |
| // add to database: |
| v_ExecCtrl_FSMStats[sizeof(v_ExecCtrl_FSMStats)] := pl_createFSMStats[st]; |
| vl_newFSMStats[sizeof(vl_newFSMStats)] := pl_createFSMStats[st]; |
| } |
| } |
| //call callbacks: |
| if (sizeof(vl_newFSMStats)>0) { |
| f_EPTF_ExecCtrl_callFSMStatsCreatedCallbacks(vl_newFSMStats); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_registerFSMStatsCreatedCallback |
| // |
| // Purpose: |
| // registers callback function to call when FSM statistics are created |
| // |
| // Parameters: |
| // pl_fsmStatsCreatedFn - in <EPTF_ExecCtrl_FSMStatsCreatedCallbackFn> - the FSM stats created callback fn to register |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // Called when the FSM statistics are declared (somewhere after the EndOfConfig event) |
| // The GUIDone event might not have happened, i.e. the GUI is not certainly prepared |
| // when this function is called. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_registerFSMStatsCreatedCallback(in EPTF_ExecCtrl_FSMStatsCreatedCallbackFn pl_fsmStatsCreatedFn) |
| runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[sizeof(v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns)] := pl_fsmStatsCreatedFn; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_deregisterFSMStatsCreatedCallback |
| // |
| // Purpose: |
| // removes the callback function registered earlier by <f_EPTF_ExecCtrl_registerFSMStatsCreatedCallback> |
| // |
| // Parameters: |
| // pl_fsmStatsCreatedFn - in <EPTF_ExecCtrl_FSMStatsCreatedCallbackFn> - the FSM stats created callback fn to deregister |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_deregisterFSMStatsCreatedCallback(in EPTF_ExecCtrl_FSMStatsCreatedCallbackFn pl_fsmStatsCreatedFn) |
| runs on EPTF_ExecCtrl_CT { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns); i<size; i:=i+1) { |
| if(v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i]==pl_fsmStatsCreatedFn) { |
| v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i] := null; |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_callFSMStatsCreatedCallbacks( |
| in EPTF_ExecCtrl_CreateFSMStats pl_createFSMStats |
| ) runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Calling callbacks for FSMStats: ",pl_createFSMStats)); |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns); i<size; i:=i+1) { |
| if(v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i]!=null) { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Calling FSMStatsCreated function: ",v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i])); |
| v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i].apply(pl_createFSMStats); |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": FSMStatsCreated function finished: ",v_EPTF_ExecCtrl_fsmStatsCreatedCallbackFns[i])); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getFSMStatisticsOfTcs |
| // |
| // Purpose: |
| // returns the FSM statistics created for all TCs |
| // |
| // Parameters: |
| // pl_fsmStats - out <EPTF_LGenBase_StatisticListOfTCList> - the list of FSM statistics |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // This function is similar to the <f_EPTF_LGenBase_getStatisticsOfTcs> in LGenBase. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getFSMStatisticsOfTcs(out EPTF_LGenBase_StatisticListOfTCList pl_fsmStats) runs on EPTF_ExecCtrl_CT { |
| pl_fsmStats := v_ExecCtrl_FSMStats; |
| } |
| |
| // configures the LGens |
| private function f_EPTF_ExecCtrl_configureLGens() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started..."); |
| f_EPTF_ExecCtrl_updateProgressbar(0.0,"Deploying scenarios") |
| // Configure entity groups: |
| f_EPTF_ExecCtrl_configureEntityGroups(); // to process all eGroups with the same eType together |
| // declare phase lists: |
| f_EPTF_ExecCtrl_declarePhaseLists(); |
| // declare traffic cases |
| f_EPTF_ExecCtrl_declareTrafficCases(); |
| // declare scenarios |
| f_EPTF_ExecCtrl_declareScenarios(); |
| //deploy scenario groups |
| f_EPTF_ExecCtrl_Phase_deployScenarioGroups(); |
| f_EPTF_ExecCtrl_disableScenariosForPhaseGroups(); |
| // notify LGens that the configuration is finished and wait for ready to start; |
| f_EPTF_ExecCtrl_endOfConfig(); |
| |
| v_ExecCtrl_cfgState := c_ExecCtrl_Cfg_CONFIGURED; |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| // returns true if repeat needed |
| private function f_EPTF_ExecCtrl_handle_EntityResourceInfo(in EPTF_ExecCtrlClient_CT pl_client, in EPTF_ExecCtrl_EntityResourceInfo pl_msg) |
| runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(log2str("EntityResourceInfo received from ",pl_client,": ", pl_msg)); |
| |
| var integer vl_lgenPoolIdxOfLGen; |
| if (not v_ExecCtrl_started or (not v_ExecCtrl_allLGensCreated and not f_EPTF_int2int_HashMap_Find(v_EPTF_ExecCtrl_lgenPoolCompRefHash, f_EPTF_Base_upcast(pl_client), vl_lgenPoolIdxOfLGen))) { |
| // buffer resource info message if ExecCtrl is not started or LGen is not added to pool database (yet) |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer[sizeof(v_EPTF_ExecCtrl_EntityResourceInfo_Buffer)] := { |
| pl_client, |
| pl_msg |
| } |
| f_EPTF_ExecCtrl_debug(%definitionId&": EntityResourceInfo is buffered. Number of buffered messages: "&int2str(sizeof(v_EPTF_ExecCtrl_EntityResourceInfo_Buffer))); |
| return; |
| } |
| |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter - 1; |
| var integer vl_lgenIdx := f_EPTF_ExecCtrl_getLGenIdx(pl_msg.lgenName); |
| if (vl_lgenIdx==-1) { |
| var EPTF_ExecCtrl_LGenData lgenData := c_EPTF_ExecCtrl_LGenData_initialValue; |
| lgenData.name := pl_msg.lgenName; |
| lgenData.lgenCompRef := f_EPTF_Base_upcast(pl_client); |
| lgenData.resourceList := pl_msg.available; |
| vl_lgenIdx := f_EPTF_ExecCtrl_addLGenInstance(lgenData); |
| f_EPTF_ExecCtrl_addLGen2EntityGrps(vl_lgenIdx); |
| if (v_ExecCtrl_nrOfClients>0 and v_ExecCtrl_allLGensCreated) { |
| f_EPTF_ExecCtrl_updateProgressbar(100.0/int2float(v_ExecCtrl_nrOfClients)); // LGen progress: 0-100% |
| } else { |
| // this is reached if the creator function is a blocking function |
| var integer vl_nrOfExpectedClients := f_EPTF_ExecCtrl_getNrOfExpectedClients(); |
| if(vl_nrOfExpectedClients > 0){ |
| f_EPTF_ExecCtrl_updateProgressbar(100.0/int2float(vl_nrOfExpectedClients)); // LGen progress: approx // number of clients unknown: EntityResourceInfo received before creator function returned! |
| } else { |
| f_EPTF_ExecCtrl_updateProgressbar(1.0); // LGen progress: approx // number of clients unknown: EntityResourceInfo received before creator function returned! |
| } |
| } |
| } else { |
| f_EPTF_ExecCtrl_updateLGenResourceList(vl_lgenIdx,pl_msg.available); |
| f_EPTF_ExecCtrl_dumpInstanceDB(); |
| return; |
| } |
| // debug: |
| f_EPTF_ExecCtrl_dumpInstanceDB(); |
| return; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getNrOfExpectedClients |
| // |
| // Purpose: |
| // Gets the number of Expected Clients set previously |
| // by f_EPTF_ExecCtrl_setNrOfExpectedClients() |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // pl_nrOfClient - in *integer* - number of expected clients |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getNrOfExpectedClients() |
| runs on EPTF_ExecCtrl_CT |
| return integer{ |
| return v_ExecCtrl_nrOfExpectedClients; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setNrOfExpectedClients |
| // |
| // Purpose: |
| // Sets the number of Expected Clients - this number is used during |
| // displaying the progress of the initialisation of the ExecCtrl |
| // lgenpool section. |
| // |
| // Parameters: |
| // pl_nrOfClient - in *integer* - number of expected clients |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // Should be called after the f_EPTF_ExecCtrl_loadConfig() but |
| // before the f_EPTF_ExecCtrl_start() or the f_EPTF_ExecCtrl_LGenPool_createLGens(), |
| // if no parameter is given, else has no effect. If parameter is given, than only |
| // before part of the sentence is true. |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setNrOfExpectedClients(in integer pl_nrOfClient := 0) |
| runs on EPTF_ExecCtrl_CT { |
| if(pl_nrOfClient > 0){ |
| v_ExecCtrl_nrOfExpectedClients := pl_nrOfClient; |
| } else { |
| v_ExecCtrl_nrOfExpectedClients := 0; |
| //add the lgens from the lgenpools |
| for(var integer vl_lgenPoolIdx:=0, size := sizeof(v_EPTF_ExecCtrl_LGenPool_Declarators); vl_lgenPoolIdx<size;vl_lgenPoolIdx:=vl_lgenPoolIdx+1) { |
| for (var integer i:=0, isize := sizeof(v_EPTF_ExecCtrl_LGenPool_Declarators[vl_lgenPoolIdx].lgenPoolItems); i<isize; i:=i+1){ |
| v_ExecCtrl_nrOfExpectedClients := v_ExecCtrl_nrOfExpectedClients + v_EPTF_ExecCtrl_LGenPool_Declarators[vl_lgenPoolIdx].lgenPoolItems[i].num; |
| } |
| } |
| //add the manual lgen clients |
| v_ExecCtrl_nrOfExpectedClients := v_ExecCtrl_nrOfExpectedClients + v_ExecCtrl_nrOfClients; |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_loadBuffered_EntityResourceInfo() runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_started or not v_ExecCtrl_allLGensCreated) { |
| return; |
| } |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_EntityResourceInfo_Buffer); i<size; i:=i+1) { |
| f_EPTF_ExecCtrl_handle_EntityResourceInfo( |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer[i].client, |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer[i].msg |
| ); |
| } |
| v_EPTF_ExecCtrl_EntityResourceInfo_Buffer := {}; |
| } |
| |
| private altstep as_EPTF_ExecCtrl_handleAllLGensCreated() runs on EPTF_ExecCtrl_CT { |
| [v_ExecCtrl_allLGensCreated and f_EPTF_ExecCtrl_numLGens() == v_ExecCtrl_nrOfClients] t_ExecCtrl_allLGensCreated.timeout { |
| // if initial resource info received for all LGens -> configure entity groups: |
| f_EPTF_ExecCtrl_debug(log2str("All ",v_ExecCtrl_nrOfClients," LGens are started.")); |
| // All LGens have started up |
| f_EPTF_ExecCtrl_configureLGens(); |
| // All LGens are configured |
| f_EPTF_ExecCtrl_readyToRun(); |
| |
| if(not v_ExecCtrl_manualControl) { |
| f_EPTF_ExecCtrl_startAllScenarios(); |
| } |
| |
| f_EPTF_ExecCtrl_debug("t_ExecCtrl_allLGensCreated.timeout handling finished"); |
| repeat; |
| } |
| } |
| |
| // increases the progressbar variable (range: 0-100) by pl_weight if 0 < pl_weight <=100, |
| // updates progressbar (slowly approaches 99) if -100 <= pl_weight < 0 |
| // if pl_text is != "" the text is updated with pl_text and the progress is set to 0 if pl_weight==0, |
| // otherwise progressbar value is is increased with the new value calculated from pl_weight |
| friend function f_EPTF_ExecCtrl_updateProgressbar(in float pl_weight := 1.0, in charstring pl_text := "") runs on EPTF_ExecCtrl_CT { |
| var integer vl_idx := f_EPTF_Var_getId(c_EPTF_ExecCtrl_statisticsRoot&".notif.progressbar"); |
| if (vl_idx<0) { |
| return; |
| } |
| var float vl_currentVal := str2float(f_EPTF_Var_getCharstringValue(vl_idx)); |
| var float vl_newVal; |
| if (pl_weight<0.0 or vl_currentVal + pl_weight > 95.0) { |
| if (pl_weight<0.0) { pl_weight := - pl_weight; } |
| vl_newVal := vl_currentVal + pl_weight*(100.0-vl_currentVal)*vl_currentVal/1000000.0; |
| } else { |
| vl_newVal := vl_currentVal + pl_weight |
| } |
| // round it: |
| vl_newVal := int2float(float2int(100.0*vl_newVal))/100.0; |
| // if (vl_newVal>100.0) { |
| // vl_newVal := 100.0 |
| // } |
| f_EPTF_ExecCtrl_updateGlobalProgressbar(vl_newVal-vl_currentVal); |
| |
| // update text: |
| var integer vl_idxText := f_EPTF_Var_getId(c_EPTF_ExecCtrl_statisticsRoot&".notif.progressbar.text"); |
| if (vl_idxText>=0) { |
| if (pl_text != "") { |
| f_EPTF_ExecCtrl_updateGlobalProgressbar(100.0-vl_newVal); |
| if (pl_text == "Done") { |
| vl_newVal := 100.0; |
| f_EPTF_ExecCtrl_updateGlobalProgressbar(-100.0); |
| } else if (pl_weight==0.0) { // reset progressbar value |
| vl_newVal := 0.0; |
| //set the previous one to 100% |
| f_EPTF_Var_adjustContent(vl_idx,{charstringVal := "100.0"}); |
| } |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := pl_text}); |
| |
| } else if (v_ExecCtrl_nrOfClients>sizeof(v_ExecCtrl_lgens)) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "Waiting for LGens to start up: "&int2str(v_ExecCtrl_nrOfClients-sizeof(v_ExecCtrl_lgens))}); |
| |
| } /*else if (vl_newVal<=20.0) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "All LGens are up."}); |
| } else if (vl_newVal>20.0 and vl_currentVal<=30.0) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "Deploying entity groups"}); |
| } else if (vl_newVal>58.0 and vl_currentVal<=58.0) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "Declaring traffic cases"}); |
| } else if (vl_newVal>75.0 and vl_currentVal<=75.0) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "Distributing scenarios"}); |
| } else if (vl_newVal>90.0 and vl_currentVal<=90.0) { |
| f_EPTF_Var_adjustContent(vl_idxText,{charstringVal := "Finalizing configuration"}); |
| }*/ |
| } |
| |
| if(str2float(substr(float2str(vl_newVal),0,5))>str2float(substr(float2str(vl_currentVal),0,5)) or (pl_text != "" and pl_weight==0.0) ){ |
| f_EPTF_Var_adjustContent(vl_idx,{charstringVal := substr(float2str(vl_newVal),0,5)}); |
| } |
| |
| } |
| |
| friend function f_EPTF_ExecCtrl_updateGlobalProgressbar(in float pl_weight := 1.0) runs on EPTF_ExecCtrl_CT { |
| |
| //"Creating LGen pools" |
| //"Deploying scenarios" |
| //"Creating Entity Groups panel variables" |
| //"Creating Client Resources panel variables" |
| //"Creating Traffic Cases panel variables" |
| //"Creating Regulator panel variables" |
| //"Creating Phase Lists variables" |
| |
| const float cl_numOfProgressPhases := 7.0; //see above |
| |
| var integer vl_idx := f_EPTF_Var_getId(c_EPTF_ExecCtrl_statisticsRoot&".notif.globalProgressbar"); |
| if (vl_idx<0) { |
| return; |
| } |
| var float vl_currentVal := str2float(f_EPTF_Var_getCharstringValue(vl_idx)); |
| var float vl_newVal; |
| if (pl_weight == -100.0) { |
| vl_newVal := 100.0; |
| } else { |
| pl_weight := pl_weight / cl_numOfProgressPhases; |
| vl_newVal := vl_currentVal + pl_weight |
| } |
| |
| // round it: |
| vl_newVal := int2float(float2int(100.0*vl_newVal))/100.0; |
| f_EPTF_Var_adjustContent(vl_idx,{charstringVal := substr(float2str(vl_newVal),0,5)}); |
| } |
| |
| |
| |
| private altstep as_EPTF_ExecCtrl_MgmtIf_handleEntityResourceInfo() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrl_EntityResourceInfo vl_msg; |
| var EPTF_ExecCtrlClient_CT vl_client; |
| //[v_ExecCtrl_allLGensCreated] |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_EntityResourceInfo:?) -> value vl_msg sender vl_client { |
| f_EPTF_ExecCtrl_handle_EntityResourceInfo(vl_client, vl_msg); |
| repeat; |
| } |
| } |
| |
| } // group EntityGroupCreation |
| |
| |
| // declares phase lists on LGens: |
| private function f_EPTF_ExecCtrl_declarePhaseLists() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started..."); |
| f_EPTF_ExecCtrl_debug(log2str("The declared PhaseLists: ", v_EPTF_ExecCtrl_PhaseList_Declarators)); |
| // go through all LGens |
| for(var integer lgenIdx:=0, size := sizeof(v_ExecCtrl_lgens); lgenIdx<size; lgenIdx:=lgenIdx+1) { |
| if (v_ExecCtrl_lgens[lgenIdx].lgenCompRef==-1) { |
| continue; // do not send packet to LGen if it already exited |
| } |
| // create the message for the LGen |
| var EPTF_ExecCtrl_DeclarePhaseLists vl_declarePhaseLists := v_EPTF_ExecCtrl_PhaseList_Declarators; |
| |
| //send the message to the LGen |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_DeclarePhaseLists:v_EPTF_ExecCtrl_PhaseList_Declarators) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenIdx].lgenCompRef); |
| // no response is sent from client |
| } |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| // declares traffic cases on LGens |
| private function f_EPTF_ExecCtrl_declareTrafficCases() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": started..."); |
| f_EPTF_ExecCtrl_debug(log2str("The declared TC Types: ", v_ExecCtrl_tcTypes)); |
| // go through all LGens |
| for(var integer lgenIdx:=0, size := sizeof(v_ExecCtrl_lgens); lgenIdx<size; lgenIdx:=lgenIdx+1) { |
| if (v_ExecCtrl_lgens[lgenIdx].lgenCompRef==-1) { |
| continue; // do not send packet to LGen if it already exited |
| } |
| // create the message for the LGen |
| var EPTF_ExecCtrl_DeclareTcs vl_declareTCs := {}; |
| |
| // Find the entity types that are used on the LGen |
| var EPTF_CharstringList vl_eTypesUsed := f_EPTF_ExecCtrl_getUsedETypesForLGen(lgenIdx); |
| f_EPTF_ExecCtrl_debug(log2str("Entity Types used on LGen ", v_ExecCtrl_lgens[lgenIdx].name, " are: ", vl_eTypesUsed)); |
| |
| //Find the traffic cases for these eType-s |
| for(var integer e:=0, esize := sizeof(vl_eTypesUsed); e<esize; e:=e+1) { |
| var EPTF_IntegerList vl_tcTypeIdxList := f_EPTF_ExecCtrl_getTcTypeIdxsForEType(vl_eTypesUsed[e]); |
| f_EPTF_ExecCtrl_debug(log2str("TC Types that use the eType ",vl_eTypesUsed[e], " are: ", vl_tcTypeIdxList)); |
| for(var integer tc:=0, tsize := sizeof(vl_tcTypeIdxList); tc<tsize; tc:=tc+1) { |
| vl_declareTCs[sizeof(vl_declareTCs)] := v_ExecCtrl_tcTypes[vl_tcTypeIdxList[tc]]; |
| } |
| } |
| //send the message to the LGen |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_DeclareTcs:vl_declareTCs) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenIdx].lgenCompRef); |
| // no response is sent from client |
| } |
| f_EPTF_ExecCtrl_debug(%definitionId&": finished"); |
| } |
| |
| // declares scenarios on LGens |
| private function f_EPTF_ExecCtrl_declareScenarios() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| // A) go through all scenarios and declare them on LGens |
| var EPTF_ExecCtrl_ScenarioTypeLists vl_scenarioTypeLists := {}; // [scIdx][lgenidx] |
| for(var integer scIdx:=0, size := sizeof(v_ExecCtrl_scenarios);scIdx<size;scIdx:=scIdx+1) { |
| vl_scenarioTypeLists[scIdx] := f_EPTF_ExecCtrl_distributeScenarioOnLGens(scIdx); |
| } |
| |
| // B) go through all LGens and send scenarios to them |
| // go through all LGens: |
| for(var integer lgenIdx:=0, size := sizeof(v_ExecCtrl_lgens); lgenIdx<size; lgenIdx:=lgenIdx+1) { |
| if (v_ExecCtrl_lgens[lgenIdx].lgenCompRef==-1) { |
| continue; // do not send packet to LGen if it already exited |
| } |
| // create the message for the LGen |
| var EPTF_LGenBase_ScenarioTypeInternalDeclaratorList vl_declareScs := {}; // [sc] |
| var EPTF_ExecCtrl_NamesInScenarioList vl_scNameLists := {}; // [sc][tcOfScIdx] |
| |
| // go through the eGrp-s: |
| for(var integer e:=0, gsize := sizeof(v_ExecCtrl_lgens[lgenIdx].eGroups); e<gsize; e:=e+1) { |
| // if eGrp is not allocated: continue |
| var integer vl_eGrpIdx := v_ExecCtrl_lgens[lgenIdx].eGroups[e].eGrpIdx; |
| var integer vl_lgenIdxInEGrp := v_ExecCtrl_lgens[lgenIdx].eGroups[e].lgenIdxInEGrp; |
| if(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_lgenIdxInEGrp].eCount==0) { |
| continue; |
| } |
| // go through the scenarios of this eGrp: |
| for(var integer s:=0, ssize := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].scenarios); s<ssize;s:=s+1) { |
| var integer vl_scIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].scenarios[s]; |
| // distribute scenario into the LGen |
| var integer sc := sizeof(vl_declareScs); |
| f_EPTF_ExecCtrl_convertScenarioInstance2Declarator(vl_scenarioTypeLists[vl_scIdx][vl_lgenIdxInEGrp],vl_declareScs[sc]); |
| // set the TCNames: |
| vl_scNameLists[sc] := { |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].name, |
| v_ExecCtrl_scenarios[vl_scIdx].scData.name, |
| {} |
| } |
| for(var integer tcOfScIdx:=0, tsize := sizeof(v_ExecCtrl_scenarios[vl_scIdx].scData.tcList); tcOfScIdx<tsize;tcOfScIdx:=tcOfScIdx+1) { |
| var charstring vl_tcName := f_EPTF_LGenBase_tcNameOfTcOfSc(v_ExecCtrl_scenarios[vl_scIdx].scData,tcOfScIdx) |
| vl_scNameLists[sc].tcNames[tcOfScIdx] := vl_tcName; |
| } |
| } |
| } |
| f_EPTF_ExecCtrl_debug(log2str("Outgoing packet to LGen ",v_ExecCtrl_lgens[lgenIdx].name,": ", vl_declareScs, " TcNames: ", vl_scNameLists)); |
| //send the message to the LGen |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_CreateScenario:{vl_declareScs,vl_scNameLists}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenIdx].lgenCompRef); |
| } |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| } |
| |
| private function f_EPTF_ExecCtrl_convertScenarioInstance2Declarator(in EPTF_ExecCtrl_ScenarioType pl_scInstance, out EPTF_LGenBase_ScenarioTypeInternalDeclarator pl_scDecl) runs on EPTF_ExecCtrl_CT { |
| pl_scDecl := pl_scInstance; |
| } |
| |
| // creates the varibles for the scenario (for gui): |
| // scenario status, start/stop scenario, start/stop all traffic cases in the scenario |
| private function f_EPTF_ExecCtrl_createScenarioVariables() runs on EPTF_ExecCtrl_CT { |
| // create Variables: |
| for(var integer sc:=0, size := sizeof(v_ExecCtrl_scenarios); sc<size; sc:=sc+1) { |
| f_EPTF_ExecCtrl_subscribeScenarioState(sc); |
| f_EPTF_ExecCtrl_createTrafficCaseVariablesOfSc(sc); |
| f_EPTF_ExecCtrl_createStartStopScenario(sc); |
| f_EPTF_ExecCtrl_createStartStopAllTC(sc); |
| } |
| // create resetAllTC counters button variable |
| f_EPTF_ExecCtrl_createResetStatsAllTC(); |
| // create resetAllTC FSM stats button variable |
| f_EPTF_ExecCtrl_createResetFSMStatsAllTC(); |
| // register execTime updater callback: |
| f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_execTimeUpdate_TCStateChangedCallbackFn)); |
| } |
| |
| // Distribute scenario on LGens |
| // Returns a scenario type list for all LGens [lgenidx] |
| // The scenarios are declared on LGens with the instance name instead of the declarator name! |
| private function f_EPTF_ExecCtrl_distributeScenarioOnLGens(in integer pl_scIdx) runs on EPTF_ExecCtrl_CT |
| return EPTF_ExecCtrl_ScenarioTypeList { |
| f_EPTF_ExecCtrl_debug(%definitionId&": start"); |
| |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| |
| // go through all TCs of this scenario and split them according to the LGen distribution of the entity group this scenario is assigned |
| |
| var EPTF_ExecCtrl_ScenarioTypeList vl_scenarioList := {}; // [lgenidx] |
| var EPTF_ExecCtrl_ScenarioType vl_scenario := v_ExecCtrl_scenarios[pl_scIdx].scData; |
| var EPTF_ExecCtrl_ParamRangeDeclaratorTableList vl_rangeDeclDB := {}; // [<tcidx>][<lgenidx>][<rangeidx>] |
| var EPTF_FloatTable vl_cpsDistributionDb := {}; // [<tcidx>][<lgenidx>] |
| var EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTableList vl_trafficStartFinishConditionsAndActionsDistributionDb := {}; // [<tcidx>][<lgenidx>] |
| |
| var EPTF_FloatList vl_cpsDistributionOfScDb := f_EPTF_ExecCtrl_splitCPSOfSc(pl_scIdx); // [<lgenidx>] |
| |
| // FIXME: shall we need this? : |
| // modify scenario name to the instance name to avoid declarator ambiguity if one scenario is added to more than one eGrp: |
| //vl_scenario.name := v_ExecCtrl_scenarios[pl_scIdx].name; |
| |
| for (var integer tcidx:=0, size := sizeof(vl_scenario.tcList);tcidx<size;tcidx:=tcidx+1) { |
| vl_rangeDeclDB[tcidx] := f_EPTF_ExecCtrl_splitRangesOfTc(pl_scIdx,tcidx); |
| vl_cpsDistributionDb[tcidx] := f_EPTF_ExecCtrl_splitCPSOfTc(pl_scIdx,tcidx) |
| vl_trafficStartFinishConditionsAndActionsDistributionDb[tcidx] := f_EPTF_ExecCtrl_splitTrafficStartFinishConditionsAndActionsOfTc(pl_scIdx,tcidx) |
| } // tcidx |
| |
| // Sending to LGens |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| if (sizeof(vl_cpsDistributionOfScDb)>0) { |
| vl_scenario.weightedScData.cpsToReach := vl_cpsDistributionOfScDb[lgenidx]; |
| } |
| for (var integer tcidx:=0, tsize := sizeof(vl_scenario.tcList);tcidx<tsize;tcidx:=tcidx+1) { |
| // Updating cps |
| if (ischosen(vl_scenario.tcList[tcidx].target.cpsToReach)) { |
| vl_scenario.tcList[tcidx].target.cpsToReach := vl_cpsDistributionDb[tcidx][lgenidx]; |
| } |
| // Updating range params |
| if (sizeof(vl_scenario.tcList[tcidx].ranges) == 0) { |
| vl_scenario.tcList[tcidx].ranges := {} |
| } else { |
| vl_scenario.tcList[tcidx].ranges := vl_rangeDeclDB[tcidx][lgenidx]; |
| } |
| // Updating trafficStartFinishConditionsAndActions |
| vl_scenario.tcList[tcidx].trafficStartFinishConditionsAndActions := vl_trafficStartFinishConditionsAndActionsDistributionDb[tcidx][lgenidx]; |
| |
| } //tcidx |
| |
| var integer vl_lgenIdx := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx; |
| f_EPTF_ExecCtrl_debug(log2str("Scenario to be declared on LGen ",v_ExecCtrl_lgens[vl_lgenIdx].name,": ", vl_scenario)); |
| vl_scenarioList[lgenidx] := vl_scenario; |
| |
| // ExecCtrl_MgmtIf_CP.send(vl_scenario) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| // will be sent together with other scenarios to LGen => only one message is sent/LGen |
| } // lgenidx |
| |
| f_EPTF_ExecCtrl_debug(%definitionId&": finish"); |
| return vl_scenarioList; |
| } |
| |
| // splits the trafficStartFinishConditionsAndActions of the traffic case on the LGens |
| // the returned value contains the list of trafficStartFinishConditionsAndActions-es on the LGens in the order they are placed in the eGrp of the scenario |
| private function f_EPTF_ExecCtrl_splitTrafficStartFinishConditionsAndActionsOfTc(in integer pl_scIdx, in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| return EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable { |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| |
| var EPTF_ExecCtrl_TrafficStartFinishConditionsInternalDeclaratorTable vl_trafficStartFinishConditionsAndActionsDistribution := {}; // [<lgenidx>] |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| |
| //var float vl_eGrpSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount); |
| var integer vl_activeEntities := f_EPTF_ExecCtrl_getActiveEntities(vl_eGrpIdx); |
| if (vl_activeEntities==0) { |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| // do not split: |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions; |
| } |
| return vl_trafficStartFinishConditionsAndActionsDistribution; |
| } |
| var EPTF_LGenBase_TrafficStartFinishConditionsInternalDeclarator vl_remaining := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions; |
| f_EPTF_ExecCtrl_debug(log2str("Distributing trafficStartFinishConditionsAndActions of traffic case ",pl_tcOfScIdx, " of scenario ", pl_scIdx, ": ", |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions)); |
| var integer vl_lastLGenIdxUsed := -1; |
| // do it backwards so that the first always receive 1 |
| for (var integer size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList), lgenidx:=size-1;lgenidx>=0;lgenidx:=lgenidx-1) { |
| var boolean vl_enableSplit := true; // false for weighted, but here it cannot be weighted |
| if (vl_enableSplit) { |
| // Split the values |
| var integer vl_lgenSize := v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCountActive;//int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount); |
| if (vl_lgenSize>0) { |
| vl_lastLGenIdxUsed := lgenidx; |
| } |
| // initialize the value with the original: |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions; |
| |
| if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfExecStart)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfExecStart.count := |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfExecStart.count * vl_lgenSize/vl_activeEntities; |
| |
| vl_remaining.nrOfExecStart.count := |
| vl_remaining.nrOfExecStart.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfExecStart.count; |
| } |
| if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfSuccesses.count := |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfSuccesses.count * vl_lgenSize/vl_activeEntities; |
| |
| vl_remaining.nrOfSuccesses.count := |
| vl_remaining.nrOfSuccesses.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfSuccesses.count; |
| } |
| if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfFails)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfFails.count := |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfFails.count * vl_lgenSize/vl_activeEntities; |
| |
| vl_remaining.nrOfFails.count := |
| vl_remaining.nrOfFails.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfFails.count; |
| } |
| if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfErrors)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfErrors.count := |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfErrors.count * vl_lgenSize/vl_activeEntities; |
| |
| vl_remaining.nrOfErrors.count := |
| vl_remaining.nrOfErrors.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfErrors.count; |
| } |
| if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfTimeouts.count := |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfTimeouts.count * vl_lgenSize/vl_activeEntities; |
| |
| vl_remaining.nrOfTimeouts.count := |
| vl_remaining.nrOfTimeouts.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfTimeouts.count; |
| } |
| // if (ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop)) { |
| // vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfRangeLoop.count := |
| // v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions.nrOfRangeLoop.count * vl_lgenSize/vl_activeEntities; |
| // |
| // vl_remaining.nrOfRangeLoop.count := |
| // vl_remaining.nrOfRangeLoop.count-vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx].nrOfRangeLoop.count; |
| // } |
| //... |
| |
| // these are not split: |
| // nrOfRangeLoop , |
| // execTime , |
| // entitiesFinished , |
| // availableEntitiesFinished , |
| // customFinish , |
| // anythingFinished |
| } else { |
| // Assign the same values, no split |
| vl_trafficStartFinishConditionsAndActionsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].trafficStartFinishConditionsAndActions; |
| } |
| } |
| |
| // correct the last element to store the remaining count |
| if (vl_lastLGenIdxUsed!=-1) { |
| if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfExecStart)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfExecStart.count := |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfExecStart.count + vl_remaining.nrOfExecStart.count; |
| vl_remaining.nrOfExecStart.count := 0; |
| } |
| if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfSuccesses)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfSuccesses.count := |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfSuccesses.count + vl_remaining.nrOfSuccesses.count; |
| vl_remaining.nrOfSuccesses.count := 0; |
| } |
| if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfFails)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfFails.count := |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfFails.count + vl_remaining.nrOfFails.count; |
| vl_remaining.nrOfFails.count := 0; |
| } |
| if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfErrors)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfErrors.count := |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfErrors.count + vl_remaining.nrOfErrors.count; |
| vl_remaining.nrOfErrors.count := 0; |
| } |
| if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfTimeouts)) { |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfTimeouts.count := |
| vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfTimeouts.count + vl_remaining.nrOfTimeouts.count; |
| vl_remaining.nrOfTimeouts.count := 0; |
| } |
| // if(ispresent(vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfRangeLoop)) { |
| // vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfRangeLoop.count := |
| // vl_trafficStartFinishConditionsAndActionsDistribution[vl_lastLGenIdxUsed].nrOfRangeLoop.count + vl_remaining.nrOfRangeLoop.count; |
| // vl_remaining.nrOfRangeLoop.count := 0; |
| // } |
| |
| // these are not split: |
| // nrOfRangeLoop , |
| // execTime , |
| // entitiesFinished , |
| // availableEntitiesFinished , |
| // customFinish , |
| // anythingFinished |
| } |
| // if (vl_remaining>0.0) { |
| // f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Cannot distribute CPS of TC ",v_ExecCtrl_trafficCases[v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[pl_tcOfScIdx]].name)) |
| // } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Calculated vl_trafficStartFinishConditionsAndActionsDistribution on LGens: ", vl_trafficStartFinishConditionsAndActionsDistribution)) |
| return vl_trafficStartFinishConditionsAndActionsDistribution; |
| } |
| |
| // splits the ranges of the traffic case on the LGens |
| // the returned value contains the list of ranges-es on the LGens in the order they are placed in the eGrp of the scenario |
| private function f_EPTF_ExecCtrl_splitRangesOfTc(in integer pl_scIdx, in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| return EPTF_ExecCtrl_ParamRangeDeclaratorTable { |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| |
| var EPTF_ExecCtrl_ParamRangeDeclaratorTable vl_rangeDeclDB := {}; // [<lgenidx>][<rangeidx>] |
| var EPTF_IntegerList vl_rangeCountDistributionDB := {}; |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| //var float vl_eGrpSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount); |
| var float vl_allocatedEntities := int2float(f_EPTF_ExecCtrl_getAllocatedEntities(vl_eGrpIdx)); |
| if (vl_allocatedEntities==0.0) { |
| return vl_rangeDeclDB; |
| } |
| f_EPTF_ExecCtrl_debug(log2str("Distributing ranges of traffic case: ",pl_tcOfScIdx, " of scenario ", pl_scIdx)); |
| // Process all the ranges in the TC |
| for (var integer rangeidx:=0, size := sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges);rangeidx<size;rangeidx:=rangeidx+1) { |
| f_EPTF_ExecCtrl_debug(log2str("Distributing on LGens the range: ", v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx])); |
| var integer vl_remaining := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].count; |
| for (var integer lgenidx:=0, lsize := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<lsize;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].enableSplit) { |
| // Split the values |
| var float vl_lgenSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount); |
| var float vl_lgenWeight := vl_lgenSize/vl_allocatedEntities; |
| vl_rangeCountDistributionDB[lgenidx] := float2int(vl_lgenWeight * int2float(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].count)); |
| if (float2int(vl_lgenSize)==0) { |
| f_EPTF_ExecCtrl_warning(%definitionId&": Zero sized range of "&v_ExecCtrl_scenarios[pl_scIdx].name&"."&f_EPTF_ExecCtrl_tcNameOfTcOfSc(pl_scIdx,pl_tcOfScIdx) |
| &" is distributed on LGen "&v_ExecCtrl_lgens[v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].lgenIdx].name&": " |
| &log2str(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx])); |
| } else if (vl_rangeCountDistributionDB[lgenidx]==0) { |
| f_EPTF_ExecCtrl_error(%definitionId&": Range of "&v_ExecCtrl_scenarios[pl_scIdx].name&"."&f_EPTF_ExecCtrl_tcNameOfTcOfSc(pl_scIdx,pl_tcOfScIdx) |
| &" too small to be able to split among the deployed LGens: " |
| &log2str(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx])); |
| } |
| } else { |
| // Assign the same values, no split |
| vl_rangeCountDistributionDB[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].count; |
| } |
| vl_remaining := vl_remaining-vl_rangeCountDistributionDB[lgenidx]; |
| // correct the last element to store the remaining count |
| if (lgenidx==sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList)-1 and vl_remaining>0) { |
| vl_rangeCountDistributionDB[lgenidx] := vl_rangeCountDistributionDB[lgenidx] + vl_remaining; |
| } |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Calculated vl_rangeCountDistributionDB on LGens: ", vl_rangeCountDistributionDB)) |
| |
| // Compose the range parameters |
| var integer vl_cumulativOffset := 0; |
| for (var integer lgenidx:=0, lsize := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<lsize;lgenidx:=lgenidx+1) { |
| vl_rangeDeclDB[lgenidx][rangeidx].name := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].name; |
| vl_rangeDeclDB[lgenidx][rangeidx].enableSplit := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].enableSplit; |
| vl_rangeDeclDB[lgenidx][rangeidx].count := vl_rangeCountDistributionDB[lgenidx]; |
| vl_rangeDeclDB[lgenidx][rangeidx].baseOffset := vl_cumulativOffset + v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].ranges[rangeidx].baseOffset; |
| if (vl_rangeDeclDB[lgenidx][rangeidx].enableSplit) { |
| vl_cumulativOffset := vl_cumulativOffset + vl_rangeCountDistributionDB[lgenidx]; |
| } |
| } // lgenidx |
| } // rangeidx |
| return vl_rangeDeclDB; |
| } |
| |
| // splits the number of active entities of the entity group on the LGens |
| // the returned value contains the list of number of active entities on the LGens in the order they are placed in the eGrp |
| private function f_EPTF_ExecCtrl_splitActiveEntitiesOfEGrp(in integer pl_eGrpIdx) |
| runs on EPTF_ExecCtrl_CT |
| return EPTF_IntegerList { |
| f_EPTF_Base_assert(%definitionId&": Invalid entity group index "&int2str(pl_eGrpIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_entityGroups))&").", |
| pl_eGrpIdx >= 0 and pl_eGrpIdx < sizeof(v_ExecCtrl_entityGroups)); |
| |
| var EPTF_IntegerList vl_activeEntityDistribution := {};// [<lgenidx>] |
| var integer vl_eGrpIdx := pl_eGrpIdx; |
| |
| //var float vl_eGrpSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount); |
| var float vl_allocatedEntities := int2float(f_EPTF_ExecCtrl_getAllocatedEntities(vl_eGrpIdx)); |
| if (vl_allocatedEntities==0.0) { |
| return vl_activeEntityDistribution; |
| } |
| var integer vl_remaining := f_EPTF_ExecCtrl_getActiveEntities(vl_eGrpIdx); |
| f_EPTF_ExecCtrl_debug(log2str("Distributing number of active entities of entity group ", f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx), ": ", |
| vl_remaining)); |
| var integer vl_lastLGenIdxUsed := -1; // remainder will be allocated to this LGen |
| // do it backwards so that the first always receive 1 |
| for (var integer size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList), lgenidx:=size-1; lgenidx>=0;lgenidx:=lgenidx-1) { |
| // Split the values |
| var float vl_lgenSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount); |
| var float vl_lgenWeight := vl_lgenSize/vl_allocatedEntities; |
| vl_activeEntityDistribution[lgenidx] := float2int(vl_lgenWeight * int2float(f_EPTF_ExecCtrl_getActiveEntities(vl_eGrpIdx))); |
| vl_remaining := vl_remaining-vl_activeEntityDistribution[lgenidx]; |
| if (vl_lgenSize>0.0) { |
| vl_lastLGenIdxUsed := lgenidx; |
| } |
| } |
| |
| // correct the last element to store the remaining count |
| if (vl_lastLGenIdxUsed!=-1 and vl_remaining>0) { |
| if (vl_activeEntityDistribution[vl_lastLGenIdxUsed] + vl_remaining>v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[vl_lastLGenIdxUsed].eCount) { |
| //if it is not possible to add the remaining active entities to this LGen: |
| //choose an LGen where it is possible to add (distribute remaining 1-by-1): |
| for (var integer lgenidx := 0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList); lgenidx<size;lgenidx:=lgenidx+1) { |
| if (vl_activeEntityDistribution[lgenidx] + 1 <= v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount) { |
| vl_activeEntityDistribution[lgenidx] := vl_activeEntityDistribution[lgenidx] + 1; |
| vl_remaining := vl_remaining-1; |
| if (vl_remaining==0) { |
| break; |
| } else { |
| lgenidx := lgenidx - 1; // retry current LGen again for if it is possible to add one more |
| } |
| } |
| } |
| } else { |
| vl_activeEntityDistribution[vl_lastLGenIdxUsed] := vl_activeEntityDistribution[vl_lastLGenIdxUsed] + vl_remaining; |
| vl_remaining := 0; |
| } |
| } |
| f_EPTF_ExecCtrl_debug(log2str("Calculated vl_activeEntityDistribution on LGens: ", vl_activeEntityDistribution)) |
| return vl_activeEntityDistribution; |
| } |
| |
| // splits the CPS/weight of the traffic case on the LGens |
| // the returned value contains the list of CPS/weights-es on the LGens in the order they are placed in the eGrp of the scenario |
| private function f_EPTF_ExecCtrl_splitCPSOfTc(in integer pl_scIdx, in integer pl_tcOfScIdx) |
| runs on EPTF_ExecCtrl_CT |
| return EPTF_FloatList { |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| f_EPTF_Base_assert(%definitionId&": Invalid tcOfScenario index "&int2str(pl_tcOfScIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList))&").", |
| pl_tcOfScIdx >= 0 and pl_tcOfScIdx < sizeof(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList)); |
| |
| if(ischosen(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.dummy)) { |
| f_EPTF_ExecCtrl_error(%definitionId&": No targetCPS/Weight specified in traffic case "&v_ExecCtrl_trafficCases[v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[pl_tcOfScIdx]].name); |
| } |
| |
| var EPTF_FloatList vl_cpsDistribution := {};// [<lgenidx>] |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| if (not ischosen(v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.cpsToReach)) { |
| f_EPTF_ExecCtrl_debug(log2str("Only cpsToReach is distributed, but current tc does not use cpsToReach")); |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| vl_cpsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.trafficWeight; |
| } |
| return vl_cpsDistribution; // weight is not split |
| } |
| |
| //var float vl_eGrpSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount); |
| var float vl_activeEntities := int2float(f_EPTF_ExecCtrl_getActiveEntities(vl_eGrpIdx)); |
| if (vl_activeEntities==0.0) { |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| vl_cpsDistribution[lgenidx] := 0.0 |
| } |
| return vl_cpsDistribution; |
| } |
| var float vl_remaining := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.cpsToReach; |
| f_EPTF_ExecCtrl_debug(log2str("Distributing CPS of traffic case ",pl_tcOfScIdx, " of scenario ", pl_scIdx, ": ", |
| v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.cpsToReach)); |
| var integer vl_lastLGenIdxUsed := -1; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| var boolean vl_enableSplit := true; // false for weighted, but here it cannot be weighted |
| if (vl_enableSplit) { |
| // Split the values |
| var float vl_lgenSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCountActive);//int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount); |
| var float vl_lgenWeight := vl_lgenSize/vl_activeEntities; |
| vl_cpsDistribution[lgenidx] := vl_lgenWeight * v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.cpsToReach; |
| } else { |
| // Assign the same values, no split |
| vl_cpsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.tcList[pl_tcOfScIdx].target.cpsToReach; |
| } |
| if (vl_cpsDistribution[lgenidx]>0.0) { |
| vl_lastLGenIdxUsed := lgenidx; |
| } |
| vl_remaining := vl_remaining-vl_cpsDistribution[lgenidx]; |
| } |
| |
| // correct the last element to store the remaining count |
| if (vl_lastLGenIdxUsed!=-1 and vl_remaining>0.0) { |
| vl_cpsDistribution[vl_lastLGenIdxUsed] := vl_cpsDistribution[vl_lastLGenIdxUsed] + vl_remaining; |
| vl_remaining := 0.0; |
| } |
| if (vl_remaining>0.0) { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Cannot distribute CPS of TC ",v_ExecCtrl_trafficCases[v_ExecCtrl_scenarios[pl_scIdx].tcIdxList[pl_tcOfScIdx]].name)) |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Calculated vl_cpsDistribution on LGens: ", vl_cpsDistribution)) |
| return vl_cpsDistribution; |
| } |
| |
| // splits the CPS of the scenario on the LGens |
| // the returned value contains the list of CPS-es on the LGens in the order they are placed in the eGrp of the scenario |
| private function f_EPTF_ExecCtrl_splitCPSOfSc(in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT |
| return EPTF_FloatList { |
| f_EPTF_Base_assert(%definitionId&": Invalid scenario index "&int2str(pl_scIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_scenarios))&").", |
| pl_scIdx >= 0 and pl_scIdx < sizeof(v_ExecCtrl_scenarios)); |
| |
| var EPTF_FloatList vl_cpsDistribution := {};// [<lgenidx>] |
| if (not ispresent(v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData)) { |
| f_EPTF_ExecCtrl_debug(log2str("Only cpsToReach is distributed, but current Sc does not use cpsToReach")) |
| return vl_cpsDistribution; // nothing to do |
| } |
| |
| var integer vl_eGrpIdx := v_ExecCtrl_scenarios[pl_scIdx].eGroupIdx; |
| //var float vl_eGrpSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].eCount); |
| var float vl_activeEntities := int2float(f_EPTF_ExecCtrl_getActiveEntities(vl_eGrpIdx)); |
| if (vl_activeEntities==0.0) { |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| vl_cpsDistribution[lgenidx] := 0.0 |
| } |
| return vl_cpsDistribution; |
| } |
| var float vl_remaining := v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach; |
| f_EPTF_ExecCtrl_debug(log2str("Distributing CPS of scenario ", pl_scIdx, ": ", |
| v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach)); |
| var integer vl_lastLGenIdxUsed := -1; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList);lgenidx<size;lgenidx:=lgenidx+1) { |
| var boolean vl_enableSplit := true; // true for weighted, but here it cannot be non-weighted |
| if (vl_enableSplit) { |
| // Split the values |
| var float vl_lgenSize := int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCountActive);//int2float(v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenList[lgenidx].eCount); |
| var float vl_lgenWeight := vl_lgenSize/vl_activeEntities; |
| vl_cpsDistribution[lgenidx] := vl_lgenWeight * v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach; |
| } else { |
| // Assign the same values, no split |
| vl_cpsDistribution[lgenidx] := v_ExecCtrl_scenarios[pl_scIdx].scData.weightedScData.cpsToReach; |
| } |
| if (vl_cpsDistribution[lgenidx]>0.0) { |
| vl_lastLGenIdxUsed := lgenidx; |
| } |
| vl_remaining := vl_remaining-vl_cpsDistribution[lgenidx]; |
| } |
| |
| // correct the last element to store the remaining count |
| if (vl_lastLGenIdxUsed!=-1 and vl_remaining>0.0) { |
| vl_cpsDistribution[vl_lastLGenIdxUsed] := vl_cpsDistribution[vl_lastLGenIdxUsed] + vl_remaining; |
| vl_remaining := 0.0; |
| } |
| if (vl_remaining>0.0) { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Cannot distribute CPS of SC ",v_ExecCtrl_scenarios[pl_scIdx].name)) |
| } |
| |
| f_EPTF_ExecCtrl_debug(log2str("Calculated vl_cpsDistribution of the scenario on LGens: ", vl_cpsDistribution)) |
| return vl_cpsDistribution; |
| } |
| |
| friend function f_EPTF_ExecCtrl_sendGuiDoneToLGen(in integer pl_lgenIdx, in boolean pl_guiPresent := false) runs on EPTF_ExecCtrl_CT { |
| if (v_ExecCtrl_lgens[pl_lgenIdx].lgenCompRef==-1) { |
| return; // do not send packet to LGen if LGen exited |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_GuiDone:{pl_guiPresent}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[pl_lgenIdx].lgenCompRef); |
| } |
| |
| |
| friend altstep as_EPTF_ExecCtrl_receiveGuiDone() runs on EPTF_ExecCtrl_CT { |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_GuiDone:?) { |
| } |
| } |
| |
| // R3: final test report generation |
| group EPTF_ExecCtrl_FinalTestReport { |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn |
| // |
| // Purpose: |
| // registers callback function to generate final test report |
| // |
| // Parameters: |
| // pl_reportGeneratorFn - in <EPTF_ExecCtrl_FinalTestReportGenerator_FT> - the report generator fn to register |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // called when the end of test execution detected: |
| // exit event detected in any of the LGens, or the Exit button pressed |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn(in EPTF_ExecCtrl_FinalTestReportGenerator_FT pl_reportGeneratorFn) |
| runs on EPTF_ExecCtrl_CT { |
| v_EPTF_ExecCtrl_finalTestReportGeneratorFns[sizeof(v_EPTF_ExecCtrl_finalTestReportGeneratorFns)] := pl_reportGeneratorFn; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_deregisterFinalTestReportGeneratorFn |
| // |
| // Purpose: |
| // removes the callback function registered earlier by <f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn> |
| // |
| // Parameters: |
| // pl_reportGeneratorFn - in <EPTF_ExecCtrl_FinalTestReportGenerator_FT> - the report generator fn to deregister |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_deregisterFinalTestReportGeneratorFn(in EPTF_ExecCtrl_FinalTestReportGenerator_FT pl_reportGeneratorFn) |
| runs on EPTF_ExecCtrl_CT { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_finalTestReportGeneratorFns); i<size; i:=i+1) { |
| if(v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i]==pl_reportGeneratorFn) { |
| v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i] := null; |
| } |
| } |
| } |
| |
| // calls all F.T.R. generator functions |
| private function f_EPTF_ExecCtrl_callFinalTestReportGeneratorFns(inout charstring pl_report) |
| runs on EPTF_ExecCtrl_CT { |
| for(var integer i:=0, size := sizeof(v_EPTF_ExecCtrl_finalTestReportGeneratorFns); i<size; i:=i+1) { |
| if(v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i]!=null) { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Calling final test report generator function: ",v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i])); |
| v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i].apply(pl_report); |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Final test report generator function finished: ",v_EPTF_ExecCtrl_finalTestReportGeneratorFns[i])); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_generateFinalTestReport |
| // |
| // Purpose: |
| // generates the final test report |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // Called automatically if the Exit Button is pressed, |
| // or when any LGen detects the exit event in LGenBase |
| // (added to the postproc of the exit button also) |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_generateFinalTestReport() |
| runs on EPTF_ExecCtrl_CT { |
| if (tsp_EPTF_ExecCtrl_finalTestReportFile=="") { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": No report generated: Final test report generation is disabled")); |
| return; // final test report generation is disabled |
| } |
| if (v_ExecCtrl_endOfTest) { |
| return; // test already ended, prevent multiple report generation |
| } |
| v_ExecCtrl_endOfTest:=true; |
| |
| // collect reports from all LGens: |
| f_EPTF_ExecCtrl_sendEofTestToAllLGens(); |
| |
| // call ExecCtrl report generators: |
| f_EPTF_ExecCtrl_callFinalTestReportGeneratorFns(v_EPTF_ExecCtrl_finalTestReport); |
| // write report to file: |
| if (v_EPTF_ExecCtrl_finalTestReport=="") { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": No report generated: Generated final test report is empty. If You want so, please set tsp_EPTF_ExecCtrl_finalTestReportFile to empty string.")); |
| return; // no report available |
| } |
| var charstring vl_generatedAt := f_getTimeFormatted(float2int(f_EPTF_Base_getAbsTimeInSecs()),"\nGenerated at: %Y/%m/%d %H:%M:%S\n\n"); |
| var charstring vl_textWritten := f_EPTF_ExecCtrl_writeToFile( |
| "----------------------------\n"& |
| "- Final test report -\n"& |
| "----------------------------\n"& |
| vl_generatedAt& |
| v_EPTF_ExecCtrl_finalTestReport&"\n"& |
| "----------------------------\n"& |
| "- End of final test report -\n"& |
| "----------------------------\n", |
| tsp_EPTF_ExecCtrl_finalTestReportFile |
| ) |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Final test report is written to file: "&vl_textWritten)); |
| f_EPTF_ExecCtrl_setStatusEndOfTest(); |
| } |
| |
| // Own final test report generator function |
| private function f_EPTF_ExecCtrl_generateOwnFinalTestReport(inout charstring pl_report) runs on EPTF_ExecCtrl_CT { |
| var charstring vl_report := "\n---- ExecCtrl Final Report ----\n"; |
| // for all traffic cases write stattistics data to the report: |
| for(var integer tcIdx:=0; tcIdx<f_EPTF_ExecCtrl_numTrafficCases(); tcIdx:=tcIdx+1) { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx) |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| var charstring vl_statName; |
| var integer vl_idx; |
| var charstring vl_varName; |
| |
| vl_report := vl_report & "\nTraffic case stats for EntityGroup: "&vl_eGrpName&", Scenario: "&vl_scTypeName&", TrafficCase: "&vl_tcName&"\n"; |
| // instanceName: |
| vl_report := vl_report &"InstanceName : " &f_EPTF_ExecCtrl_getTrafficCaseName(tcIdx)&"\n"; |
| // state: |
| vl_varName := "ExecCtrl.trafficCaseStatus."&vl_eGrpName&"."&vl_scTypeName&"."&vl_tcName; //widget: vl_namePrefix&".StatusLED"; |
| vl_idx := f_EPTF_Var_getId(vl_varName); |
| if (vl_idx==-1) { |
| vl_report := vl_report & "State : " &"N/A\n"; |
| // variable not found |
| } else { |
| var EPTF_StatusLED vl_statusLed := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| var charstring vl_strValue := vl_statusLed.text; |
| vl_report := vl_report &"State : " &vl_strValue&"\n"; |
| } |
| // all stats |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcStatNames); st<size;st:=st+1) { |
| if (st==c_EPTF_ExecCtrl_tcStatId_ExecTime) { |
| // execTime: |
| vl_varName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[st] |
| vl_idx := f_EPTF_Var_getId(vl_varName); |
| } else { |
| // stathandler stats: |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[st]; |
| vl_varName := f_EPTF_ExecCtrl_StatHandlerClient_getStatVariableRef(vl_statName); |
| vl_idx := f_EPTF_Var_getId(vl_varName); |
| } |
| if (vl_idx==-1) { |
| vl_report := vl_report & c_EPTF_ExecCtrl_tcStatNames[st]&" : " &"N/A\n"; |
| continue; // variable not found |
| } |
| var charstring vl_strValue := f_EPTF_Var_content2str(vl_idx); |
| vl_report := vl_report & c_EPTF_ExecCtrl_tcStatNames[st]&" : " &vl_strValue&"\n"; |
| } |
| |
| // {Delta statistics}: all stat deltas |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcDeltaStatVarIds); st<size;st:=st+1) { |
| var integer vl_tcDeltaStatVarId := c_EPTF_ExecCtrl_tcDeltaStatVarIds[st]; |
| vl_statName := vl_namePrefix&"."& c_EPTF_ExecCtrl_tcStatNames[vl_tcDeltaStatVarId] &".delta"; |
| vl_varName := f_EPTF_ExecCtrl_StatHandlerClient_getStatVariableRef(vl_statName); |
| vl_idx := f_EPTF_Var_getId(vl_varName); |
| if (vl_idx==-1) { |
| vl_report := vl_report & c_EPTF_ExecCtrl_tcStatNames[vl_tcDeltaStatVarId] &" : " &"N/A\n"; |
| continue; // variable not found |
| } |
| var charstring vl_strValue := f_EPTF_Var_content2str(vl_idx); |
| vl_report := vl_report & c_EPTF_ExecCtrl_tcStatNames[vl_tcDeltaStatVarId] &" : " &vl_strValue&"\n"; |
| } |
| } |
| vl_report := vl_report & "---- End of ExecCtrl Report ----\n"; |
| |
| // append the generated report to the original report: |
| pl_report := pl_report & vl_report; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_writeToFile |
| // |
| // Purpose: |
| // Saves pl_stringToWrite in a file |
| // |
| // Parameters: |
| // pl_stringToWrite - *in charstring* - the module parameter name to save the values into. |
| // pl_fileName - *in charstring* - the filename where the pl_stringToWrite shall be saved |
| // |
| // Return Value: |
| // charstring - name of the file the pl_stringToWrite was saved in. Empty string ("") is returned on error. |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The name of the file can be a format string where the timestamp can be specified also. |
| // For the supported time-format strings see <f_getTimeFormatted>. |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_writeToFile( |
| in charstring pl_stringToWrite, |
| in charstring pl_fileName |
| ) runs on EPTF_ExecCtrl_CT return charstring { |
| var charstring vl_filename := f_getTimeFormatted(float2int(f_EPTF_Base_getAbsTimeInSecs()),pl_fileName); |
| if (vl_filename=="") { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": cannot save data to file: filename is not specified")); |
| return ""; |
| } |
| f_EPTF_ExecCtrl_debug(log2str("vl_filename: ", vl_filename)); |
| f_EPTF_ExecCtrl_debug(log2str("pl_stringToWrite: ", pl_stringToWrite)); |
| var integer vl_fd := f_FIO_open_trunc_wronly_excl(vl_filename); |
| if (vl_fd == -1) { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": cannot open file ", vl_filename, ": ", f_FIO_get_error_string())); |
| return ""; |
| } |
| var charstring vl_fileNameSaved := vl_filename; |
| if (f_FIO_write_text(vl_fd, pl_stringToWrite) == -1) { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId&": cannot save data to file ", vl_filename, ": ", f_FIO_get_error_string())); |
| return ""; |
| }; |
| if (-1==f_FIO_close(vl_fd)) {/*to remove the warning*/}; |
| return vl_filename; |
| } |
| |
| // sends EofTest request to all LGens |
| private function f_EPTF_ExecCtrl_sendEofTestToAllLGens() |
| runs on EPTF_ExecCtrl_CT { |
| v_ExecCtrl_pendingMsgCounter := 0; |
| for(var integer lgenIdx:=0, size := sizeof(v_ExecCtrl_lgens); lgenIdx<size; lgenIdx:=lgenIdx+1) { |
| if (v_ExecCtrl_lgens[lgenIdx].lgenCompRef==-1) { |
| continue; // do not send packet to LGen if it already exited |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_EofTest:{}) to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenIdx].lgenCompRef); |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter + 1; |
| } |
| // wait until response (EofTestDone) is received from all LGens: |
| var EPTF_ExecCtrl_Condition_FN vl_checkPending := refers(f_EPTF_ExecCtrl_checkPendingMsgs); |
| f_EPTF_ExecCtrl_waitForCondition(vl_checkPending); |
| } |
| |
| private function f_EPTF_ExecCtrl_checkEndOfTest() runs on EPTF_ExecCtrl_CT return boolean { |
| return v_ExecCtrl_endOfTest; |
| } |
| |
| // |
| // EofTest message sequence: |
| // |
| // ExecCtrl ExecCtrlClient |
| // |
| // Exit button pressed |
| // OR |
| // <-- EofTest |
| // |
| // |
| // --> EofTest to all Clients |
| // ExecCtrlClients call Report generators |
| // <-- EofTestDone from all clients |
| // |
| // ExecCtrl Waits until all EofTestDone arrives |
| // ExecCtrl calls Report generators and creates the report |
| // ExecCtrl terminates execution (if manual mode false) |
| |
| // handles EofTest/EofTestDone messages coming from the LGens |
| private altstep as_EPTF_ExecCtrl_handleEofTest() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrl_EofTest vl_msg0; |
| var EPTF_ExecCtrl_EofTestDone vl_msg; |
| var EPTF_ExecCtrlClient_CT vl_client; |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_EofTestDone:?) -> value vl_msg sender vl_client { |
| v_EPTF_ExecCtrl_finalTestReport := v_EPTF_ExecCtrl_finalTestReport & vl_msg.report; |
| v_ExecCtrl_pendingMsgCounter := v_ExecCtrl_pendingMsgCounter - 1; |
| repeat; |
| } |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_EofTest:?) -> value vl_msg0 sender vl_client { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": EofTest received from ",vl_client, ". Generating final test report before exiting...")); |
| if (v_ExecCtrl_endOfTest) { |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": EofTest received from ",vl_client, ". Message dropped: Report generation is already in progress")); |
| repeat; // drop message if report generation is already in progress |
| } |
| f_EPTF_ExecCtrl_generateFinalTestReport(); |
| if(not v_ExecCtrl_manualControl) { |
| f_EPTF_Base_stopAll(none); |
| } |
| repeat; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_exit |
| // |
| // Purpose: |
| // Terminate the execution and exit, generate final test riport |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_exit() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_generateFinalTestReport(); |
| f_EPTF_ExecCtrl_sendByeToAllClients(); |
| f_EPTF_Base_stopAll(none); |
| } |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_setGenerateOwnReport |
| // |
| // Purpose: |
| // Tells that the ExecCtrl's own final report has to be generated or not |
| // |
| // Parameters: |
| // pl_generateOwnReport - *boolean* - tells that the ExecCtrl's own final |
| // report has to be generated or not. |
| // |
| // Return Value: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_setGenerateOwnReport(in boolean pl_generateOwnReport) runs on EPTF_ExecCtrl_CT |
| { |
| if(pl_generateOwnReport and not v_EPTF_ExecCtrl_generateOwnReport){ |
| f_EPTF_ExecCtrl_registerFinalTestReportGeneratorFn(refers(f_EPTF_ExecCtrl_generateOwnFinalTestReport)); |
| } else if(not pl_generateOwnReport and v_EPTF_ExecCtrl_generateOwnReport){ |
| f_EPTF_ExecCtrl_deregisterFinalTestReportGeneratorFn(refers(f_EPTF_ExecCtrl_generateOwnFinalTestReport)); |
| } |
| v_EPTF_ExecCtrl_generateOwnReport := pl_generateOwnReport; |
| } |
| |
| } // group EPTF_ExecCtrl_FinalTestReport |
| |
| |
| group EPTF_ExecCtrl_UIVars { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_InitGUILayout_vars |
| // |
| // Purpose: |
| // Function to init dynamic execution control GUI layout |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Appends varios dynamic elements to GUI in order to create execution |
| // control handling interface |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_InitGUILayout_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| // f_EPTF_ExecCtrl_UIVars_createMainImages(); |
| // f_EPTF_ExecCtrl_UIVars_createMainTab(pl_EPTF_GUI_Main_Tabbox_WidgetId); |
| f_EPTF_ExecCtrl_UIVars_AppendMainTabs_vars(); |
| // f_EPTF_ExecCtrl_UIVars_AppendEntityGroupTab(); |
| // f_EPTF_ExecCtrl_UIVars_AppendResourceTab(); |
| // f_EPTF_ExecCtrl_UIVars_AppendTrafficTab(); |
| // f_EPTF_ExecCtrl_UIVars_AppendRegulatedItemsTab(); |
| //f_EPTF_ExecCtrl_UIVars_AppendControlTab(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_AppendMainTabs_vars |
| // |
| // Purpose: |
| // Append main tabs to execution control panel |
| // |
| // Parameters: |
| // pl_EPTF_GUI_ExecCtrl_tabbox_WidgetId - *in* <EPTF_UIVars_WidgetIdString> - parent |
| // widget id |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_AppendMainTabs_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_progressBar_idx,vl_progressBarText_idx,vl_globalProgressBar_idx; |
| f_EPTF_Var_newCharstring(c_EPTF_ExecCtrl_statisticsRoot&".notif.progressbar","0.0",vl_progressBar_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_progressBar_idx,false); |
| |
| f_EPTF_Var_newCharstring(c_EPTF_ExecCtrl_statisticsRoot&".notif.progressbar.text","Creating LGen pools",vl_progressBarText_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_progressBarText_idx,false); |
| |
| f_EPTF_Var_newCharstring(c_EPTF_ExecCtrl_statisticsRoot&".notif.globalProgressbar","0.0",vl_globalProgressBar_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_globalProgressBar_idx,false); |
| |
| |
| var EPTF_Var_DirectContent vl_PTCList; |
| if (0==f_EPTF_DataSourceClient_getDataValue( |
| vl_PTCList, |
| pl_source := "DataSource", |
| pl_ptcName := "", |
| pl_element := "PTCs", |
| pl_params := { |
| { |
| paramName := "Source", |
| paramValue := "UIHandler" |
| } |
| } |
| )) { |
| if (sizeof(vl_PTCList.charstringlistVal) > 0) { |
| // to update UIHandler progressbar: |
| var charstring vl_progressBarUIHandlerName; |
| if (0==f_EPTF_DataSourceClient_getData( |
| pl_dataVarName := vl_progressBarUIHandlerName, |
| pl_source := "UIHandler", |
| pl_ptcName := "", |
| pl_element := "progressBar", |
| pl_params := {} |
| )) { |
| v_ExecCtrl_progressBarUIHandler_Idx := f_EPTF_Var_getId(vl_progressBarUIHandlerName); |
| |
| f_EPTF_Var_addPostProcFn(vl_progressBar_idx,{ |
| refers(f_EPTF_ExecCtrl_progressBar_PostProc), |
| {vl_progressBar_idx,vl_progressBarText_idx} |
| }); |
| } |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExeCtrl_enableUIHandlerProgress |
| // |
| // Purpose: |
| // Enables updates of UIHandler's progress information with ExecCtrl info |
| // |
| // Parameters: |
| // pl_enableProgress - *in* *boolean* - true: enable, false: disable |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExeCtrl_enableUIHandlerProgress(in boolean pl_enableProgress) runs on EPTF_ExecCtrl_CT { |
| v_ExecCtrl_progressEnabled := pl_enableProgress; |
| } |
| |
| |
| // copies the progressbar text to the UIHandler progressBar: |
| private function f_EPTF_ExecCtrl_progressBar_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_progressEnabled or v_ExecCtrl_progressBarUIHandler_Idx==-1 or v_ExecCtrl_progressBarUIHandler_updateSent) { |
| return; |
| } |
| var integer vl_progressBarId := pl_argList[0]; |
| var integer vl_progressBarTextId := pl_argList[1]; |
| f_EPTF_Var_adjustContent( |
| v_ExecCtrl_progressBarUIHandler_Idx, |
| { |
| charstringVal := "ExecCtrl: "&f_EPTF_Var_getCharstringValue(vl_progressBarTextId)&" "&f_EPTF_Var_getCharstringValue(vl_progressBarId)&"%" |
| } |
| ); |
| v_ExecCtrl_progressBarUIHandler_updateSent := true; |
| |
| var float vl_EPTF_ExecCtrl_timePeriodForProgressUpdate := 3.0; |
| var float vl_when := f_EPTF_Base_getRelTimeInSecs()+vl_EPTF_ExecCtrl_timePeriodForProgressUpdate; |
| var EPTF_Scheduler_ActionHandler vl_actionHandler := refers(f_EPTF_ExecCtrl_progressBarUIHandler_enabler); |
| var EPTF_ActionId vl_action := { }; // nothing |
| var integer vl_eventIndex; |
| if (f_EPTF_SchedulerComp_scheduleAction( |
| vl_when, |
| vl_actionHandler, |
| vl_action, |
| vl_eventIndex |
| )) {}; // to remove the warning |
| } |
| |
| private function f_EPTF_ExecCtrl_progressBarUIHandler_enabler(in EPTF_ScheduledAction pl_action, in integer pl_eventIndex) runs on EPTF_ExecCtrl_CT return boolean { |
| v_ExecCtrl_progressBarUIHandler_updateSent := false; |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_exit_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to exit ttcn |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_exit_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_exit(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_Subscribe2ExitButton_vars |
| // |
| // Purpose: |
| // Subscribe variable to exit button and adds test management |
| // post processing functions |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_Subscribe2ExitButton_vars() runs on EPTF_ExecCtrl_CT { |
| // Exit button |
| var integer vl_idx; |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_Exit, 0, vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_exit_PostProc), {}} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Exit button) name: " |
| &c_EPTF_ExecCtrl_Exit); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_startScenario_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to start scenario |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // This is what happens when user presses the start button at widgetId |
| // c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Start" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_startScenario_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_startScIdx := pl_argList[1]; |
| var integer vl_stopScIdx := pl_argList[2]; |
| var integer vl_resetScIdx := pl_argList[3]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startScIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopScIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_resetScIdx,false); |
| |
| // Start the scenario |
| f_EPTF_ExecCtrl_startScenarioOnLGens(vl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_stopScenario_PostProc |
| // |
| // Purpose: |
| // Test management post proc function stop scenario |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // This is what happens when user presses the stop button at widgetId |
| // c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Stop" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_stopScenario_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_startScIdx := pl_argList[1]; |
| var integer vl_stopScIdx := pl_argList[2]; |
| var integer vl_resetScIdx := pl_argList[3]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startScIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopScIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_resetScIdx,true); |
| |
| // Start the scenario |
| f_EPTF_ExecCtrl_stopScenarioOnLGens(vl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_resetScenario_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to reset scenario |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // This is what happens when user presses the reset button at widgetId |
| // c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Reset" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_resetScenario_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_startScIdx := pl_argList[1]; |
| var integer vl_stopScIdx := pl_argList[2]; |
| var integer vl_resetScIdx := pl_argList[3]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startScIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopScIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_resetScIdx,true); |
| |
| // Reset the scenario |
| f_EPTF_ExecCtrl_resetScenarioOnLGens(vl_scIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_startTc_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to start traffic case |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // This is what happens when user presses the start button at widgetId |
| // c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Start" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_startTc_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_startTcIdx := pl_argList[2]; |
| var integer vl_stopTcIdx := pl_argList[3]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startTcIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopTcIdx,true); |
| |
| // Start the tc |
| f_EPTF_ExecCtrl_startTCOnLGens(vl_scIdx,vl_tcOfScIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_stopTc_PostProc |
| // |
| // Purpose: |
| // Test management post proc function stop traffic case |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // This is what happens when user presses the stop button at widgetId |
| // c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Stop" |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_stopTc_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_startTcIdx := pl_argList[2]; |
| var integer vl_stopTcIdx := pl_argList[3]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startTcIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopTcIdx,false); |
| |
| // Start the tc |
| f_EPTF_ExecCtrl_stopTCOnLGens(vl_scIdx,vl_tcOfScIdx); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_resetStatsTc_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to reset stats of traffic case |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Resets the following statistics: Start, Success, Fail, Timeout, Error of the traffic case |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_resetStatsTc_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getScenarioTcIdx(vl_scIdx, vl_tcOfScIdx); |
| |
| // reset the stats |
| var integer vl_statHandlerCompIdx; |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers==0) { |
| vl_statHandlerCompIdx := 0; |
| } else { |
| vl_statHandlerCompIdx := vl_tcIdx mod v_EPTF_ExecCtrl_nofExternalStatHandlers; |
| } |
| var EPTF_StatHandler_CT vl_statHandler := v_EPTF_ExecCtrl_statHandler_comprefList[vl_statHandlerCompIdx]; |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScIdx) |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| var charstring vl_statName; |
| |
| var EPTF_IntegerList vl_statsToReset := { |
| c_EPTF_ExecCtrl_tcStatId_Starts, |
| c_EPTF_ExecCtrl_tcStatId_Success, |
| c_EPTF_ExecCtrl_tcStatId_Fail, |
| c_EPTF_ExecCtrl_tcStatId_Timeout, |
| c_EPTF_ExecCtrl_tcStatId_Error |
| } |
| |
| for(var integer i:=0, size:=sizeof(vl_statsToReset);i<size;i:=i+1){ |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[vl_statsToReset[i]]; |
| // var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(vl_statName); |
| var boolean vl_res := f_EPTF_StatHandlerClient_resetStatistics(vl_statName, vl_statHandler); |
| if (vl_res != true) { |
| f_EPTF_ExecCtrl_debug(log2str("Error reseting " & vl_statName)); |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_resetStatsAllTc_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| var integer vl_sizeScen := f_EPTF_ExecCtrl_numScenarios(); |
| var integer vl_sizeTCs; |
| |
| for (var integer sidx := 0; sidx < vl_sizeScen; sidx := sidx + 1){ |
| vl_sizeTCs := f_EPTF_ExecCtrl_numTcOfScenario(sidx); |
| for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1){ |
| f_EPTF_ExecCtrl_UIVars_resetStatsTc_PostProc(-1, {sidx, tcidx}); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_resetStatFunctions |
| // |
| // Purpose: |
| // Function to call all reset callback functions registered by ExecCtrl |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors & assertions: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| /////////////////////////////////////////////////////////// |
| // TR HR20548 - Reset All statistics button |
| private function f_EPTF_ExecCtrl_resetStatFunctions() |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var EPTF_Var_DirectContent vl_currentContent; |
| var charstring vl_eGrpName; |
| var charstring vl_scTypeName; |
| var charstring vl_tcName; |
| var charstring vl_namePrefix; |
| var charstring vl_statName; |
| var EPTF_TopProviderType vl_providerType; |
| var EPTF_IntegerList vl_auxVarList; |
| var integer vl_nrOfSources; |
| |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| // LGenList: v_ExecCtrl_lgens |
| var integer vl_nOfLGens := sizeof(v_ExecCtrl_lgens); |
| for(var integer vl_lgenIdx:=0;vl_lgenIdx<vl_nOfLGens;vl_lgenIdx:=vl_lgenIdx+1){ |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_ResetStats:{}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[vl_lgenIdx].lgenCompRef); |
| } |
| |
| // // go through all scenarios: |
| // var integer vl_sizeScen := f_EPTF_ExecCtrl_numScenarios(); |
| // var integer vl_sizeTCs; |
| // |
| // for (var integer sidx := 0; sidx < vl_sizeScen; sidx := sidx + 1){ |
| // var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(sidx); |
| // vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| // vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(sidx); |
| // vl_sizeTCs := f_EPTF_ExecCtrl_numTcOfScenario(sidx); |
| // for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1){ |
| // vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(sidx,tcidx) |
| // vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| // // all integer stats except CurrentCPS and ExecTime |
| // for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcStatNames); st<size;st:=st+1) { |
| // if (st==c_EPTF_ExecCtrl_tcStatId_CurrentCPS |
| // or st==c_EPTF_ExecCtrl_tcStatId_ExecTime) { |
| // continue; // they are handled differently |
| // } |
| // vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[st]; |
| // |
| // var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(vl_statName); |
| // f_EPTF_StatHandlerClient_resetStatistics(vl_statName,vl_statHandler); |
| // } |
| // } |
| // } |
| // |
| // // get statList: v_ExecCtrl_FSMStats |
| // var charstring vl_shName; |
| // var EPTF_StatHandler_StatMethod vl_statMethod; |
| // var EPTF_Var_DirectContent vl_resetValue; |
| // |
| // // for each stat |
| // for(var integer i:=0, size := sizeof(v_ExecCtrl_FSMStats); i<size;i:=i+1) { |
| // vl_eGrpName:=v_ExecCtrl_FSMStats[i].entityGroup; |
| // vl_scTypeName:=v_ExecCtrl_FSMStats[i].scenario; |
| // vl_tcName:=v_ExecCtrl_FSMStats[i].tc; |
| // |
| // for(var integer st:=0, ssize := sizeof(v_ExecCtrl_FSMStats[i].stats); st<ssize;st:=st+1) { |
| // vl_statName := v_ExecCtrl_FSMStats[i].stats[st].declaredName; |
| // // reset stat: |
| // f_EPTF_ExecCtrl_resetFSMStat(vl_eGrpName,vl_scTypeName,vl_tcName,vl_statName); |
| // } |
| // } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_resetFSMStat |
| // |
| // Purpose: |
| // Resets a given fsmStat |
| // |
| // Parameters: |
| // - pl_eGrpName - *in charstring* - the entityGroup name |
| // - pl_scenName - *in charstring* - the scenarioName |
| // - pl_tcName - *in charstring* - name of the trafficCase |
| // - pl_fsmStatName - *in charstring* - name of the fsm stat |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // The list of available FSM stats is given by the iterator |
| // <c_ExecCtrl_iteratorFSMStats> |
| // Only the min/max/sum method stats will be reset |
| // (For the others that are complex calculated stats coming from StatHandler |
| // reset is not supported yet, see <f_EPTF_StatHandler_resetStatistics>) |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_resetFSMStat( |
| in charstring pl_eGrpName, |
| in charstring pl_scTypeName, |
| in charstring pl_tcName, |
| in charstring pl_fsmStatName |
| ) runs on EPTF_ExecCtrl_CT { |
| // reset stat on ExecCtrl |
| var charstring vl_statName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scTypeName&".TC."&pl_tcName&".FSMStats."&pl_fsmStatName; |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(vl_statName); |
| if (vl_statHandler!=null) { |
| f_EPTF_StatHandlerClient_resetStatistics(vl_statName,vl_statHandler); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_resetFSMStatsTc_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to reset FSM stats of traffic case |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Resets the FSM statistics of the traffic case |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_resetFSMStatsTc_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScIdx) |
| var charstring vl_statName; |
| |
| // get statList: v_ExecCtrl_FSMStats |
| var charstring vl_fsmStatVarName := c_ExecCtrl_DS_iteratorVar_prefix & c_ExecCtrl_iteratorFSMStats_varName & "." & vl_eGrpName & "." & vl_scTypeName & "." & vl_tcName; |
| var integer vl_fsmStatsId := f_EPTF_Var_getId(vl_fsmStatVarName); |
| var EPTF_CharstringList vl_fsmStats := f_EPTF_Var_getCharstringlistValue(vl_fsmStatsId); |
| |
| // for each stat |
| for(var integer i:=0, size := sizeof(vl_fsmStats); i<size;i:=i+1) { |
| |
| // reset stat: |
| f_EPTF_ExecCtrl_resetFSMStat(vl_eGrpName,vl_scTypeName,vl_tcName,vl_fsmStats[i]); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_resetFSMStatsAllTc_PostProc(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| var integer vl_sizeScen := f_EPTF_ExecCtrl_numScenarios(); |
| var integer vl_sizeTCs; |
| |
| for (var integer sidx := 0; sidx < vl_sizeScen; sidx := sidx + 1){ |
| vl_sizeTCs := f_EPTF_ExecCtrl_numTcOfScenario(sidx); |
| for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1){ |
| f_EPTF_ExecCtrl_UIVars_resetFSMStatsTc_PostProc(-1, {sidx, tcidx}); |
| } |
| } |
| } |
| |
| // calculates the StatusLED for the group finish condition state |
| friend function f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinish( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType := c_EPTF_ExecCtrl_groupFinishConditionUnknown |
| ) runs on EPTF_ExecCtrl_CT return EPTF_StatusLED |
| { |
| var EPTF_StatusLED vl_statusLED := {color := led_blue, text := "None fired"}; |
| if (f_EPTF_ExecCtrl_checkOnGroupFinished(pl_tcIdx,pl_conditionType)) { |
| vl_statusLED.color := led_red; |
| // check if onGroupFinish is fired: |
| if (pl_conditionType==c_EPTF_ExecCtrl_groupFinishConditionUnknown) { |
| vl_statusLED.text := "OnGroupFinish fired" |
| } else if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_ExecTime) { |
| vl_statusLED.text := "ExecTime fired" |
| } else if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_RangeLoops) { |
| vl_statusLED.text := "RangeLoops fired" |
| } else if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_EntitiesFinished) { |
| vl_statusLED.text := "EntitiesFinished fired" |
| } else if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_AvailableEntitiesFinished) { |
| vl_statusLED.text := "AvailableEntitiesFinished fired" |
| } else if (pl_conditionType==c_EPTF_ExecCtrl_groupFinish_Custom) { |
| vl_statusLED.text := "Custom fired" |
| } else { |
| vl_statusLED.text := c_EPTF_ExecCtrl_nameOfVarsInLGen[pl_conditionType]&" fired" |
| } |
| } |
| return vl_statusLED; |
| } |
| |
| // creates TC entity stats using the statHandler API for the traffic case |
| private function f_EPTF_ExecCtrl_UIVars_createStatsForTc_vars(in integer pl_tcIdx) |
| runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx) |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| var charstring vl_statName; |
| |
| // declare stats: |
| f_EPTF_ExecCtrl_debug("Declaring TC statistics for "&vl_namePrefix); |
| |
| // CurrentCPS: |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_CurrentCPS]; // c_EPTF_ExecCtrl_tcStatId_CurrentCPS == 0 |
| v_EPTF_ExecCtrl_statHandler_autoSelector := pl_tcIdx; // use same StatHandler for the Stats of the same TC |
| if (not f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| pl_statName := vl_statName, |
| pl_statMethod := c_EPTF_StatHandler_Method_Sum, |
| pl_statResetValue := {floatVal := 0.0} |
| )) { |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare Statistics: ", vl_statName)); |
| } else { |
| } |
| |
| // all integer stats except CurrentCPS and ExecTime |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcStatNames); st<size;st:=st+1) { |
| if (st==c_EPTF_ExecCtrl_tcStatId_CurrentCPS |
| or st==c_EPTF_ExecCtrl_tcStatId_ExecTime) { |
| continue; // they are handled differently |
| } |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[st]; |
| v_EPTF_ExecCtrl_statHandler_autoSelector := pl_tcIdx; // use same StatHandler for the Stats of the same TC |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| pl_statName := vl_statName, |
| pl_statMethod := c_EPTF_StatHandler_Method_Sum, |
| pl_statResetValue := {intVal := 0} |
| )) { |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare Statistics: ", vl_statName)); |
| } else { |
| } |
| } |
| |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForStats := sampledAtSync; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForStats := pull; |
| } |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForVars := sampled; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForVars := pull; |
| } |
| // register sources: |
| // name of source variable on the LGen: |
| var charstring vl_lgenDataSourceVarName := f_EPTF_LGenBaseStats_getNamePrefix(vl_eGrpName,vl_scTypeName,vl_tcName); |
| var EPTF_ExecCtrl_EntityGroupDistributionList vl_lgenList := f_EPTF_ExecCtrl_eGrp_lgenList(vl_eGrpIdx); |
| for(var integer lg:=0, size := sizeof(vl_lgenList); lg<size;lg:=lg+1) { |
| if (vl_lgenList[lg].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| var integer vl_lgenIdx := vl_lgenList[lg].lgenIdx; |
| |
| // CurrentCPS |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_CurrentCPS]; // c_EPTF_ExecCtrl_tcStatId_CurrentCPS == 0 |
| if (not f_EPTF_ExecCtrl_StatHandlerClient_registerStat( |
| pl_providerVarList := {vl_lgenDataSourceVarName&c_EPTF_ExecCtrl_tcStatVarNamesInLGen[c_EPTF_ExecCtrl_tcStatId_CurrentCPS]}, |
| pl_statName := vl_statName, |
| pl_subscriptionMode := vl_subscriptionModeForStats, |
| pl_wait4response := true,//tsp_EPTF_ExecCtrl_StatHandler_wait4response, |
| pl_sourceCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(f_EPTF_ExecCtrl_getLGenCompRef(vl_lgenIdx))), |
| pl_refreshRate := 0//v_ExecCtrl_UIVars_refreshRate_currentCPS |
| )) {/*cannot happen*/}; |
| |
| // all integer stats |
| for(var integer st:=0, tsize := sizeof(c_EPTF_ExecCtrl_tcStatNames); st<tsize;st:=st+1) { |
| if (st==c_EPTF_ExecCtrl_tcStatId_CurrentCPS |
| or st==c_EPTF_ExecCtrl_tcStatId_ExecTime) { |
| continue; // they are handled differently |
| } |
| vl_statName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[st]; |
| if (not f_EPTF_ExecCtrl_StatHandlerClient_registerStat( |
| pl_providerVarList := {vl_lgenDataSourceVarName&c_EPTF_ExecCtrl_tcStatVarNamesInLGen[st]}, |
| pl_statName := vl_statName, |
| pl_subscriptionMode := vl_subscriptionModeForStats, |
| pl_wait4response := true,//tsp_EPTF_ExecCtrl_StatHandler_wait4response, |
| pl_sourceCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(f_EPTF_ExecCtrl_getLGenCompRef(vl_lgenIdx))), |
| pl_refreshRate := 0//v_ExecCtrl_UIVars_refreshRate_TCStats |
| )) {/*cannot happen*/}; |
| } |
| } |
| |
| // {Delta statistics}: all delta stats - Create new StatMeasure |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcDeltaStatVarIds); st<size;st:=st+1) { |
| var integer vl_tcDeltaStatVarId := c_EPTF_ExecCtrl_tcDeltaStatVarIds[st]; |
| var charstring vl_varBaseName := vl_namePrefix&"."&c_EPTF_ExecCtrl_tcStatNames[vl_tcDeltaStatVarId]; |
| var charstring vl_statBaseName := vl_varBaseName; |
| |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(vl_varBaseName); |
| if (vl_statHandler != self) { |
| |
| // wait until war exists: |
| timer t_wait := 0.5; |
| var boolean vl_present := false; |
| while(true) { |
| if (f_EPTF_Var_isPresentRemote(vl_statHandler,vl_varBaseName)) { |
| break; |
| } else { |
| t_wait.start; |
| t_wait.timeout; |
| } |
| } |
| |
| var integer vl_idx; |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := vl_statHandler, |
| pl_remoteProviderVarName := vl_varBaseName, |
| pl_subscriptionMode := vl_subscriptionModeForVars, |
| pl_idx := vl_idx, |
| pl_localName := vl_varBaseName&"_Local" |
| ); |
| vl_varBaseName := f_EPTF_Var_getName(vl_idx); |
| } |
| |
| var charstring vl_varDeltaName := vl_statBaseName&".delta"; |
| var integer vl_varBaseId := f_EPTF_Var_getId(vl_varBaseName); |
| if(vl_varBaseId<0) { |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare delta Statistics - base variable Id not found: ", vl_varDeltaName,"->",vl_varBaseName)); |
| } else { |
| var integer vl_statDeltaId := f_EPTF_StatMeasure_newStat_delta(); |
| if(vl_statDeltaId<0) { |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare delta Statistics: ", vl_varDeltaName)); |
| } else { |
| f_EPTF_StatMeasure_addData_delta(vl_statDeltaId,{intVal := 0}); |
| var integer vl_deltaStatVarId := f_EPTF_StatMeasure_createVarFromStat(vl_statDeltaId, vl_varDeltaName); |
| if(vl_deltaStatVarId<0){ |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare delta Statistics - create Var From Stat fail: ", vl_varDeltaName)); |
| } else { |
| // add Scheduler that updates the stat periodically: |
| f_EPTF_ExecCtrl_registerUpdateEventForTc_delta_Stat(pl_tcIdx,vl_statDeltaId, vl_varBaseId); |
| } |
| } |
| } |
| } |
| |
| //request GoS from StatManager so that getData handler would not block when GoS is requested |
| var charstring pl_dataVarName; |
| var charstring vl_nofSuccVarName,vl_nofFailVarName,vl_nofTimeoutVarName,vl_nofErrorVarName; |
| vl_nofSuccVarName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_Success] |
| vl_nofFailVarName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_Fail] |
| vl_nofErrorVarName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_Error] |
| vl_nofTimeoutVarName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&"."&c_EPTF_ExecCtrl_tcStatNames[c_EPTF_ExecCtrl_tcStatId_Timeout] |
| var charstring vl_statManagerPTCName := f_EPTF_Base_selfName(); |
| if (v_EPTF_ExecCtrl_nofExternalStatHandlers>0) { |
| vl_statManagerPTCName := "ExecCtrl_ExternalStatHandler_Comp_"&log2str(pl_tcIdx mod v_EPTF_ExecCtrl_nofExternalStatHandlers) |
| } |
| if (0 != f_EPTF_DataSourceClient_getData( |
| pl_dataVarName := pl_dataVarName, |
| pl_source := "StatManager", |
| pl_ptcName := vl_statManagerPTCName, |
| pl_element := "GoS", |
| pl_params := { |
| {paramName := "SuccessVarName", paramValue := vl_nofSuccVarName}, |
| {paramName := "FailVarName", paramValue := vl_nofFailVarName}, |
| {paramName := "TimeoutVarName", paramValue := vl_nofTimeoutVarName}, |
| {paramName := "ErrorVarName", paramValue := vl_nofErrorVarName} |
| } |
| )) { |
| pl_dataVarName := "GoS does not exist" |
| } |
| |
| } |
| |
| // creates scheduled event for TC entity stat deltas using the statHandler API for the traffic case |
| private function f_EPTF_ExecCtrl_registerUpdateEventForTc_delta_Stat(in integer pl_tcIdx, in integer pl_statisticsId, in integer pl_variableId) |
| runs on EPTF_ExecCtrl_CT { |
| if(vl_eventIndexUpdateEvent==-1){ |
| var float vl_when := f_EPTF_Base_getRelTimeInSecs()+v_EPTF_ExecCtrl_timePeriodForTcDeltaStats; |
| var EPTF_Scheduler_ActionHandler vl_actionHandler := refers(f_EPTF_ExecCtrl_updateDeltaStatVarForTcSyncCallBack); |
| var EPTF_ActionId vl_action := { 0 }; // nothing |
| var integer vl_eventIndex; |
| if (f_EPTF_SchedulerComp_scheduleAction( |
| vl_when, |
| vl_actionHandler, |
| vl_action, |
| vl_eventIndex |
| )) {}; // to remove the warning |
| // store event idx: |
| vl_eventIndexUpdateEvent := vl_eventIndex; |
| } |
| f_EPTF_Base_assert(%definitionId&": Invalid index "&int2str(pl_tcIdx)& |
| ". Valid index range: (0.."&int2str(sizeof(v_ExecCtrl_trafficCases))&").", |
| pl_tcIdx >= 0 and pl_tcIdx < sizeof(v_ExecCtrl_trafficCases)); |
| // Put it into table |
| var integer vl_nextIdx := sizeof(v_ExecCtrl_trafficCases[pl_tcIdx].deltaStatList); |
| v_ExecCtrl_trafficCases[pl_tcIdx].deltaStatList[vl_nextIdx] := {pl_statisticsId, pl_variableId}; |
| } |
| |
| // the function that updates the delta stats pl_argList[0] : the statId |
| private function f_EPTF_ExecCtrl_updateDeltaStatVarForTcSyncCallBack(in EPTF_ScheduledAction pl_action, in integer pl_eventIndex) runs on EPTF_ExecCtrl_CT return boolean { |
| var boolean vl_ret := f_EPTF_Base_cleanupIsInProgress(); |
| if(vl_ret == true){ |
| // all down the line |
| for(var integer idx:=0, size := sizeof(v_ExecCtrl_trafficCases); idx<size;idx:=idx+1){ |
| // If Running |
| var boolean vl_tcStatus := f_EPTF_ExecCtrl_isTcRunning(idx); |
| if(vl_tcStatus == true){ |
| for(var integer st:=0, dsize := sizeof(v_ExecCtrl_trafficCases[idx].deltaStatList); st<dsize;st:=st+1){ |
| var integer vl_statisticsId := v_ExecCtrl_trafficCases[idx].deltaStatList[st].statisticsId; |
| var integer vl_variableId := v_ExecCtrl_trafficCases[idx].deltaStatList[st].variableId; |
| var integer vl_variableValue := f_EPTF_Var_getIntValue(vl_variableId); |
| f_EPTF_StatMeasure_addData_delta(vl_statisticsId,{intVal := vl_variableValue}); |
| } |
| } |
| } |
| var float vl_when := pl_action.when + v_EPTF_ExecCtrl_timePeriodForTcDeltaStats; |
| var EPTF_Scheduler_ActionHandler vl_actionHandler := refers(f_EPTF_ExecCtrl_updateDeltaStatVarForTcSyncCallBack); |
| var EPTF_ActionId vl_action := { 0 }; // nothing |
| var integer vl_eventIndex; |
| if (f_EPTF_SchedulerComp_scheduleAction( |
| vl_when, |
| vl_actionHandler, |
| vl_action, |
| vl_eventIndex |
| )) {}; // to remove the warning |
| // store event idx: |
| vl_eventIndexUpdateEvent := vl_eventIndex; |
| } |
| return(vl_ret); |
| } |
| |
| // creates Global stats using the statHandler API |
| private function f_EPTF_ExecCtrl_UIVars_createGlobalStats_vars() |
| runs on EPTF_ExecCtrl_CT { |
| |
| // create itertor var which contains all global stats: |
| var integer vl_idx; |
| f_EPTF_Var_newCharstringlist(c_ExecCtrl_DS_iteratorVar_prefix & c_ExecCtrl_iteratorGlobalStats_varName, c_EPTF_ExecCtrl_globalStatNames, vl_idx); |
| |
| // declare all global stats: |
| // all integer global stats |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_globalStatNames); st<size;st:=st+1) { |
| var charstring vl_globalStatName := c_EPTF_ExecCtrl_globalStatNames[st]; |
| var charstring vl_globalStatNameFull := c_EPTF_ExecCtrl_statisticsRoot&"."&vl_globalStatName; |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| pl_statName := vl_globalStatNameFull, |
| pl_statMethod := c_EPTF_StatHandler_Method_Sum, |
| pl_statResetValue := {intVal := 0} |
| )) { |
| f_EPTF_ExecCtrl_error(log2str(%definitionId&": Cannot declare Statistics: ", vl_globalStatName)); |
| } |
| } |
| |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForStats := sampledAtSync; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForStats := pull; |
| } |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForVars := sampled; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForVars := pull; |
| } |
| // register sources: |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_globalStatNames); st<size;st:=st+1) { |
| |
| var charstring vl_globalStatName := c_EPTF_ExecCtrl_globalStatNames[st]; |
| |
| // have to sum all values => go through all TC-s: |
| for(var integer tc:=0, tsize := sizeof(v_ExecCtrl_trafficCases); tc<tsize;tc :=tc+1) { |
| var integer sc := v_ExecCtrl_trafficCases[tc].scenarioIdx; |
| var charstring vl_entityGrpName := v_ExecCtrl_entityGroups[v_ExecCtrl_scenarios[sc].eGroupIdx].name; |
| var charstring vl_scName := v_ExecCtrl_scenarios[sc].scData.name; |
| var charstring vl_tcName := v_ExecCtrl_scenarios[sc].scData.tcList[v_ExecCtrl_trafficCases[tc].tcOfScenarioIdx].tcPrivateName; |
| |
| |
| // name of source variable: |
| var charstring vl_dataVarName; |
| var charstring vl_statName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_entityGrpName&".SC."&vl_scName&".TC."&vl_tcName&"."&vl_globalStatName; |
| var EPTF_StatHandler_CT vl_statHandler := f_EPTF_ExecCtrl_findStatHandler(vl_statName); |
| if (vl_statHandler!=self) { |
| f_EPTF_Var_subscribeRemote( |
| pl_remoteCompRef := vl_statHandler, |
| pl_remoteProviderVarName := vl_statName, |
| pl_subscriptionMode := vl_subscriptionModeForVars, |
| pl_idx := vl_idx, |
| pl_localName := vl_statName&"_Local" |
| ); |
| if (vl_idx==-1) { |
| f_EPTF_ExecCtrl_warning(%definitionId& ": Statistic doesn't exist: "&vl_statName); |
| continue; |
| } |
| vl_dataVarName := f_EPTF_Var_getName(vl_idx); |
| } else { |
| if (not f_EPTF_StatHandler_getVarNameByStatName(vl_statName, vl_dataVarName)){ |
| f_EPTF_ExecCtrl_warning(%definitionId& ": Statistic doesn't exist: "&vl_statName); |
| continue; |
| } |
| } |
| var charstring vl_globalStatNameFull := c_EPTF_ExecCtrl_statisticsRoot&"."&vl_globalStatName; |
| if (not f_EPTF_ExecCtrl_StatHandlerClient_registerStat( |
| pl_providerVarList := {vl_dataVarName}, |
| pl_statName := vl_globalStatNameFull, |
| pl_subscriptionMode := vl_subscriptionModeForStats, |
| pl_wait4response := true,//tsp_EPTF_ExecCtrl_StatHandler_wait4response, |
| pl_sourceCompRef := self, |
| pl_refreshRate := 0//v_ExecCtrl_UIVars_refreshRate_TCStats |
| )) {/*cannot happen*/}; |
| } |
| } |
| } |
| |
| // Test Case is Runing? |
| friend function f_EPTF_ExecCtrl_isTcRunning(in integer pl_tcIdx) runs on EPTF_ExecCtrl_CT return boolean { |
| var boolean vl_ret := false; |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx) |
| var EPTF_ExecCtrl_TCName vl_idName := {vl_eGrpName,vl_scTypeName,vl_tcName}; |
| vl_ret := f_EPTF_ExecCtrl_checkTrafficCaseStatus(vl_idName, |
| c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]); |
| |
| return(vl_ret); |
| } |
| |
| |
| friend function f_EPTF_ExecCtrl_UIVars_tcStatId2GrpFinishConditionType( |
| in EPTF_ExecCtrl_TcStatId pl_tcStatId |
| ) return EPTF_ExecCtrl_GrpFinishConditionType { |
| if (pl_tcStatId==c_EPTF_ExecCtrl_tcStatId_RangeLoops) { |
| return c_EPTF_ExecCtrl_groupFinish_RangeLoops; |
| } |
| if (pl_tcStatId==c_EPTF_ExecCtrl_tcStatId_FinTraffic) { |
| return c_EPTF_ExecCtrl_groupFinish_EntitiesFinished; |
| } |
| if (pl_tcStatId==c_EPTF_ExecCtrl_tcStatId_ExecTime) { |
| return c_EPTF_ExecCtrl_groupFinish_ExecTime; |
| } |
| if (pl_tcStatId==c_EPTF_ExecCtrl_tcStatId_Unknown |
| or pl_tcStatId<c_EPTF_ExecCtrl_tcStatId_Starts |
| or pl_tcStatId>c_EPTF_ExecCtrl_tcStatId_Error) { |
| return c_EPTF_ExecCtrl_groupFinishConditionUnknown; |
| } |
| // the rest are in the same order: simply subtracting the offset of Starts works: |
| return pl_tcStatId - c_EPTF_ExecCtrl_tcStatId_Starts; |
| } |
| |
| friend function f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinishCond( |
| in integer pl_tcIdx, |
| in EPTF_ExecCtrl_GrpFinishConditionType pl_conditionType |
| ) runs on EPTF_ExecCtrl_CT return EPTF_StatusLED { |
| var EPTF_StatusLED vl_EPTF_StatusLED := c_EPTF_ExecCtrl_UIVars_GroupFinishCondStatusLED_init; |
| |
| // if condition is monitored: set text to the threshold |
| var integer vl_threshold := f_EPTF_ExecCtrl_getThreshold(pl_tcIdx,pl_conditionType); |
| if (vl_threshold!=-1) { |
| vl_EPTF_StatusLED.text := int2str(vl_threshold); |
| vl_EPTF_StatusLED.color := led_blue; |
| } |
| var float vl_thresholdFloat := f_EPTF_ExecCtrl_getThresholdFloat(pl_tcIdx,pl_conditionType); |
| if (vl_thresholdFloat>=0.0) { |
| vl_EPTF_StatusLED.text := float2str(vl_thresholdFloat); |
| vl_EPTF_StatusLED.color := led_blue; |
| } |
| |
| var boolean vl_thresholdBoolean := f_EPTF_ExecCtrl_getThresholdBoolean(pl_tcIdx,pl_conditionType); |
| if (vl_thresholdBoolean) { |
| vl_EPTF_StatusLED.text := "On"; |
| vl_EPTF_StatusLED.color := led_blue; |
| } |
| // if pl_conditionType condition is fired: set color to red if the condition is monitored |
| if (vl_EPTF_StatusLED.color == led_blue |
| and f_EPTF_ExecCtrl_checkOnGroupFinished(pl_tcIdx,pl_conditionType) |
| and pl_conditionType != c_EPTF_ExecCtrl_groupFinishConditionUnknown) { |
| vl_EPTF_StatusLED.color := led_red |
| } |
| return vl_EPTF_StatusLED; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_createVarsForGroupFinishCondStatusLEDsForTc_vars(in integer pl_tcIdx) runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx) |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| |
| var charstring vl_currentName; // name of variable to connect |
| var charstring vl_widgetId; // name of widgetId to connect to |
| var integer vl_idx; // index of vars |
| |
| |
| // create GroupFinishCondStatusLED for all groupFinisih conditions: |
| for(var integer st:=0, size := sizeof(c_EPTF_ExecCtrl_tcStatNames); st<size;st:=st+1) { |
| var EPTF_ExecCtrl_GrpFinishConditionType vl_grpFinishConditionType := f_EPTF_ExecCtrl_UIVars_tcStatId2GrpFinishConditionType(st); |
| if (vl_grpFinishConditionType == c_EPTF_ExecCtrl_groupFinishConditionUnknown) { |
| continue; // no conditions for these stats |
| } |
| |
| // GroupFinishCondStatusLED: |
| vl_widgetId := vl_namePrefix&".GroupFinishCondStatusLED."&c_EPTF_ExecCtrl_tcStatNames[st]; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinishCond(pl_tcIdx,vl_grpFinishConditionType), |
| vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_singleShotPostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_tcIdx := pl_argList[0]; |
| var integer vl_eIdx_Idx := pl_argList[1]; |
| var integer vl_enableLog_Idx := pl_argList[2]; |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(vl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(vl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx); |
| |
| var integer vl_eIdx := f_EPTF_Var_getIntValue(vl_eIdx_Idx); |
| var boolean vl_enableLog := f_EPTF_Var_getBoolValue(vl_enableLog_Idx); |
| f_EPTF_ExecCtrl_singleShotTc(vl_tcIdx,vl_eIdx,vl_enableLog); |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_connectVarsToStatisticsTabForTc_vars(in integer pl_tcIdx) |
| runs on EPTF_ExecCtrl_CT { |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdxForTc(pl_tcIdx); |
| var integer vl_tcOfScenarioIdx := f_EPTF_ExecCtrl_getTcOfScenarioIdx(pl_tcIdx); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcOfScenarioIdx) |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName; |
| |
| var charstring vl_currentName; // name of variable to connect |
| var charstring vl_widgetId; // name of widgetId to connect to |
| var integer vl_eIdx_Idx, vl_enableLog_Idx, vl_idx; // index of vars |
| |
| // entityStats: |
| f_EPTF_ExecCtrl_UIVars_createStatsForTc_vars(pl_tcIdx); |
| |
| // CPS Chart: |
| // f_EPTF_ExecCtrl_UIVars_createStatsForTcCPSChart(pl_tcIdx); |
| |
| // group finish conditions: |
| f_EPTF_ExecCtrl_UIVars_createVarsForGroupFinishCondStatusLEDsForTc_vars(pl_tcIdx); |
| |
| // ExecTime: |
| vl_widgetId := vl_namePrefix&".ExecTime"; |
| vl_currentName := vl_widgetId; |
| |
| vl_idx := f_EPTF_ExecCtrl_getTrafficCaseExecTimeStatId(pl_tcIdx); |
| if(-1==f_EPTF_StatMeasure_createVarFromStat( |
| vl_idx,vl_currentName)) {/*cannot happen*/} |
| |
| // single shot params/button |
| |
| // entity index: |
| vl_widgetId := vl_namePrefix&".SingleShotTc.EIdx"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, -1, vl_eIdx_Idx); |
| |
| // enableLog checkbox: |
| vl_widgetId := vl_namePrefix&".SingleShotTc.EnableLog"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newBool( |
| vl_currentName, false, vl_enableLog_Idx); |
| |
| // singleShot button: |
| vl_widgetId := vl_namePrefix&".SingleShotTc.Start"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_idx); |
| |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_singleShotPostProc), {pl_tcIdx,vl_eIdx_Idx,vl_enableLog_Idx}} |
| ); |
| // f_EPTF_UIVarsClient_enableGUIElement(vl_widgetId); |
| |
| } |
| |
| // creates SC entity stats using the statHandler API for the scenario |
| private function f_EPTF_ExecCtrl_UIVars_createStatsForSc_vars(in integer pl_scIdx) |
| runs on EPTF_ExecCtrl_CT { |
| if (not f_EPTF_ExecCtrl_isWeightedScenario(pl_scIdx)) { |
| return; // for non-weighted scenarios there is no CPS stat |
| } |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(pl_scIdx); |
| |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(pl_scIdx); |
| var charstring vl_scName := f_EPTF_ExecCtrl_getScenarioInstanceName(pl_scIdx); |
| var charstring vl_namePrefix := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName; |
| var charstring vl_statName; |
| |
| // declare stats: |
| f_EPTF_ExecCtrl_debug("Declaring SC statistics for "&vl_namePrefix); |
| |
| // CurrentCPS: |
| vl_statName := vl_namePrefix&".CurrentCPS"; |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_declareStat( |
| pl_statName := vl_statName, |
| pl_statMethod := c_EPTF_StatHandler_Method_Sum, |
| pl_statResetValue := {floatVal := 0.0} |
| )) {/*cannot happen*/} else { |
| }; |
| |
| var EPTF_Var_SubscriptionMode vl_subscriptionModeForStats := sampledAtSync; |
| if (v_ExecCtrl_usePullModeForStats) { |
| vl_subscriptionModeForStats := pull; |
| } |
| var charstring vl_lgenDataSourceVarName := f_EPTF_LGenBaseStats_getScNamePrefix(vl_eGrpName,vl_scTypeName); |
| var EPTF_ExecCtrl_EntityGroupDistributionList vl_lgenList := f_EPTF_ExecCtrl_eGrp_lgenList(vl_eGrpIdx); |
| for(var integer lg:=0, size := sizeof(vl_lgenList); lg<size;lg:=lg+1) { |
| if (vl_lgenList[lg].eCount == 0) { |
| continue; // do not send packet to LGen if there is no entity on the LGen |
| } |
| var integer vl_lgenIdx := vl_lgenList[lg].lgenIdx; |
| // CurrentCPS |
| // FIXME IN LGenBase: NO CURRENT CPS FOR WEIGHTED SCENARIO!!!!!!!! => Calculating here |
| for (var integer tc:=0; tc<f_EPTF_ExecCtrl_getScenarioTcIdxListSize(pl_scIdx);tc:=tc+1) { |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(pl_scIdx,tc) |
| var charstring vl_lgenDataSourceVarName_Tc_CPS := f_EPTF_LGenBaseStats_getNamePrefix(vl_eGrpName,vl_scTypeName,vl_tcName); |
| if(not f_EPTF_ExecCtrl_StatHandlerClient_registerStat( |
| pl_providerVarList := {vl_lgenDataSourceVarName_Tc_CPS&c_EPTF_LGenBaseStats_nameOfTcLastCps}, |
| pl_statName := vl_namePrefix&".CurrentCPS", |
| pl_subscriptionMode := vl_subscriptionModeForStats, |
| pl_wait4response := true,//tsp_EPTF_ExecCtrl_StatHandler_wait4response, |
| pl_sourceCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(f_EPTF_ExecCtrl_getLGenCompRef(vl_lgenIdx))), |
| pl_refreshRate := 0//v_ExecCtrl_UIVars_refreshRate_currentCPS |
| )) {/*cannot happen*/}; |
| } |
| |
| // f_EPTF_StatHandlerClient_registerStat( |
| // pl_providerVarList := {vl_lgenDataSourceVarName&c_EPTF_LGenBaseStats_nameOfCURRENT_CPS}, // MISSING IN LGenBase |
| // pl_statName := vl_namePrefix&".CurrentCPS", |
| // pl_subscriptionMode := realtime, |
| // pl_wait4response := false, |
| // pl_sourceCompRef := f_EPTF_Var_downcast(f_EPTF_Base_downcast(f_EPTF_ExecCtrl_getLGenCompRef(vl_lgenIdx))) |
| // ); |
| |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_eGrp_activeEntities_GuardFn |
| // |
| // Purpose: |
| // Guard function for the activeEntities of the entity groups |
| // |
| // Parameters: |
| // pl_idx - *in integer* - id of the varible containing the number of active entities |
| // pl_argList - *in* <EPTF_IntegerList> - its 0-th element is the index of the entity group in v_ExecCtrl_entityGroups |
| // pl_newContent - *in* <EPTF_Var_DirectContent> - the new value to be set |
| // |
| // Return Value: |
| // integer - true if accepted, false if not |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_eGrp_activeEntities_GuardFn(in integer pl_idx, in EPTF_IntegerList pl_argList, in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| var integer vl_eGrpIdx := pl_argList[0]; |
| var integer vl_newActiveEntities := pl_newContent.intVal; |
| if (vl_newActiveEntities<0) { |
| vl_newActiveEntities := 0; |
| f_EPTF_Var_adjustContent(pl_idx, {intVal := vl_newActiveEntities}); |
| return false; |
| } |
| var integer vl_allocatedEntities := f_EPTF_ExecCtrl_getAllocatedEntities(vl_eGrpIdx); |
| if (vl_newActiveEntities>vl_allocatedEntities) { |
| vl_newActiveEntities := vl_allocatedEntities; |
| f_EPTF_Var_adjustContent(pl_idx, {intVal := vl_newActiveEntities}); |
| return false; |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_eGrp_activeEntities_PostProcFn |
| // |
| // Purpose: |
| // PostProc function for the active entities to distribute the value |
| // on the LGens |
| // |
| // Parameters: |
| // pl_idx - *in integer* - id of the varible containing the number of active entities |
| // pl_argList - *in* <EPTF_IntegerList> - its 0-th element is the index of the entity group in v_ExecCtrl_entityGroups |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_eGrp_activeEntities_PostProcFn(in integer pl_idx, in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| var integer vl_eGrpIdx := pl_argList[0]; |
| var integer vl_newValue := f_EPTF_Var_getIntValue(pl_idx); |
| f_EPTF_ExecCtrl_debug(log2str("Active entities for the EGrp ",f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx), " is set to ",vl_newValue)); |
| //distribute active entities among the LGens to which the entity group is deployed |
| f_EPTF_ExecCtrl_sendUpdatedActiveEntities(vl_eGrpIdx); |
| f_EPTF_ExecCtrl_sendCurrentCPSForAllSCInEGrp(vl_eGrpIdx); |
| } |
| |
| // connects the widges on the Statistics tab to variables |
| private function f_EPTF_ExecCtrl_UIVars_connectVarsToStatisticsTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var charstring vl_currentName; // name of variable to connect |
| var charstring vl_widgetId; // name of widgetId to connect to |
| var integer vl_idx; // index of var vl_currentName |
| |
| // go through all entity groups: |
| for(var integer eg:=0; eg<f_EPTF_ExecCtrl_numEntityGroups(); eg:=eg+1) { |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(eg); |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".nofLGens"; |
| vl_currentName := vl_widgetId; |
| |
| // count number of LGens deployed on: |
| var integer vl_numLGensDeployed:=0; |
| var EPTF_ExecCtrl_EntityGroupDistributionList vl_lgenList := f_EPTF_ExecCtrl_eGrp_lgenList(eg); |
| for(var integer lg:=0, lsize := sizeof(vl_lgenList); lg<lsize;lg:=lg+1) { |
| if (vl_lgenList[lg].eCount == 0 ) { |
| continue; // nothing to do |
| } |
| vl_numLGensDeployed:=vl_numLGensDeployed+1; |
| } |
| f_EPTF_Var_newCharstring(vl_currentName, int2str(vl_numLGensDeployed), vl_idx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / EntityGroups / nofLGens) created with widgetId: "&vl_widgetId |
| ); |
| |
| //number of active entities: |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".nofActiveEntities"; |
| vl_currentName := vl_widgetId; |
| f_EPTF_Var_newInt(vl_currentName, f_EPTF_ExecCtrl_getActiveEntities(eg), vl_idx); |
| |
| f_EPTF_Var_addGuardFn(vl_idx,{refers(f_EPTF_ExecCtrl_eGrp_activeEntities_GuardFn),{eg}}) |
| f_EPTF_Var_addPostProcFn(vl_idx,{refers(f_EPTF_ExecCtrl_eGrp_activeEntities_PostProcFn),{eg}}) |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / EntityGroups / nofActiveEntities) created with widgetId: "&vl_widgetId |
| ); |
| |
| //offset of entityGroup: |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".eOffset"; |
| vl_currentName := vl_widgetId; |
| f_EPTF_Var_newInt(vl_currentName, f_EPTF_ExecCtrl_eGrp_eOffset(eg), vl_idx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / EntityGroups / eOffset) created with widgetId: "&vl_widgetId |
| ); |
| |
| //LGenPool of entityGroup: |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".LGenPool"; |
| vl_currentName := vl_widgetId; |
| f_EPTF_Var_newCharstring(vl_currentName, f_EPTF_ExecCtrl_eGrp_lgenPoolName(eg), vl_idx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / EntityGroups / LGenPool) created with widgetId: "&vl_widgetId |
| ); |
| |
| } |
| |
| // go through all scenarios: |
| for(var integer sc:=0; sc<f_EPTF_ExecCtrl_numScenarios(); sc:=sc+1) { |
| f_EPTF_ExecCtrl_updateProgressbar(100.0/int2float(f_EPTF_ExecCtrl_numScenarios())); |
| |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(sc); |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring vl_scTypeName := f_EPTF_ExecCtrl_getScenarioName(sc); |
| var charstring vl_scName := f_EPTF_ExecCtrl_getScenarioInstanceName(sc); |
| |
| |
| // Control buttons (start/stop/reset): |
| // start scenario button: |
| //vl_currentName := "ExecCtrl.startScenario."&vl_eGrpName&"."&vl_scTypeName; // this is the name in the TrafficCase table |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Start"; |
| vl_currentName := vl_widgetId; |
| |
| var integer vl_startScVarIdx,vl_stopScVarIdx,vl_resetScVarIdx; |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_startScVarIdx); |
| |
| // stop scenario button: |
| //vl_currentName := "ExecCtrl.stopScenario."&vl_eGrpName&"."&vl_scTypeName; // this is the name in the TrafficCase table |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Stop"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_stopScVarIdx); |
| |
| // reset scenario button: |
| //vl_currentName := "ExecCtrl.startScenario."&vl_eGrpName&"."&vl_scTypeName; // this is the name in the TrafficCase table |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".ControlButtons.Reset"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, 0, vl_resetScVarIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn( |
| vl_startScVarIdx, { refers(f_EPTF_ExecCtrl_UIVars_startScenario_PostProc), {sc,vl_startScVarIdx,vl_stopScVarIdx,vl_resetScVarIdx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_stopScVarIdx, { refers(f_EPTF_ExecCtrl_UIVars_stopScenario_PostProc), {sc,vl_startScVarIdx,vl_stopScVarIdx,vl_resetScVarIdx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_resetScVarIdx, { refers(f_EPTF_ExecCtrl_UIVars_resetScenario_PostProc), {sc,vl_startScVarIdx,vl_stopScVarIdx,vl_resetScVarIdx}} ); |
| |
| // disable start/stop/reset scenario buttons if scenario is in scenario group: |
| if (not f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(sc)) { |
| f_EPTF_Var_setSubsCanAdjust(vl_startScVarIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopScVarIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_resetScVarIdx,false); |
| } |
| |
| // call f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback to initialize button status: |
| vl_currentName := "ExecCtrl.scenarioStatus."&vl_eGrpName&"."&vl_scTypeName; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| if (vl_idx != -1) { |
| var EPTF_StatusLED vl_EPTF_StatusLED := f_EPTF_Var_getStatusLEDValue(vl_idx); |
| f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback(vl_eGrpName,vl_scTypeName,vl_EPTF_StatusLED.text); |
| } |
| |
| // name of scenario instance |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".instanceName"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newCharstring(vl_currentName, vl_scName, vl_idx); |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / Scenario instance name) connected to widgetId: "&vl_widgetId |
| ); |
| |
| if (not f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(sc)) { |
| var integer vl_scGrpIdx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(sc); |
| // phase list name of scenario instance |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".phaseListName"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_getScenarioPhaseListName(sc), vl_idx); |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / Phase list name for scenario instance) connected to widgetId: "&vl_widgetId |
| ); |
| |
| // scenario group name of scenario instance |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".scGrpName"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newCharstring(vl_currentName, f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scGrpIdx), vl_idx); |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / Scenario group name for scenario instance) connected to widgetId: "&vl_widgetId |
| ); |
| } |
| |
| // connect traffic case widgets: |
| for(var integer tc:=0; tc<f_EPTF_ExecCtrl_getScenarioTcIdxListSize(sc); tc:=tc+1) { |
| var integer vl_tcIdx := f_EPTF_ExecCtrl_getScenarioTcIdx(sc,tc); |
| var charstring vl_tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(sc,tc) |
| |
| // traffic case GroupFinishStatusLED: |
| vl_widgetId := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".SC."&vl_scTypeName&".TC."&vl_tcName&".GroupFinishStatusLED"; |
| vl_currentName := vl_widgetId; |
| |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, f_EPTF_ExecCtrl_UIVars_getLEDForGroupFinish(vl_tcIdx), vl_idx); |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variable "&vl_currentName&" (Statistics / Traffic case group finish status) connected to widgetId: "&vl_widgetId |
| ); |
| |
| f_EPTF_ExecCtrl_UIVars_connectVarsToStatisticsTabForTc_vars(vl_tcIdx); |
| } // for tc |
| f_EPTF_ExecCtrl_UIVars_createStatsForSc_vars(sc); |
| } // for sc |
| //f_EPTF_ExecCtrl_UIVars_createStatsForAllTcs(); |
| |
| f_EPTF_ExecCtrl_UIVars_createGlobalStats_vars(); |
| } |
| |
| private function f_EPTF_ExecCtrl_createGUI_vars() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug(%definitionId& |
| ": Trying to subscribe variables to GUI for init!"); |
| |
| // Init already subscribed database |
| |
| f_EPTF_ExecCtrl_UIVars_Subscribe2TimeElapsed_vars(); |
| f_EPTF_ExecCtrl_UIVars_Subscribe2TestMgmtButtons_vars(); |
| f_EPTF_ExecCtrl_UIVars_connectVarsToStatisticsTab_vars(); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2GUI_vars(); |
| } |
| |
| // Create_vars |
| ////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2ResourceTab_vars |
| // |
| // Purpose: |
| // Subscribe resource related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2ResourceTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_updateProgressbar(0.0, "Creating Client Resources panel variables"); |
| var charstring vl_currentName; |
| var integer vl_offset := 0; |
| var integer vl_sizeLG := f_EPTF_ExecCtrl_numLGens(); |
| var integer vl_varId := 0; |
| |
| for (var integer lgenidx := 0; lgenidx < vl_sizeLG; lgenidx := lgenidx + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(vl_sizeLG)); |
| // LGen name |
| vl_currentName := "Resource.LGenName." & int2str(lgenidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_ResourceTabId & "." & int2str(vl_offset) & ".0"; |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_getLGenName(lgenidx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RES / LGen name) id: " |
| &int2str(vl_varId)); |
| } |
| |
| var integer vl_sizeAvail := f_EPTF_ExecCtrl_getLGenResourceListNum(lgenidx); |
| |
| if (vl_sizeAvail==0) { |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } |
| |
| // Resource info (entity group - available - allocated) |
| for (var integer eidx := 0; eidx < vl_sizeAvail; eidx := eidx + 1) |
| { |
| vl_currentName := "Resource.EntityType." & int2str(lgenidx) & "." & int2str(eidx); |
| // Entity type |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_ResourceTabId & "." & int2str(vl_offset) & ".1"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Available list: " & f_EPTF_ExecCtrl_getLGenResourceList2Str(lgenidx)); |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| f_EPTF_ExecCtrl_getLGenResourceListEType(lgenidx,eidx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RES / Entity type) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // Available and allocated number of entity types |
| vl_currentName := "Resource.EntityAvailNum." & int2str(lgenidx) & "." & int2str(eidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_ResourceTabId & "." & int2str(vl_offset) & ".2"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Available list: " & f_EPTF_ExecCtrl_getLGenResourceList2Str(lgenidx)); |
| |
| f_EPTF_ExecCtrl_createRefVarForMaxCount( |
| vl_currentName, |
| lgenidx,eidx, |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RES / Entity Max available num) id: " |
| &int2str(vl_varId)); |
| |
| vl_currentName := "Resource.EntityAllocNum." & int2str(lgenidx) & "." & int2str(eidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_ResourceTabId & "." & int2str(vl_offset) & ".3"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Allocated list: " & f_EPTF_ExecCtrl_getLGenResourceList2Str(lgenidx)); |
| |
| f_EPTF_ExecCtrl_createRefVarForEAvail( |
| vl_currentName, |
| lgenidx,eidx, |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RES / Entity Current available num) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2EntityGroupsTab_vars |
| // |
| // Purpose: |
| // Subscribe entity group related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2EntityGroupsTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_updateProgressbar(0.0, "Creating Entity Groups panel variables"); |
| var charstring vl_currentName; |
| var integer vl_idx; |
| var integer vl_size := f_EPTF_ExecCtrl_numEntityGroups(); |
| for (var integer i := 0; i < vl_size; i := i + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(100.0/int2float(vl_size)); |
| // Entity name |
| vl_currentName := "EntityGroup." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_EntityGrpTabId & "." & int2str(i) & ".0"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_eGrp_name(i), vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EG / Entity group) id: " |
| &int2str(vl_idx)); |
| |
| // Entity type |
| vl_currentName := "EntityType." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_EntityGrpTabId & "." & int2str(i) & ".1"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_eGrp_eType(i), vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EG / Entity type) id: " |
| &int2str(vl_idx)); |
| |
| // Entity number of entity group |
| vl_currentName := "EntityNum." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_EntityGrpTabId & "." & int2str(i) & ".2"; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, f_EPTF_ExecCtrl_eGrp_eCount(i), vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EG / Entity num) id: " |
| &int2str(vl_idx)); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2EGrpDistributionTab_vars |
| // |
| // Purpose: |
| // Subscribe entity group distribution related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2EGrpDistributionTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var charstring vl_currentName; |
| var integer vl_offset := 0; |
| var integer vl_sizeEGrp := f_EPTF_ExecCtrl_numEntityGroups(); |
| var integer vl_varId := 0; |
| |
| for (var integer eGrpIdx := 0; eGrpIdx < vl_sizeEGrp; eGrpIdx := eGrpIdx + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(vl_sizeEGrp)); |
| // EGrpName name |
| vl_currentName := "EGrpDistr.EGrpName." & int2str(eGrpIdx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_GroupDistributionTabId & "." & int2str(vl_offset) & ".0"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_eGrp_name(eGrpIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EGrpDistr / EGrp name) id: " |
| &int2str(vl_varId)); |
| } |
| |
| var EPTF_ExecCtrl_EntityGroupDistributionList vl_lgenList := f_EPTF_ExecCtrl_eGrp_lgenList(eGrpIdx); |
| var integer vl_sizeLGen := sizeof( |
| vl_lgenList); |
| |
| // Resource info (entity group - available - allocated) |
| if (vl_sizeLGen==0) { |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } |
| for (var integer lgenIdx := 0; lgenIdx < vl_sizeLGen; lgenIdx := lgenIdx + 1) |
| { |
| var integer vl_lgenIdx := vl_lgenList[lgenIdx].lgenIdx; |
| // LGen name |
| vl_currentName := "EGrpDistr.LGenName." & int2str(eGrpIdx) & "." & int2str(lgenIdx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_GroupDistributionTabId & "." & int2str(vl_offset) & ".1"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| f_EPTF_ExecCtrl_getLGenName(vl_lgenIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EGrpDistr / LGen name) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // EGroup size and offset |
| vl_currentName := "EGrpDistr.ECount." & int2str(eGrpIdx) & "." & int2str(lgenIdx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_GroupDistributionTabId & "." & int2str(vl_offset) & ".2"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Available list: " & log2str(vl_lgenList[lgenIdx])); |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, |
| vl_lgenList[lgenIdx].eCount, |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EGrpDistr / ECount ) id: " |
| &int2str(vl_varId)); |
| |
| vl_currentName := "EGrpDistr.EOffset." & int2str(eGrpIdx) & "." & int2str(lgenIdx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_GroupDistributionTabId & "." & int2str(vl_offset) & ".3"; |
| |
| f_EPTF_Var_newInt( |
| vl_currentName, |
| vl_lgenList[lgenIdx].eOffset + f_EPTF_ExecCtrl_eGrp_eOffset(eGrpIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (EGrpDistr / Entity Offset) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_vars |
| // |
| // Purpose: |
| // Subscribe scenario and traffic case related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_Scenario_vars(); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_TrafficCase_vars(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_CreateLEDFromExecStatus |
| // |
| // Purpose: |
| // Creates a status LED from execution control status |
| // |
| // |
| // Parameters: |
| // pl_idx - *in* *integer* - index of the subscriber variable |
| // pl_argList - *in* <EPTF_IntegerList> - list of argument variable indices |
| // pl_nonVarArgList - *in* <EPTF_IntegerList> - list of other argument indices |
| // pl_retVal - *inout* <EPTF_Var_DirectContent> - result of the function |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_CreateLEDFromExecStatus( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal) runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var charstring vl_execState := |
| f_EPTF_Var_getCharstringValue(pl_argList[0]); |
| |
| pl_retVal := { |
| statusLEDVal := f_EPTF_ExecCtrl_stateStrToEPTF_StatusLED(vl_execState) |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_Scenario_vars |
| // |
| // Purpose: |
| // Subscribe scenario related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_Scenario_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_updateProgressbar(0.0, "Creating Traffic Cases panel variables"); |
| |
| var charstring vl_currentName; |
| var integer vl_idx, vl_offset := 0; |
| var integer vl_sizeLG := f_EPTF_ExecCtrl_numLGens(); |
| var integer vl_varId := 0; |
| |
| for (var integer lgenidx := 0; lgenidx < vl_sizeLG; lgenidx := lgenidx + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(vl_sizeLG)); |
| // LGen name |
| vl_currentName := "Scenario.LGenName." & int2str(lgenidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario & "." & int2str(vl_offset) & ".0"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_getLGenName(lgenidx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (SCEN / LGen name) id: " |
| &int2str(vl_varId)); |
| } |
| |
| var integer sidx := -1; |
| if (f_EPTF_ExecCtrl_getLGenNumEGroups(lgenidx)==0) { |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } |
| for(var integer eg:=0; eg<f_EPTF_ExecCtrl_getLGenNumEGroups(lgenidx); eg:=eg+1) { |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getLGenEGrpIdx(lgenidx,eg); |
| var EPTF_IntegerList vl_eGrpScenarios := f_EPTF_ExecCtrl_eGrp_scenarios(vl_eGrpIdx); |
| if (sizeof(vl_eGrpScenarios)==0) { |
| // Allocated of entity group |
| sidx := sidx + 1; |
| // Resource info (entity group - available - allocated) |
| |
| vl_currentName := "Scenario.ScenarioGroup." & int2str(lgenidx) & "." & int2str(sidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario & "." & int2str(vl_offset) & ".1"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (SCEN / Scenario group) id: " |
| &int2str(vl_varId)); |
| } |
| |
| vl_offset := vl_offset+1; |
| //continue; // the for cycle is not executed, continue is not necessary |
| } |
| for(var integer sc:=0, size := sizeof(vl_eGrpScenarios); sc<size;sc:=sc+1) { |
| var integer vl_scIdx := vl_eGrpScenarios[sc]; |
| sidx := sidx + 1; |
| |
| // Resource info (entity group - available - allocated) |
| |
| // Allocated of entity group |
| vl_currentName := "Scenario.ScenarioGroup." & int2str(lgenidx) & "." & int2str(sidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario & "." & int2str(vl_offset) & ".1"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (SCEN / Scenario group) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // Scenario name |
| vl_currentName := "Scenario.ScenarioName." & int2str(lgenidx) & "." & int2str(sidx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario & "." & int2str(vl_offset) & ".2"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| f_EPTF_ExecCtrl_getScenarioName(vl_scIdx), |
| vl_varId); |
| f_EPTF_Var_setSubsCanAdjust(vl_varId,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (SCEN / Scenario name) id: " |
| &int2str(vl_varId)); |
| } |
| |
| // Scenario status |
| vl_currentName := "Scenario.LGenStatus." & f_EPTF_ExecCtrl_getLGenName(lgenidx) & "." &f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx)& |
| "."&f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| if (f_EPTF_Var_getId(vl_currentName) == -1) |
| { |
| |
| // lgen status |
| var EPTF_Var_ProviderLocal vl_providerLocal; |
| // vl_currentName := "Scenario.LGenStatus." & int2str(lgenidx) & "." & int2str(sidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario & "." & int2str(vl_offset) & ".3"; |
| |
| f_EPTF_Var_newStatusLED( |
| "StatusLED." & vl_currentName, |
| c_EPTF_ExecCtrl_UIVars_StatusLED_init, |
| vl_idx); |
| |
| var charstring vl_varName := "ExecCtrlClient.scenarioStatus."&f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx)& |
| "."&f_EPTF_ExecCtrl_getScenarioName(vl_scIdx); |
| vl_varId := f_EPTF_Var_getId(vl_varName&"."&f_EPTF_ExecCtrl_getLGenName(lgenidx)); |
| |
| vl_providerLocal := {calcFn:={ |
| funcRef := refers(f_EPTF_ExecCtrl_UIVars_CreateLEDFromExecStatus), |
| argList := {vl_varId}, |
| nonVarArgList := {} |
| }}; |
| // FIXME: update the function ExecCtrl_Functions.f_EPTF_ExecCtrl_subscribeScenarioState |
| if (vl_varId == -1) { |
| vl_offset := vl_offset + 1; |
| continue; |
| } |
| |
| f_EPTF_Var_subscribeLocal(vl_idx, vl_providerLocal); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (SCEN / LGen status) id: " |
| &int2str(vl_varId)); |
| |
| } |
| |
| // Increase offset for each group |
| vl_offset := vl_offset + 1; |
| } // sc |
| } // eg |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_TrafficCase_vars() runs on EPTF_ExecCtrl_CT{ |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_TrafficCase2_vars(); |
| f_EPTF_ExecCtrl_registerScenarioStateChangedCallback(refers(f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback)); |
| f_EPTF_ExecCtrl_registerTrafficCaseStateChangedCallback(refers(f_EPTF_ExecCtrl_startStopTc_tcStateChangedCallback)); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback |
| // |
| // Purpose: |
| // A scenarioStateChangedCallback to automatically disable the start/stop/reset buttons |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_startStopScenario_scenarioStateChangedCallback(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| |
| var charstring vl_currentName; |
| var integer vl_idx; |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]) { |
| // disables startScenario: |
| // enables stopScenario: |
| f_EPTF_ExecCtrl_debug( |
| "**********STOP SCENARIO ENABLED***********"); |
| vl_currentName := "ExecCtrl.startScenario."&pl_eGrpName&"."&pl_scName; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := false}); |
| |
| // this scenario cannot be stopped if it belongs to a scenario group: |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario "&pl_scName&" of entity group "&pl_eGrpName&" in database.", vl_scIdx != -1); |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(vl_scIdx)) { |
| // Manage Statistics/Scenario control buttons enabled state |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Stop"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,true); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Start"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Reset"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| } |
| |
| |
| } |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateStopped] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateFinished] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStatePaused] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateAborted] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateTerminated] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateIdle]) { |
| // pl_state=="Idle" or pl_state=="Stopped" or pl_state=="Stopping" or pl_state=="Finished" or pl_state=="Paused" or pl_state=="Aborted" |
| // enables startScenario: |
| // disables stopScenario: |
| f_EPTF_ExecCtrl_debug( |
| "**********START SCENARIO ENABLED***********"); |
| vl_currentName := "ExecCtrl.stopScenario."&pl_eGrpName&"."&pl_scName; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := false}); |
| |
| // this scenario cannot be started if it belongs to a scenario group: |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario "&pl_scName&" of entity group "&pl_eGrpName&" in database.", vl_scIdx != -1); |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(vl_scIdx)) { |
| // Manage Statistics/Scenario control buttons enabled state |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Stop"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Start"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,true); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".ControlButtons.Reset"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,true); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_startStopTc_tcStateChangedCallback |
| // |
| // Purpose: |
| // A tcStateChangedCallback to automatically disable the start/stop buttons |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_startStopTc_tcStateChangedCallback(in charstring pl_eGrpName, in charstring pl_scName, in charstring pl_tcName, in charstring pl_state) runs on EPTF_ExecCtrl_CT { |
| |
| var charstring vl_currentName; |
| var integer vl_idx; |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateRunning]) { |
| // disables startTc: |
| // enables stopTc: |
| f_EPTF_ExecCtrl_debug( |
| "**********STOP TC ENABLED***********"); |
| vl_currentName := "ExecCtrl.startTC."&pl_eGrpName&"."&pl_scName&"."&pl_tcName; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := false}); |
| |
| // this tc cannot be stopped if it belongs to a scenario group: |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario "&pl_scName&" of entity group "&pl_eGrpName&" in database.", vl_scIdx != -1); |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(vl_scIdx)) { |
| // Manage TrafficCase control buttons enabled state |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".TC."&pl_tcName&".ControlButtons.Stop"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,true); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".TC."&pl_tcName&".ControlButtons.Start"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| } |
| } |
| |
| if (pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateStopped] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateFinished] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStatePaused] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateAborted] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateTerminated] |
| or pl_state==c_EPTF_LGenBase_stateNames[c_EPTF_LGenBase_tcStateIdle]) { |
| // pl_state=="Idle" or pl_state=="Stopped" or pl_state=="Stopping" or pl_state=="Finished" or pl_state=="Paused" or pl_state=="Aborted" |
| // enables startTc: |
| // disables stopTc: |
| f_EPTF_ExecCtrl_debug( |
| "**********START TC ENABLED***********"); |
| vl_currentName := "ExecCtrl.stopTC."&pl_eGrpName&"."&pl_scName&"."&pl_tcName; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_adjustContent(vl_idx,{boolVal := false}); |
| |
| // this scenario cannot be started if it belongs to a scenario group: |
| |
| var integer vl_scIdx := f_EPTF_ExecCtrl_getScenarioIdx(pl_eGrpName,pl_scName); |
| f_EPTF_Base_assert(%definitionId&": Cannot find scenario "&pl_scName&" of entity group "&pl_eGrpName&" in database.", vl_scIdx != -1); |
| if (f_EPTF_ExecCtrl_scenarioIsNotInScenarioGroup(vl_scIdx)) { |
| // Manage Statistics/Scenario control buttons enabled state |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".TC."&pl_tcName&".ControlButtons.Stop"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| vl_currentName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&pl_eGrpName&".SC."&pl_scName&".TC."&pl_tcName&".ControlButtons.Start"; |
| vl_idx := f_EPTF_Var_getId(vl_currentName); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,true); |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_updateStartDelay_PostProc |
| // |
| // Purpose: |
| // Post proc function to update the startDelay for a traffic case |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_updateStartDelay_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcOfScIdx := pl_argList[1]; |
| var float vl_startDelay := f_EPTF_Var_getFloatValue(pl_idx); |
| f_EPTF_ExecCtrl_setStartDelay_TC(vl_scIdx,vl_tcOfScIdx,vl_startDelay); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_updateScenarioCPS |
| // |
| // Purpose: |
| // Test management post proc function to update CPS for a weighted scenario in |
| // entity group |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_updateScenarioCPS( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| //TR: MTTSM00015935 |
| if(not ischosen(pl_newContent.floatVal)) { return false; } |
| if(pl_newContent.floatVal < 0.0) { return false; } |
| // ~TR |
| |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| // do not send update if value is not changed: |
| if (f_EPTF_Var_getFloatValue(pl_idx) == pl_newContent.floatVal) { |
| return true; // no change |
| } |
| // set into the content (==comp var) because the function reads data from component var |
| f_EPTF_Var_setContent(pl_idx,pl_newContent); |
| |
| // Update according to scenario index |
| f_EPTF_ExecCtrl_sendUpdatedScenarioCps(pl_argList[0]); |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_updateCPS |
| // |
| // Purpose: |
| // Test management post proc function to update CPS for all TCs in |
| // scenario group |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_updateCPS( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| //TR: MTTSM00015935 |
| if(not ischosen(pl_newContent.floatVal)) { return false; } |
| if(pl_newContent.floatVal < 0.0) { return false; } |
| // ~TR |
| |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| // do not send update if value is not changed: |
| if (f_EPTF_Var_getFloatValue(pl_idx) == pl_newContent.floatVal) { |
| return true; // no change |
| } |
| // set into the content (==comp var) because the function reads data from component var |
| f_EPTF_Var_setContent(pl_idx,pl_newContent); |
| |
| // Update according to scenario index and tcOfScenario idx |
| f_EPTF_ExecCtrl_sendUpdatedCps(pl_argList[0], pl_argList[1]); |
| return true; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_guardRegulatorName( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| var charstring pl_regulatorName := pl_newContent.charstringVal; |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&" :"& pl_regulatorName); |
| if (match(pl_regulatorName, pattern "\d+")) { |
| f_EPTF_ExecCtrl_debug( |
| "Regulator name is a digit, assuming it is the ID. Converting it into name..."); |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_regulatorName(str2int(pl_regulatorName)); |
| if (vl_regulatorName != "") { |
| pl_regulatorName := vl_regulatorName; |
| f_EPTF_ExecCtrl_debug( |
| "Regulator name is converted to: "&pl_regulatorName); |
| f_EPTF_Var_adjustContent(pl_idx, {charstringVal := pl_regulatorName}); |
| return false; |
| } |
| } |
| // returns true if the regulator exists: |
| if (pl_regulatorName!="" and f_EPTF_ExecCtrl_Regulator_getRegulatorId(pl_regulatorName)==-1) { |
| // set back the original value |
| // NOTE: GUIHanlder should be fixed to handle adjustContentNack to revert back to the original value |
| // then this line is not needed: |
| f_EPTF_ExecCtrl_debug( |
| "Regulator name not accepted: "& pl_regulatorName); |
| f_EPTF_Var_adjustContent(pl_idx, {charstringVal := f_EPTF_Var_getCharstringValue(pl_idx)}); |
| return false; |
| } |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_updateRegulator |
| // |
| // Purpose: |
| // Test management post proc function to update Regulator for a regulated item |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_updateRegulator( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (not v_ExecCtrl_initialized) { |
| f_EPTF_ExecCtrl_warning(%definitionId&": Update during cleanup ignored."); |
| return; |
| } |
| |
| var integer vl_regulatedItemId := pl_argList[0]; |
| var charstring pl_regulatorName := f_EPTF_Var_getCharstringValue(pl_idx); |
| |
| if (sizeof(pl_argList)==2) { |
| // update regulator for the current phase! |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := f_EPTF_ExecCtrl_Regulator_itemId2ItemName(vl_regulatedItemId); |
| var EPTF_ExecCtrl_RegulatedItemId vl_regulatedItemData := f_EPTF_ExecCtrl_Regulator_getRegulatedItemDataById(vl_regulatedItemId); |
| if (ischosen(vl_idName.cps_TCInPhase)) { |
| var integer scenidx := vl_regulatedItemData.cps_TCInPhase.scenidx; |
| var integer vl_scGrpidx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(scenidx); |
| var charstring vl_currentPhase := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGrpidx); |
| |
| vl_idName.cps_TCInPhase.phase := vl_currentPhase; |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| |
| // set the content of the other variable (without calling postProc fns to avoid infinite loop): |
| var charstring vl_otherName := f_EPTF_Var_getName(pl_idx); // this is my name (does not include the phase) |
| vl_otherName := vl_otherName&".InPhase."&vl_currentPhase; // this is the other var name |
| var integer vl_otherIdx := f_EPTF_Var_getId(vl_otherName); |
| f_EPTF_Var_adjustContent(vl_otherIdx,{charstringVal := pl_regulatorName}); |
| f_EPTF_ExecCtrl_debug("Var "&vl_otherName&" changed to: "&pl_regulatorName); |
| } else if (ischosen(vl_idName.cps_SCInPhase)) { |
| var integer scenidx := vl_regulatedItemData.cps_SCInPhase.scenidx; |
| var integer vl_scGrpidx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(scenidx); |
| var charstring vl_currentPhase := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGrpidx); |
| |
| vl_idName.cps_SCInPhase.phase := vl_currentPhase; |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| |
| // set the content of the other variable (without calling postProc fns to avoid infinite loop): |
| var charstring vl_otherName := f_EPTF_Var_getName(pl_idx); // this is my name (does not include the phase) |
| vl_otherName := vl_otherName&".InPhase."&vl_currentPhase; // this is the other var name |
| var integer vl_otherIdx := f_EPTF_Var_getId(vl_otherName); |
| f_EPTF_Var_adjustContent(vl_otherIdx,{charstringVal := pl_regulatorName}); |
| f_EPTF_ExecCtrl_debug("Var "&vl_otherName&" changed to: "&pl_regulatorName); |
| } |
| } |
| |
| // Update according to group and scenario index in grp2scenario DB |
| f_EPTF_ExecCtrl_Regulator_setRegulatorName(vl_regulatedItemId,pl_regulatorName); |
| |
| f_EPTF_ExecCtrl_Regulator_logAll(); |
| } |
| |
| |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_TrafficCase2_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_offset := 0; |
| var charstring vl_currentName; |
| var integer vl_idx; |
| var integer vl_sizeScen := f_EPTF_ExecCtrl_numScenarios(); |
| var integer vl_sizeTCs; |
| |
| for (var integer sidx := 0; sidx < vl_sizeScen; sidx := sidx + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(vl_sizeScen)); |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getScenarioEGroupIdx(sidx); |
| var charstring grpName := f_EPTF_ExecCtrl_eGrp_name(vl_eGrpIdx); |
| var charstring scenName := f_EPTF_ExecCtrl_getScenarioName(sidx); |
| |
| // Scenario name |
| vl_currentName := "Traffic.ScenarioName." & grpName&"." & int2str(sidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".0"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_getScenarioInstanceName(sidx), vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Scenario name) id: " |
| &int2str(vl_idx)); |
| |
| // Scenario type |
| vl_currentName := "Traffic.ScenarioType." & grpName&"."& int2str(sidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".1"; |
| |
| var charstring vl_type := "Decl"; |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_type := "Weighted"; |
| } |
| f_EPTF_Var_newCharstring( |
| vl_currentName, vl_type, vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Scenario type) id: " |
| &int2str(vl_idx)); |
| |
| // Scenario status |
| vl_currentName := "ExecCtrl.scenarioStatus."&grpName&"."&scenName; |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".2"; |
| |
| // FIXME: fix in f_EPTF_ExecCtrl_subscribeScenarioState needed |
| if (f_EPTF_Var_getId(vl_currentName) == -1) { |
| vl_offset := vl_offset + 1; |
| continue; |
| } |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Scenario status) id: " |
| &int2str(vl_idx)); |
| |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| // Scenario CPS |
| vl_currentName := "Traffic.ScenarioCPS." & grpName&"."& int2str(sidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".5"; |
| |
| f_EPTF_ExecCtrl_createRefVarForWScCPSToReach( |
| vl_currentName, sidx, vl_idx); |
| // Refresh refered variable for TargetCPS |
| var integer vl_previdx; |
| f_EPTF_Var_newFloat( vl_currentName&".prevvalue", v_ExecCtrl_scenarios[sidx].scData.weightedScData.cpsToReach, vl_previdx); |
| f_EPTF_Var_addSyncCallBackFn( refers(f_EPTF_ExecCtrl_refreshCallBackTargetCPS), {vl_idx, vl_previdx}); |
| f_EPTF_Var_addPostProcFn(vl_idx, {refers(f_EPTF_ExecCtrl_refreshPostProcRegulatorTotalCPS), {sidx} } ); |
| |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_updateScenarioCPS), {sidx}} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Scenario CPS) id: " |
| &int2str(vl_idx)); |
| |
| } // f_EPTF_ExecCtrl_isWeightedScenario(sidx) |
| vl_sizeTCs := f_EPTF_ExecCtrl_numTcOfScenario(sidx); |
| for (var integer tcidx := 0; tcidx < vl_sizeTCs; tcidx := tcidx + 1) |
| { |
| // Traffic case (of current scenarios) |
| vl_currentName := "Traffic.TC." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".6"; |
| |
| var charstring tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(sidx,tcidx) |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| tcName, |
| vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / TC name) id: " |
| &int2str(vl_idx)); |
| |
| // Start Traffic case |
| vl_currentName := "ExecCtrl.startTC."&grpName&"."&scenName&"."&tcName; |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".7"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Start TC) id: " |
| &int2str(vl_idx)); |
| |
| // Stop Traffic case |
| vl_currentName := "ExecCtrl.stopTC."&grpName&"."&scenName&"."&tcName; |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".8"; |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / Stop TC) id: " |
| &int2str(vl_idx)); |
| |
| if (not f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| |
| // Traffic case start delay time |
| vl_currentName := "Traffic.TCDelay."& grpName&"." & int2str(sidx) & "." & int2str(tcidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".9"; |
| |
| f_EPTF_Var_newFloat( |
| vl_currentName, |
| f_EPTF_ExecCtrl_getScenarioTcStartDelay(sidx,tcidx), |
| vl_idx); |
| |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_updateStartDelay_PostProc), {sidx,tcidx}} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / TC start delay) id: " |
| &int2str(vl_idx)); |
| } |
| |
| // Traffic case target CPS (call per second) |
| vl_currentName := "Traffic.TCCPS." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".10"; |
| |
| f_EPTF_ExecCtrl_createRefVarForTcCPSToReach(sidx,tcidx,vl_currentName,vl_idx); |
| // Refresh refered variable for TargetCPS |
| var integer vl_previdx; |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| f_EPTF_Var_newFloat( |
| vl_currentName&".prevvalue", |
| v_ExecCtrl_scenarios[sidx].scData.tcList[tcidx].target.trafficWeight, |
| vl_previdx); |
| } else { |
| f_EPTF_Var_newFloat( |
| vl_currentName&".prevvalue", |
| v_ExecCtrl_scenarios[sidx].scData.tcList[tcidx].target.cpsToReach, |
| vl_previdx); |
| } |
| f_EPTF_Var_addSyncCallBackFn(refers(f_EPTF_ExecCtrl_refreshCallBackTargetCPS), {vl_idx, vl_previdx}); |
| f_EPTF_Var_addPostProcFn(vl_idx, {refers(f_EPTF_ExecCtrl_refreshPostProcRegulatorTotalCPS), {sidx, tcidx} } ) |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_updateCPS), {sidx, tcidx}} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / TC target CPS) id: " |
| &int2str(vl_idx)); |
| |
| // TimeProfile |
| if (not f_EPTF_ExecCtrl_isWeightedScenario(sidx) |
| or (tcidx==0 and f_EPTF_ExecCtrl_isWeightedScenario(sidx))) { |
| vl_currentName := "Traffic.TimeProfile." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".11"; |
| |
| var charstring vl_timeProfileName := f_EPTF_ExecCtrl_getTimeProfileNameForTC(sidx,tcidx); |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| vl_timeProfileName, |
| vl_idx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / TC time profile) id: " |
| &int2str(vl_idx)); |
| }// if |
| |
| // Regulator |
| if (not f_EPTF_ExecCtrl_isWeightedScenario(sidx) |
| or (tcidx==0 and f_EPTF_ExecCtrl_isWeightedScenario(sidx))) { |
| // vl_widgetId := |
| // c_EPTF_ExecCtrl_TrafficTabId_TC & "." & int2str(vl_offset) & ".12"; |
| |
| var charstring vl_regulatorName := ""; |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName; |
| var integer vl_scGrpidx := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(sidx); |
| if (vl_scGrpidx==-1) { |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SC := {grpName,scenName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx); |
| } else { |
| vl_idName := {cps_TC := {grpName,scenName,tcName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); // tc idx shall be there for non-weighted Sc |
| } |
| } else { |
| // for scenarios in scenario groups: it shows the regulator in the current phase |
| var EPTF_ExecCtrl_PhaseList_Instance phaseList := f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseList(vl_scGrpidx); |
| |
| // create variables for all phases: |
| for(var integer ph:=0; ph<f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListPhasesNum(vl_scGrpidx); ph:=ph+1) { |
| var charstring vl_phaseName := f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListPhaseName(vl_scGrpidx,ph); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SCInPhase := {grpName,scenName, vl_phaseName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx)&".InPhase."&vl_phaseName; |
| } else { |
| vl_idName := {cps_TCInPhase := {grpName,scenName,tcName, vl_phaseName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx) & "." & int2str(tcidx)&".InPhase."&vl_phaseName; // tc idx shall be there for non-weighted Sc |
| } |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| f_EPTF_Base_assert(%definitionId&": Regulated item is not found: "&log2str(vl_idName), vl_regulatedItemId!=-1); |
| |
| vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| vl_regulatorName, |
| vl_idx); |
| |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_guardRegulatorName), {vl_regulatedItemId}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_updateRegulator), {vl_regulatedItemId}} ); |
| } |
| // put regulator in CURRENT PHASE to the GUI: |
| var charstring vl_phaseName := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGrpidx); |
| if (f_EPTF_ExecCtrl_isWeightedScenario(sidx)) { |
| vl_idName := {cps_SCInPhase := {grpName,scenName, vl_phaseName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx); |
| } else { |
| vl_idName := {cps_TCInPhase := {grpName,scenName,tcName, vl_phaseName}}; |
| vl_currentName := "Traffic.Regulator." & grpName&"."& int2str(sidx) & "." & int2str(tcidx); // tc idx shall be there for non-weighted Sc |
| } |
| } |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| f_EPTF_Base_assert(%definitionId&": Regulated item is not found: "&log2str(vl_idName), vl_regulatedItemId!=-1); |
| |
| vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| f_EPTF_Var_newCharstring( |
| vl_currentName, |
| vl_regulatorName, |
| vl_idx); |
| |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_guardRegulatorName), {vl_regulatedItemId}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_updateRegulator), {vl_regulatedItemId, -1}} ); // -1: update regulator for the current phase |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (TC / TC regulator) id: " |
| &int2str(vl_idx)); |
| |
| }// if |
| |
| // Increase offset |
| vl_offset := vl_offset + 1; |
| } |
| // vl_offset := vl_offset + 1; |
| // f_EPTF_ExecCtrl_UIVars_createScenarioTab_TableRow(c_EPTF_ExecCtrl_TrafficTabId_TC); |
| } |
| |
| |
| } |
| |
| // portProc function for the "RegulatedItemEnabled" variable on the GUI |
| // this starts/stops the regulator if necessary |
| private function f_EPTF_ExecCtrl_UIVars_enableRegulatedItem_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| var integer vl_regulatedItemId := pl_argList[0]; |
| var integer vl_regulatorId := f_EPTF_ExecCtrl_Regulator_getRegulatorId(f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId)); |
| if (vl_regulatorId!=-1) { |
| f_EPTF_ExecCtrl_Regulator_startStop(vl_regulatorId); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatedItemsTab_vars |
| // |
| // Purpose: |
| // Subscribe entity group related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatedItemsTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_updateProgressbar(0.0, "Creating Regulator panel variables"); |
| var charstring vl_currentName; |
| var integer vl_idx; |
| var integer vl_size := f_EPTF_ExecCtrl_Regulator_nofRegulatedItems(); |
| for (var integer i := 0; i < vl_size; i := i + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(80.0/int2float(vl_size)); |
| |
| // Item type |
| vl_currentName := "RegulatedItemType." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_RegulatedItemsTabId & "." & int2str(i) & ".0"; |
| |
| var charstring vl_tmpstr := ""; |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := f_EPTF_ExecCtrl_Regulator_itemId2ItemName(i); |
| |
| if (ischosen(vl_idName.cps_TC)) { |
| vl_tmpstr := "TrafficCase CPS" |
| } |
| if (ischosen(vl_idName.cps_SC)) { |
| vl_tmpstr := "Scenario CPS" |
| } |
| if (ischosen(vl_idName.cps_TCInPhase)) { |
| vl_tmpstr := "TrafficCase CPS @ Phase" |
| } |
| if (ischosen(vl_idName.cps_SCInPhase)) { |
| vl_tmpstr := "Scenario CPS @ Phase" |
| } |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, vl_tmpstr, vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RegItems / Item type) id: " |
| &int2str(vl_idx)); |
| |
| // Item name |
| vl_currentName := "RegulatedItemName." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_RegulatedItemsTabId & "." & int2str(i) & ".1"; |
| |
| vl_tmpstr := ""; |
| if (ischosen(vl_idName.cps_TC)) { |
| vl_tmpstr := vl_idName.cps_TC.eGrpName |
| &"."&vl_idName.cps_TC.scName |
| &"."&vl_idName.cps_TC.tcName; |
| } |
| if (ischosen(vl_idName.cps_SC)) { |
| vl_tmpstr := vl_idName.cps_SC.eGrpName |
| &"."&vl_idName.cps_SC.scName; |
| } |
| if (ischosen(vl_idName.cps_TCInPhase)) { |
| vl_tmpstr := vl_idName.cps_TCInPhase.eGrpName |
| &"."&vl_idName.cps_TCInPhase.scName |
| &"."&vl_idName.cps_TCInPhase.tcName |
| &"@"&vl_idName.cps_TCInPhase.phase; |
| } |
| if (ischosen(vl_idName.cps_SCInPhase)) { |
| vl_tmpstr := vl_idName.cps_SCInPhase.eGrpName |
| &"."&vl_idName.cps_SCInPhase.scName |
| &"@"&vl_idName.cps_SCInPhase.phase; |
| } |
| |
| f_EPTF_str2int_HashMap_Insert(v_ExecCtrl_regulatedItemsHash, vl_tmpstr, i); |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, vl_tmpstr, vl_idx); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RegItems / Item name) id: " |
| &int2str(vl_idx)); |
| |
| // Weight |
| vl_currentName := "RegulatedItemWeight." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_RegulatedItemsTabId & "." & int2str(i) & ".3"; |
| |
| f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemWeight( |
| vl_currentName, i, vl_idx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RegItems / Item Weight) id: " |
| &int2str(vl_idx)); |
| |
| // Enabled |
| vl_currentName := "RegulatedItemEnabled." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_RegulatedItemsTabId & "." & int2str(i) & ".4"; |
| |
| f_EPTF_ExecCtrl_Regulator_createRefVarFromRegulatedItemEnabled( |
| vl_currentName, i, vl_idx); |
| |
| f_EPTF_Var_addPostProcFn(vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_enableRegulatedItem_PostProc), {i} }); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RegItems / Item Enabled) id: " |
| &int2str(vl_idx)); |
| |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatorsTargetValueTab_vars |
| // |
| // Purpose: |
| // Subscribe regulator related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatorsTargetValueTab_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var charstring vl_currentName; |
| var integer vl_idx; |
| var integer vl_size := f_EPTF_ExecCtrl_Regulator_getNofRegulators(); |
| for (var integer i := 0; i < vl_size; i := i + 1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(20.0/int2float(vl_size)); |
| |
| // Regulator Name |
| vl_currentName := "RegulatedItems_tab."&"RegulatorName." & int2str(i); |
| // vl_widgetId := c_EPTF_ExecCtrl_RegulatorsTotalValueTabId & "." & int2str(i) & ".0"; |
| |
| f_EPTF_Var_newCharstring( |
| vl_currentName, f_EPTF_ExecCtrl_Regulator_getRegulatorNameByRegulatorId(i), vl_idx); |
| |
| // // FIXME: if this is commented in: regulator cannot set the values of its variables |
| // vl_idx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(i); |
| // f_EPTF_Var_addPostProcFn( |
| // vl_idx, { refers(f_EPTF_ExecCtrl_enableRegulatorTargetLoad), {i}} ); |
| // // call the postproc: |
| // f_EPTF_ExecCtrl_enableRegulatorTargetLoad(vl_idx,{i}); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Regulators / Reg Name) id: " |
| &int2str(vl_idx)); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_enableRegulatorTargetLoad( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList |
| ) runs on EPTF_ExecCtrl_CT { |
| if (f_EPTF_Base_cleanupIsInProgress()==false) { |
| return; // cleanup is in progress, GUI may not answer disableWidget request after cleanup |
| } |
| var integer vl_regulatorIdx := pl_argList[0]; |
| var integer vl_regulatedValueVarIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorTotalValueIdxByRegulatorId(vl_regulatorIdx); |
| var integer vl_targetLoadVarIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorTargetLoadIdxByRegulatorId(vl_regulatorIdx); |
| |
| var EPTF_StatusLED vl_statusLEDVal := f_EPTF_Var_getStatusLEDValue(pl_idx); |
| if (vl_statusLEDVal == {led_red, "Disconnected"}) { |
| f_EPTF_Var_setSubsCanAdjust(vl_regulatedValueVarIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_targetLoadVarIdx,true); |
| } else { |
| f_EPTF_Var_setSubsCanAdjust(vl_regulatedValueVarIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_targetLoadVarIdx,false); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_start |
| // |
| // Purpose: |
| // Test management post proc function to start traffic cases |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_start_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_startIdx := pl_argList[0]; |
| var integer vl_stopIdx := pl_argList[1]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,true); |
| |
| // Start scenarios |
| f_EPTF_ExecCtrl_startAllScenarios(); |
| |
| // start the time profiles: |
| // f_EPTF_ExecCtrl_startTimeProfiles(); - already in f_EPTF_ExecCtrl_startAllScenarios() |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_timeElapsed( |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| // TR HQ88308 - Refresh sampled & sync variables on GUI. |
| f_EPTF_ExecCtrl_UIVars_refreshSampledAtSync_vars(); |
| var integer pl_idx := pl_argList[0]; |
| // v_EPTF_ExecCtrl_startTime is -1 if scenarios (=timeProfiles) are not running |
| if (f_EPTF_ExecCtrl_startTime()>0.0) |
| { |
| if(v_EPTF_ExecCtrl_timeFormat == SECONDS) |
| { |
| f_EPTF_Var_adjustContent(pl_idx,{charstringVal := "Time elapsed since Test was started: " & float2str(T_EPTF_componentClock.read-f_EPTF_ExecCtrl_startTime())}); |
| } |
| else if(v_EPTF_ExecCtrl_timeFormat == HH_MM_SS) |
| { |
| var integer vl_nrOfSeconds := float2int(T_EPTF_componentClock.read-f_EPTF_ExecCtrl_startTime()); |
| var integer vl_seconds := vl_nrOfSeconds mod 60; |
| var integer vl_minutes := vl_nrOfSeconds / 60 mod 60; |
| var integer vl_hours := vl_nrOfSeconds / 3600; |
| var charstring vl_formattedTime; |
| if(vl_hours < 10) |
| { |
| vl_formattedTime := "0"&int2str(vl_hours); |
| } |
| else |
| { |
| vl_formattedTime := int2str(vl_hours); |
| } |
| if(vl_minutes < 10) |
| { |
| vl_formattedTime := vl_formattedTime & ":0" & int2str(vl_minutes); |
| } |
| else |
| { |
| vl_formattedTime := vl_formattedTime & ":" & int2str(vl_minutes); |
| } |
| if(vl_seconds < 10) |
| { |
| vl_formattedTime := vl_formattedTime & ":0" & int2str(vl_seconds); |
| } |
| else |
| { |
| vl_formattedTime := vl_formattedTime & ":" & int2str(vl_seconds); |
| } |
| f_EPTF_Var_adjustContent(pl_idx,{charstringVal := "Time elapsed since Test was started: " & vl_formattedTime}); |
| } |
| } |
| } |
| |
| // TR HQ88308 - Refresh sampled & sync variables on GUI. |
| private function f_EPTF_ExecCtrl_UIVars_storeSampledAtSync_vars(in integer pl_varIdx) runs on EPTF_ExecCtrl_CT { |
| |
| v_EPTF_ExecCtrl_SampledAtSync_vars[sizeof(v_EPTF_ExecCtrl_SampledAtSync_vars)] := pl_varIdx; |
| } |
| |
| // TR HQ88308 - Refresh sampled & sync variables on GUI. |
| private function f_EPTF_ExecCtrl_UIVars_refreshSampledAtSync_vars() runs on EPTF_ExecCtrl_CT { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| for(var integer i := 0, size := sizeof(v_EPTF_ExecCtrl_SampledAtSync_vars); i < size; i := i + 1) { |
| f_EPTF_Var_refreshContent(v_EPTF_ExecCtrl_SampledAtSync_vars[i]); // update the gui with the current value |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_Subscribe2TimeElapsed_vars() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_idx; |
| |
| if(v_EPTF_ExecCtrl_timeFormat == SECONDS) |
| { |
| f_EPTF_Var_newCharstring(c_EPTF_ExecCtrl_TimeElapsed, "Time elapsed since Test was started: 0.0", vl_idx); |
| } |
| else if(v_EPTF_ExecCtrl_timeFormat == HH_MM_SS) |
| { |
| f_EPTF_Var_newCharstring(c_EPTF_ExecCtrl_TimeElapsed, "Time elapsed since Test was started: 00:00:00", vl_idx); |
| } |
| |
| f_EPTF_Var_addSyncCallBackFn( |
| refers(f_EPTF_ExecCtrl_UIVars_timeElapsed), {vl_idx} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last created to GUI variable (Time elapsed) id: " |
| &int2str(vl_idx)); |
| |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_stop_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to stop traffic cases |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_stop_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_idx := f_EPTF_Var_getId(c_EPTF_ExecCtrl_TimeElapsed); |
| f_EPTF_ExecCtrl_UIVars_timeElapsed({vl_idx}) |
| |
| var integer vl_startIdx := pl_argList[0]; |
| var integer vl_stopIdx := pl_argList[1]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,false); |
| |
| // restart if not manual: |
| if (not f_EPTF_ExecCtrl_getManualControl() and not tsp_EPTF_ExecCtrl_UIHandler_disableAutoEnablingOfManualControlModeWhenStopButtonIsPressed) { |
| f_EPTF_ExecCtrl_setManualControl(true); |
| } |
| |
| // stop scenarios: |
| f_EPTF_ExecCtrl_stopAllScenarios(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_terminate_PostProc |
| // |
| // Purpose: |
| // Test management post proc function to terminate traffic cases |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_terminate_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_idx := f_EPTF_Var_getId(c_EPTF_ExecCtrl_TimeElapsed); |
| f_EPTF_ExecCtrl_UIVars_timeElapsed({vl_idx}) |
| |
| var integer vl_startIdx := pl_argList[0]; |
| var integer vl_stopIdx := pl_argList[1]; |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,false); |
| |
| // restart if not manual: |
| if (not f_EPTF_ExecCtrl_getManualControl() and not tsp_EPTF_ExecCtrl_UIHandler_disableAutoEnablingOfManualControlModeWhenStopButtonIsPressed) { |
| f_EPTF_ExecCtrl_setManualControl(true); |
| } |
| |
| // terminate scenarios: |
| f_EPTF_ExecCtrl_terminateAllScenarios(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_Snapshot_PostProc |
| // |
| // Purpose: |
| // Test management post proc function for the snapshot button |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // It logs the variables that are registered to save into the log file. |
| // Default setting is used for the tsp and selfName is saved into the variable name. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_Snapshot_PostProc( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Variables saved to: "& f_EPTF_Var_saveVars2tsp()); |
| if (f_EPTF_ExecCtrl_debugEnabled()) { |
| f_EPTF_Var_CT_LogAll("-------SNAPSHOT OF EPTF_Vars------------"); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_Subscribe2TestMgmtButtons_vars |
| // |
| // Purpose: |
| // Subscribe variables to test management buttons and adds test management |
| // post processing functions |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_Subscribe2TestMgmtButtons_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| var integer vl_varId := 0; |
| |
| // Start button |
| var integer vl_startIdx,vl_stopIdx,vl_terminateIdx; |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_Start, 0, vl_startIdx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Start button) id: " |
| &int2str(vl_varId)); |
| |
| // Stop button |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_Stop, 0, vl_stopIdx); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Stop button) id: " |
| &int2str(vl_varId)); |
| |
| // Terminate button |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_Terminate, 0, vl_terminateIdx); |
| |
| // add postProc-es: |
| f_EPTF_Var_addPostProcFn( |
| vl_startIdx, { refers(f_EPTF_ExecCtrl_UIVars_start_PostProc), {vl_startIdx,vl_stopIdx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_stopIdx, { refers(f_EPTF_ExecCtrl_UIVars_stop_PostProc), {vl_startIdx,vl_stopIdx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_terminateIdx, { refers(f_EPTF_ExecCtrl_UIVars_terminate_PostProc), {vl_startIdx,vl_stopIdx}} ); |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Terminate button) id: " |
| &int2str(vl_varId)); |
| |
| /* // uncomment it when needed: |
| // RunTest(Enable test) button |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_RunTest, 0, vl_varId); |
| //f_EPTF_Var_addPostProcFn( |
| // vl_varId, { refers(f_EPTF_ExecCtrl_UIVars_RunTest), {}} ); |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (RunTest button) id: " |
| &int2str(vl_varId)); |
| */ |
| |
| // Snapshot button |
| f_EPTF_Var_newInt( |
| c_EPTF_ExecCtrl_Snapshot, 0, vl_varId); |
| f_EPTF_Var_addPostProcFn( |
| vl_varId, { refers(f_EPTF_ExecCtrl_UIVars_Snapshot_PostProc), {}} ); |
| |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,false); |
| |
| // enable start button |
| if (v_ExecCtrl_manualControl==true) { // test is not running |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,true); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,false); |
| } else { |
| f_EPTF_Var_setSubsCanAdjust(vl_startIdx,false); |
| f_EPTF_Var_setSubsCanAdjust(vl_stopIdx,true); |
| } |
| |
| f_EPTF_ExecCtrl_debug( |
| "Last subscribed to GUI variable (Snapshot button) id: " |
| &int2str(vl_varId)); |
| |
| } |
| |
| friend function f_EPTF_ExecCtrl_UIVars_getPhaseListTabName_FromPhaseListDB(in integer p_idx) |
| runs on EPTF_ExecCtrl_CT |
| return charstring |
| { |
| return "Execution_Control.PhaseLists.tabbox"&"."&f_EPTF_ExecCtrl_getPhaseListDeclaratorName(p_idx)&".tab"; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_enablePhaseInDeclarator( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (not v_ExecCtrl_initialized) { |
| return; |
| } |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_declaratorIdx := pl_argList[0]; |
| var integer vl_phaseIdx := pl_argList[1]; |
| var boolean vl_phaseState := f_EPTF_Var_getBoolValue(pl_idx); |
| |
| f_EPTF_ExecCtrl_setPhaseListDeclaratorPhaseEnabled(vl_declaratorIdx,vl_phaseIdx,vl_phaseState); |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_appendPhaseListTab_vars(in integer p_idx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("### "&%definitionId&"()"); |
| |
| for (var integer i:=0; i<f_EPTF_ExecCtrl_getPhaseListDeclaratorPhasesNum(p_idx); i:=i+1) |
| { |
| var charstring vl_widgetId := f_EPTF_ExecCtrl_UIVars_getPhaseListTabName_FromPhaseListDB(p_idx)& |
| ".mainTable."&f_EPTF_ExecCtrl_getPhaseListDeclaratorPhaseName(p_idx,i); |
| var integer vl_idx; |
| f_EPTF_Var_newBool( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_getPhaseListDeclaratorPhaseEnabled(p_idx,i), |
| vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_enablePhaseInDeclarator), {p_idx, i}} ); |
| } |
| } |
| |
| friend function f_EPTF_ExecCtrl_UIVars_getPhaseListTabName_FromScenarioGroupDB(in integer p_idx) |
| runs on EPTF_ExecCtrl_CT |
| return charstring |
| { |
| return "Execution_Control.PhaseLists.tabbox"&"."&f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListName(p_idx)&".tab"; |
| } |
| |
| friend function f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(in integer p_idx) |
| runs on EPTF_ExecCtrl_CT |
| return charstring |
| { |
| return f_EPTF_ExecCtrl_UIVars_getPhaseListTabName_FromScenarioGroupDB(p_idx) & "." & |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceName(p_idx); |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_guardPhaseForScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| if (v_ExecCtrl_initialized==false) { |
| return false; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var charstring vl_newPhase := pl_newContent.charstringVal; |
| |
| if ( |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceIsValidPhase(vl_scenarioGroupIdx, vl_newPhase)>-1 and |
| ( |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListActualPhaseState(vl_scenarioGroupIdx) == IDLE or |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListActualPhaseState(vl_scenarioGroupIdx) == FINISHED |
| ) |
| ) |
| { return true; } |
| |
| return false; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_setPhaseForScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var charstring vl_phaseName := f_EPTF_Var_getCharstringValue(pl_idx); |
| |
| f_EPTF_ExecCtrl_debug(log2str("Setting phase: " & vl_phaseName & " for " & f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scenarioGroupIdx))); |
| if(not f_EPTF_ExecCtrl_getScenarioGroupInstanceSetPhase(vl_scenarioGroupIdx, vl_phaseName)) {/*this cannot happen*/}; |
| } |
| |
| friend function f_EPTF_ExecCtrl_UIVars_getModeforScenarioGroup(in EPTF_ExecCtrl_ScenarioGroup_ExecMode p_execMode) |
| return charstring |
| { |
| if (p_execMode == MANUAL) |
| { |
| return "MANUAL" |
| } |
| else if (p_execMode == AUTOMATIC) |
| { |
| return "AUTOMATIC" |
| } |
| |
| return "UNKNOWN" |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_guardModeForScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| if (v_ExecCtrl_initialized==false) { |
| return false; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var charstring vl_newMode := pl_newContent.charstringVal; |
| var EPTF_ExecCtrl_ScenarioGroup_ExecMode vl_dummy; |
| |
| if ( |
| f_EPTF_ExecCtrl_ScenarioGroup_isValidExecMode(vl_newMode, vl_dummy) and |
| ( |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListActualPhaseState(vl_scenarioGroupIdx) == IDLE or |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListActualPhaseState(vl_scenarioGroupIdx) == FINISHED |
| ) |
| ) |
| { return true; } |
| |
| return false; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_setModeForScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var charstring vl_modeName := f_EPTF_Var_getCharstringValue(pl_idx); |
| |
| var EPTF_ExecCtrl_ScenarioGroup_ExecMode vl_execMode; |
| if (not f_EPTF_ExecCtrl_ScenarioGroup_isValidExecMode |
| ( |
| vl_modeName, |
| vl_execMode |
| )) {/*cannot happen*/} |
| else { |
| f_EPTF_ExecCtrl_setScenarioGroupInstanceExecMode(vl_scenarioGroupIdx,vl_execMode); |
| }; |
| |
| f_EPTF_ExecCtrl_debug(log2str("Setting mode: " & vl_modeName & " for " & f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scenarioGroupIdx))); |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_getLEDforPhaseList(in EPTF_ExecCtrl_PhaseList_Instance p_pl) |
| return EPTF_StatusLED |
| { |
| if (p_pl.phases[p_pl.actualPhaseIndex].state == IDLE) |
| { |
| return {led_blue, p_pl.phases[p_pl.actualPhaseIndex].name & " - IDLE"} |
| } |
| else if (p_pl.phases[p_pl.actualPhaseIndex].state == RUNNING) |
| { |
| return {led_green, p_pl.phases[p_pl.actualPhaseIndex].name & " - RUNNING"} |
| } |
| else if (p_pl.phases[p_pl.actualPhaseIndex].state == SKIPPING) |
| { |
| return {led_black, p_pl.phases[p_pl.actualPhaseIndex].name & " - SKIPPING"} |
| } |
| else if (p_pl.phases[p_pl.actualPhaseIndex].state == STOPPING) |
| { |
| return {led_red, p_pl.phases[p_pl.actualPhaseIndex].name & " - STOPPING"} |
| } |
| else if (p_pl.phases[p_pl.actualPhaseIndex].state == FINISHED) |
| { |
| return {led_yellow, p_pl.phases[p_pl.actualPhaseIndex].name & " - FINISHED"} |
| } |
| |
| return {led_red, p_pl.phases[p_pl.actualPhaseIndex].name & " - UNKNOWN"} |
| } |
| |
| function fcb_EPTF_ExecCtrl_calcGroupStatus( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_nonVarArgList[0]; |
| |
| pl_retVal := |
| { |
| statusLEDVal := |
| f_EPTF_ExecCtrl_UIVars_getLEDforPhaseList(f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseList(vl_scenarioGroupIdx)) |
| } |
| |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_startScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var boolean vl_start := f_EPTF_Var_getBoolValue(pl_idx); |
| |
| if (not f_EPTF_ExecCtrl_getScenarioGroupInstanceInternalAdjust(vl_scenarioGroupIdx)) |
| { |
| if (vl_start) |
| { |
| f_EPTF_ExecCtrl_debug(log2str("Starting " & f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scenarioGroupIdx))); |
| f_EPTF_ExecCtrl_ScenarioGroup_start(vl_scenarioGroupIdx); |
| } |
| else |
| { |
| f_EPTF_ExecCtrl_debug(log2str("Stopping " & f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scenarioGroupIdx))); |
| f_EPTF_ExecCtrl_ScenarioGroup_stop(vl_scenarioGroupIdx); |
| } |
| } |
| else |
| { |
| f_EPTF_ExecCtrl_setScenarioGroupInstanceInternalAdjust(vl_scenarioGroupIdx, false); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_stopScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_Var_DirectContent pl_newContent) |
| runs on EPTF_ExecCtrl_CT return boolean |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return false; // cleanup is in progress, or not initialized |
| } |
| |
| //var boolean vl_stop := f_EPTF_Var_getBoolValue(pl_idx); |
| //if (not vl_stop) { |
| if (pl_newContent.boolVal == false) { |
| return true; |
| } |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| f_EPTF_ExecCtrl_stopScenarioGroupOnLGens(vl_scenarioGroupIdx); |
| // set the GroupStart button to false: |
| f_EPTF_Var_adjustContent(f_EPTF_ExecCtrl_getScenarioGroupInstanceIsRunningVarIdx(vl_scenarioGroupIdx), {boolVal := false}); |
| return true; |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_resetScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList ) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var boolean vl_start := f_EPTF_Var_getBoolValue(pl_idx); |
| |
| if (vl_start) |
| { |
| f_EPTF_ExecCtrl_debug("Reseting " & f_EPTF_ExecCtrl_getScenarioGroupInstanceName(vl_scenarioGroupIdx)); |
| f_EPTF_ExecCtrl_ScenarioGroup_reset(vl_scenarioGroupIdx); |
| |
| f_EPTF_ExecCtrl_setScenarioGroupInstanceInternalAdjust(vl_scenarioGroupIdx, true); |
| f_EPTF_Var_adjustContent(f_EPTF_ExecCtrl_getScenarioGroupInstanceIsRunningVarIdx(vl_scenarioGroupIdx), {boolVal := false}); |
| f_EPTF_Var_adjustContent(pl_idx, {boolVal := false}); |
| } |
| } |
| |
| function fcb_EPTF_ExecCtrl_calcScenarioStatus( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList, |
| in EPTF_IntegerList pl_nonVarArgList, |
| inout EPTF_Var_DirectContent pl_retVal |
| ) runs on EPTF_ExecCtrl_CT |
| { |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| var integer vl_scenarioGroupIdx := pl_nonVarArgList[0]; |
| var integer vl_scenarioIdx := pl_nonVarArgList[1]; |
| |
| pl_retVal := |
| { |
| statusLEDVal := |
| f_EPTF_ExecCtrl_UIVars_getLEDforPhaseList(f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioPhaseList(vl_scenarioGroupIdx,vl_scenarioIdx)) |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_enablePhaseInScenarioGroup( |
| in integer pl_idx, |
| in EPTF_IntegerList pl_argList) |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| if (v_ExecCtrl_initialized==false) { |
| return; // cleanup is in progress, or not initialized |
| } |
| |
| var integer vl_scenarioGroupIdx := pl_argList[0]; |
| var integer vl_scenarioIdx := pl_argList[1]; |
| var integer vl_phaseIdx := pl_argList[2]; |
| var boolean vl_phaseState := f_EPTF_Var_getBoolValue(pl_idx); |
| |
| f_EPTF_ExecCtrl_setScenarioGroupInstanceScenarioPhaseListPhaseEnabled(vl_scenarioGroupIdx,vl_scenarioIdx,vl_phaseIdx, vl_phaseState); |
| } |
| |
| private function f_EPTF_ExecCtrl_appendScenarioGroupTable_vars(in integer p_idx) |
| runs on EPTF_ExecCtrl_CT |
| { |
| var integer vl_idx; |
| var charstring vl_widgetId; |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".GroupPhase"; |
| f_EPTF_Var_newCharstring( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(p_idx), |
| vl_idx); |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_guardPhaseForScenarioGroup), {p_idx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_setPhaseForScenarioGroup), {p_idx}} ); |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".GroupMode"; |
| f_EPTF_Var_newCharstring( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_UIVars_getModeforScenarioGroup(f_EPTF_ExecCtrl_getScenarioGroupInstanceExecMode(p_idx)), |
| vl_idx); |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_guardModeForScenarioGroup), {p_idx}} ); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_setModeForScenarioGroup), {p_idx}} ); |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".GroupStatus"; |
| f_EPTF_Var_newStatusLED( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_UIVars_getLEDforPhaseList(f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseList(p_idx)), |
| vl_idx); |
| f_EPTF_Var_subscribeLocal(vl_idx,{calcFn := {funcRef:=refers(fcb_EPTF_ExecCtrl_calcGroupStatus), argList:={}, nonVarArgList:={p_idx} } }); |
| // TR HQ88308 - Refresh sampled & sync variables on GUI. |
| f_EPTF_ExecCtrl_UIVars_storeSampledAtSync_vars(vl_idx); |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".GroupStart"; |
| f_EPTF_Var_newBool( |
| "Var." & vl_widgetId, |
| false, |
| vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_startScenarioGroup), {p_idx}} ); |
| f_EPTF_ExecCtrl_setScenarioGroupInstanceIsRunningVarIdx(p_idx,vl_idx); |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".TerminateGroup"; |
| f_EPTF_Var_newBool( |
| "Var." & vl_widgetId, |
| false, |
| vl_idx); |
| f_EPTF_Var_addGuardFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_stopScenarioGroup), {p_idx}} ); |
| |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & ".GroupReset"; |
| f_EPTF_Var_newBool( |
| "Var." & vl_widgetId, |
| false, |
| vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_resetScenarioGroup), {p_idx}} ); |
| |
| |
| for (var integer j:=0; j<f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioNum(p_idx); j:=j+1) |
| { |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & "." & |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioName(p_idx,j) & ".ScenarioStatus"; |
| f_EPTF_Var_newStatusLED( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_UIVars_getLEDforPhaseList(f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioPhaseList(p_idx,j)), |
| vl_idx); |
| f_EPTF_Var_subscribeLocal(vl_idx,{calcFn := {funcRef:=refers(fcb_EPTF_ExecCtrl_calcScenarioStatus), argList:={}, nonVarArgList:={p_idx,j} } }); |
| // TR HQ88308 - Refresh sampled & sync variables on GUI. |
| f_EPTF_ExecCtrl_UIVars_storeSampledAtSync_vars(vl_idx); |
| |
| for (var integer i:=0; i<f_EPTF_ExecCtrl_getScenarioGroupInstanceGroupPhaseListPhasesNum(p_idx); i:=i+1) |
| { |
| vl_widgetId := f_EPTF_ExecCtrl_UIVars_getScenarioGroupTableName_FromScenarioGroupDB(p_idx) & "." & |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioName(p_idx,j) & "." & |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioPhaseListPhaseName(p_idx,j,i); |
| f_EPTF_Var_newBool( |
| "Var." & vl_widgetId, |
| f_EPTF_ExecCtrl_getScenarioGroupInstanceScenarioPhaseListPhaseEnabled(p_idx,j,i), |
| vl_idx); |
| f_EPTF_Var_addPostProcFn( |
| vl_idx, { refers(f_EPTF_ExecCtrl_UIVars_enablePhaseInScenarioGroup), {p_idx, j, i}} ); |
| } |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_appendScenarioGroups_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| for (var integer i:=0; i<f_EPTF_ExecCtrl_getScenarioGroupInstanceDataNum(); i:=i+1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(f_EPTF_ExecCtrl_getScenarioGroupInstanceDataNum())); |
| f_EPTF_ExecCtrl_appendScenarioGroupTable_vars(i); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_UIVars_createPhaseListsTab_vars() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| f_EPTF_ExecCtrl_updateProgressbar(0.0, "Creating Phase Lists variables"); |
| for (var integer i:=0; i<f_EPTF_ExecCtrl_getPhaseListDeclaratorDataNum(); i:=i+1) |
| { |
| f_EPTF_ExecCtrl_updateProgressbar(50.0/int2float(f_EPTF_ExecCtrl_getPhaseListDeclaratorDataNum())); |
| f_EPTF_ExecCtrl_UIVars_appendPhaseListTab_vars(i); |
| } |
| f_EPTF_ExecCtrl_appendScenarioGroups_vars(); |
| f_EPTF_ExecCtrl_updateProgressbar(100.0, "Done"); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_UIVars_SubscribeVars2GUI_vars |
| // |
| // Purpose: |
| // Subscribes execution control related variables to GUI |
| // |
| // Parameters: |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // Execution control related params and statistics handled here |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_UIVars_SubscribeVars2GUI_vars() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug( |
| "### "&%definitionId&"()"); |
| |
| // Subscribe for entity group widgets |
| // f_EPTF_ExecCtrl_UIVars_WaitingForDynamicGUI( |
| // c_EPTF_ExecCtrl_EntityGrpTabId); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2EntityGroupsTab_vars(); |
| |
| // Subscribe for resource widgets |
| // f_EPTF_ExecCtrl_UIVars_WaitingForDynamicGUI( |
| // c_EPTF_ExecCtrl_ResourceTabId); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2ResourceTab_vars(); |
| |
| // Subscribe for EntityGroupDistribution widgets |
| // f_EPTF_ExecCtrl_UIVars_WaitingForDynamicGUI( |
| // c_EPTF_ExecCtrl_GroupDistributionTabId); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2EGrpDistributionTab_vars(); |
| |
| // Subscribe for scenario and traffic case widgets |
| // f_EPTF_ExecCtrl_UIVars_WaitingForDynamicGUI( |
| // c_EPTF_ExecCtrl_TrafficTabId_Scenario); |
| // f_EPTF_ExecCtrl_UIVars_WaitingForDynamicGUI( |
| // c_EPTF_ExecCtrl_TrafficTabId_TC); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2ScenarioTab_vars(); |
| |
| // Subscribe for Regulated Items case widgets |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatedItemsTab_vars(); |
| f_EPTF_ExecCtrl_UIVars_SubscribeVars2RegulatorsTargetValueTab_vars(); |
| |
| f_EPTF_ExecCtrl_UIVars_createPhaseListsTab_vars(); |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_refreshCallBackTargetCPS |
| // |
| // Purpose: |
| // Refresh the Target CPS variables with realtime subscription mode |
| // |
| // Parameters: integer variable index |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_refreshCallBackTargetCPS(in EPTF_IntegerList pl_argList) runs on EPTF_ExecCtrl_CT |
| { |
| if(f_EPTF_Base_cleanupIsInProgress()==false) { |
| return; |
| } |
| if(lengthof(pl_argList) < 1) { |
| f_EPTF_ExecCtrl_warning(%definitionId&": The index of the variable is not set"); |
| return; |
| } |
| if(lengthof(pl_argList) == 2) { |
| var integer vl_actidx := pl_argList[0]; |
| var integer vl_previdx := pl_argList[1]; |
| var float vl_actValue := f_EPTF_Var_getFloatValue(vl_actidx); |
| var float vl_prevValue := f_EPTF_Var_getFloatValue(vl_previdx); |
| if(vl_actValue != vl_prevValue){ |
| f_EPTF_Var_refreshContent(pl_argList[0]); |
| f_EPTF_Var_adjustContent(vl_previdx, { floatVal := vl_actValue }); |
| } |
| } |
| } |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_refreshPostProcRegulatorTotalCPS |
| // |
| // Purpose: |
| // Refresh the Target CPS variables with realtime subscription mode |
| // |
| // Parameters: integer scenario index |
| // - |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_refreshPostProcRegulatorTotalCPS(in integer pl_idx, in EPTF_IntegerList pl_argList) runs on EPTF_ExecCtrl_CT |
| { |
| if(f_EPTF_Base_cleanupIsInProgress()==false) { |
| return; |
| } |
| if(lengthof(pl_argList) < 1) { |
| f_EPTF_ExecCtrl_warning(%definitionId&": The index of the scenario is not set"); |
| return; |
| } |
| var integer vl_regulatorIdx := -1; |
| // scenario CPS |
| if(lengthof(pl_argList) == 1) { |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_numScenarios := f_EPTF_ExecCtrl_numScenarios(); |
| if(0<vl_numScenarios and vl_scIdx<vl_numScenarios) { |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := { cps_SC := { |
| eGrpName := f_EPTF_ExecCtrl_eGrp_name(f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx)), |
| scName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx)} }; |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if(vl_regulatedItemId!=-1) { |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorId(vl_regulatorName); |
| |
| |
| } else { |
| var integer vl_scGroupIndex := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(vl_scIdx); |
| if(vl_scGroupIndex != -1) { |
| vl_idName := { cps_SCInPhase := { |
| eGrpName := f_EPTF_ExecCtrl_eGrp_name(f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx)), |
| scName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx), |
| phase := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGroupIndex)} }; |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if(vl_regulatedItemId!=-1) { |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorId(vl_regulatorName); |
| } else {} |
| } |
| } |
| } |
| } |
| if(lengthof(pl_argList) == 2) { |
| |
| var integer vl_scIdx := pl_argList[0]; |
| var integer vl_tcIdx := pl_argList[1]; |
| var integer vl_numScenarios := f_EPTF_ExecCtrl_numScenarios(); |
| if(0<vl_numScenarios and vl_scIdx<vl_numScenarios) { |
| var integer vl_numTcOfScenario := f_EPTF_ExecCtrl_numTcOfScenario(vl_scIdx); |
| if(0<vl_numTcOfScenario and vl_tcIdx<vl_numTcOfScenario) { |
| var EPTF_ExecCtrl_RegulatedItemName vl_idName := { cps_TC := { |
| eGrpName := f_EPTF_ExecCtrl_eGrp_name(f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx)), |
| scName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx), |
| tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcIdx) |
| } }; |
| var integer vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if(vl_regulatedItemId!=-1) { |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorId(vl_regulatorName); |
| |
| |
| } else { |
| var integer vl_scGroupIndex := f_EPTF_ExecCtrl_ScenarioGroup_get_byScIndex(vl_scIdx); |
| if(vl_scGroupIndex != -1) { |
| vl_idName := { cps_TCInPhase := { |
| eGrpName := f_EPTF_ExecCtrl_eGrp_name(f_EPTF_ExecCtrl_getScenarioEGroupIdx(vl_scIdx)), |
| scName := f_EPTF_ExecCtrl_getScenarioName(vl_scIdx), |
| tcName := f_EPTF_ExecCtrl_tcNameOfTcOfSc(vl_scIdx,vl_tcIdx), |
| phase := f_EPTF_ExecCtrl_getScenarioGroupInstanceActualPhaseName(vl_scGroupIndex)} }; |
| vl_regulatedItemId := f_EPTF_ExecCtrl_Regulator_getRegulatedItemId(vl_idName); |
| if(vl_regulatedItemId!=-1) { |
| var charstring vl_regulatorName := f_EPTF_ExecCtrl_Regulator_getRegulatorName(vl_regulatedItemId); |
| vl_regulatorIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorId(vl_regulatorName); |
| } else {} |
| } |
| } |
| } |
| } |
| } |
| if(vl_regulatorIdx != -1) { |
| var integer vl_regulatorStatusIdx := f_EPTF_ExecCtrl_Regulator_getRegulatorStatusIdxByRegulatorId(vl_regulatorIdx); |
| if (vl_regulatorStatusIdx!=-1) { |
| var EPTF_StatusLED vl_regulatorStatus := f_EPTF_Var_getStatusLEDValue(vl_regulatorStatusIdx); |
| if (vl_regulatorStatus.text == "Auto-off" or vl_regulatorStatus.text == "Disabled") { |
| var float vl_newTotalCps := f_EPTF_ExecCtrl_Regulator_getTotalCps(vl_regulatorIdx); |
| if (f_EPTF_Var_getFloatValue(v_EPTF_ExecCtrl_Regulators[vl_regulatorIdx].totalValueIdx)!=vl_newTotalCps) { |
| f_EPTF_Var_adjustContent(v_EPTF_ExecCtrl_Regulators[vl_regulatorIdx].totalValueIdx,{floatVal := vl_newTotalCps}); |
| } |
| } |
| |
| } |
| } |
| |
| } |
| |
| } // group EPTF_ExecCtrl_UIVars |
| |
| group EPTF_ExecCtrl_EventStatus { |
| |
| // creates and initializes the EventStatus variables |
| private function f_EPTF_ExecCtrl_initEventStatus() runs on EPTF_ExecCtrl_CT { |
| var charstring vl_currentName; |
| var integer vl_idx; |
| // ReadyToRun |
| vl_currentName := "EPTF_ExecCtrl.EventStatus.ReadyToRun"; |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| {led_blue, "ReadyToRun"}, |
| vl_idx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set status for ReadyToRun: ",vl_currentName)); |
| // EndOfConfig |
| vl_currentName := "EPTF_ExecCtrl.EventStatus.EndOfConfig"; |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| {led_blue, "EndOfConfig"}, |
| vl_idx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set status for EndOfConfig: ",vl_currentName)); |
| // GUIDone |
| vl_currentName := "EPTF_ExecCtrl.EventStatus.GUIDone"; |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| {led_blue, "GUIDone"}, |
| vl_idx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set status for GUIDone: ",vl_currentName)); |
| // EndOfTest |
| vl_currentName := "EPTF_ExecCtrl.EventStatus.EndOfTest"; |
| f_EPTF_Var_newStatusLED( |
| vl_currentName, |
| {led_blue, "EndOfTest"}, |
| vl_idx |
| ); |
| f_EPTF_Var_setSubsCanAdjust(vl_idx,false); |
| f_EPTF_ExecCtrl_debug(log2str("Variable created to set status for EndOfTest: ",vl_currentName)); |
| } |
| |
| private function f_EPTF_ExecCtrl_setStatusReadyToRun() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug("ReadyToTun"); |
| var charstring vl_currentName := "EPTF_ExecCtrl.EventStatus.ReadyToRun"; |
| f_EPTF_Var_adjustContent( |
| f_EPTF_Var_getId(vl_currentName), |
| {statusLEDVal := {led_green, "ReadyToRun"}} |
| ); |
| } |
| |
| private function f_EPTF_ExecCtrl_setStatusEndOfConfig() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug("EndOfConfig"); |
| var charstring vl_currentName := "EPTF_ExecCtrl.EventStatus.EndOfConfig"; |
| f_EPTF_Var_adjustContent( |
| f_EPTF_Var_getId(vl_currentName), |
| {statusLEDVal := {led_green, "EndOfConfig"}} |
| ); |
| } |
| |
| friend function f_EPTF_ExecCtrl_setStatusGUIDone() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug("GUIDone"); |
| var charstring vl_currentName := "EPTF_ExecCtrl.EventStatus.GUIDone"; |
| f_EPTF_Var_adjustContent( |
| f_EPTF_Var_getId(vl_currentName), |
| {statusLEDVal := {led_green, "GUIDone"}} |
| ); |
| if (v_ExecCtrl_progressEnabled and v_ExecCtrl_progressBarUIHandler_Idx!=-1) { |
| f_EPTF_Var_adjustContent(v_ExecCtrl_progressBarUIHandler_Idx,{charstringVal := "ExecCtrl: GUI Done."}); |
| } |
| } |
| |
| private function f_EPTF_ExecCtrl_setStatusEndOfTest() runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_debug("EndOfTest"); |
| var charstring vl_currentName := "EPTF_ExecCtrl.EventStatus.EndOfTest"; |
| f_EPTF_Var_adjustContent( |
| f_EPTF_Var_getId(vl_currentName), |
| {statusLEDVal := {led_green, "EndOfTest"}} |
| ); |
| } |
| |
| } //group EPTF_ExecCtrl_EventStatus |
| |
| // R3 LGenPools DB |
| group EPTF_ExecCtrl_LGenPools |
| { |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenPool_initInstanceDB |
| // |
| // Purpose: |
| // Initializes the LGenPool instance DB |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_LGenPool_initInstanceDB() |
| runs on EPTF_ExecCtrl_CT |
| { |
| v_EPTF_ExecCtrl_lgenPools := {}; |
| v_EPTF_ExecCtrl_lgenPoolsHash := f_EPTF_str2int_HashMap_New(c_ExecCtrl_lgenPoolsHashMapName); |
| v_EPTF_ExecCtrl_lgenPoolCompRefHash := f_EPTF_int2int_HashMap_New(c_ExecCtrl_lgenPoolCompRefHashMapName); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenPool_cleanupInstanceDB |
| // |
| // Purpose: |
| // Cleans up the LGenPool instance DB |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_LGenPool_cleanupInstanceDB() |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (v_EPTF_ExecCtrl_lgenPoolsHash != c_ExecCtrl_invalidIdx) { |
| f_EPTF_str2int_HashMap_Delete(c_ExecCtrl_lgenPoolsHashMapName); |
| v_EPTF_ExecCtrl_lgenPoolsHash := c_ExecCtrl_invalidIdx; |
| } |
| v_EPTF_ExecCtrl_lgenPools := {}; |
| if (v_EPTF_ExecCtrl_lgenPoolCompRefHash != c_ExecCtrl_invalidIdx) { |
| f_EPTF_int2int_HashMap_Delete(c_ExecCtrl_lgenPoolCompRefHashMapName); |
| v_EPTF_ExecCtrl_lgenPoolCompRefHash := c_ExecCtrl_invalidIdx; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenPool_loadInstanceDB |
| // |
| // Purpose: |
| // Loads the LGen Pool instance DB from declarators |
| // |
| // Parameters: |
| // pl_lgenPoolDeclarators - *in* <EPTF_ExecCtrl_LGenPool_Declarators> - LGen Pool declarators |
| // pl_entityGroups2LGenPools - *in* <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - Entity group to LGen Pool declarators |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_LGenPool_loadInstanceDB( |
| in EPTF_ExecCtrl_LGenPool_Declarators pl_lgenPoolDeclarators := {}, |
| in EPTF_ExecCtrl_EntityGroup2LGenPool_List pl_entityGroups2LGenPools := {} |
| ) |
| runs on EPTF_ExecCtrl_CT { |
| f_EPTF_ExecCtrl_addLGenPoolsFromDeclarators( |
| pl_lgenPoolDeclarators); |
| |
| f_EPTF_ExecCtrl_addEntityGroups2LGenPoolsFromDeclarators( |
| pl_entityGroups2LGenPools); |
| |
| // LGenPools are loaded when they log in and when the eGroups are distributed on them |
| f_EPTF_ExecCtrl_LGenPool_dumpInstanceDB(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addLGenPoolsFromDeclarators |
| // |
| // Purpose: |
| // Add LGen Pool declarators to the instance DB |
| // |
| // Parameters: |
| // pl_lgenPoolDecl - *in* <EPTF_ExecCtrl_LGenPool_Declarators> - LGen pool declarators to add |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_addLGenPoolsFromDeclarators( |
| in EPTF_ExecCtrl_LGenPool_Declarators pl_lgenPoolDecl |
| ) |
| runs on EPTF_ExecCtrl_CT |
| { |
| for(var integer i := 0, size := sizeof(pl_lgenPoolDecl); i < size; i := i + 1) { |
| f_EPTF_ExecCtrl_addLGenPoolInstance(pl_lgenPoolDecl[i]); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addLGenPoolInstance |
| // |
| // Purpose: |
| // Adds an LGenPool to the instance DB |
| // |
| // Parameters: |
| // pl_lgenPool - *in* <EPTF_ExecCtrl_LGenPool_Declarator> - LGen pool to add |
| // |
| // Return Value: |
| // integer - idx of the LGenPool |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_addLGenPoolInstance(in EPTF_ExecCtrl_LGenPool_Declarator pl_lgenPool) |
| runs on EPTF_ExecCtrl_CT |
| //return integer |
| { |
| var integer vl_idx := sizeof(v_EPTF_ExecCtrl_lgenPools); |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrl_lgenPoolsHash, pl_lgenPool.name, vl_idx); |
| v_EPTF_ExecCtrl_lgenPools[vl_idx].name := pl_lgenPool.name; |
| v_EPTF_ExecCtrl_lgenPools[vl_idx].lgens := {}; |
| v_EPTF_ExecCtrl_lgenPools[vl_idx].lgenPoolItems := pl_lgenPool.lgenPoolItems; |
| //return vl_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getLGenPoolIdx |
| // |
| // Purpose: |
| // Returns the id of an entity group in the instance DB |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // integer - id of the entity group |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_getLGenPoolIdx(in charstring pl_lgenPoolName) |
| runs on EPTF_ExecCtrl_CT |
| return integer |
| { |
| var integer vl_idx := -1; |
| var boolean vl_found := f_EPTF_str2int_HashMap_Find( |
| v_EPTF_ExecCtrl_lgenPoolsHash, |
| pl_lgenPoolName, |
| vl_idx); |
| f_EPTF_Base_assert(%definitionId&": Cannot find LGenPool "&pl_lgenPoolName&" in database.", vl_found); |
| return vl_idx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenPool_createLGens |
| // |
| // Purpose: |
| // Creates the LGens of all LGenPools |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // This function has to be called after <f_EPTF_ExecCtrl_init_CT> has been called |
| // if it's call was disabled in <f_EPTF_ExecCtrl_init_CT>. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_LGenPool_createLGens() |
| runs on EPTF_ExecCtrl_CT |
| { |
| if (v_ExecCtrl_allLGensCreated) { |
| return; |
| } |
| var EPTF_ExecCtrl_CreateLGen_FT vl_createFunc; |
| |
| var integer vl_lgenCounter := 0; |
| for(var integer pl_lgenPoolIdx:=0, size := sizeof(v_EPTF_ExecCtrl_lgenPools); pl_lgenPoolIdx<size;pl_lgenPoolIdx:=pl_lgenPoolIdx+1) { |
| for (var integer i:=0, isize := sizeof(v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems); i<isize; i:=i+1) |
| { |
| if (f_EPTF_ExecCtrl_getLGenFunctionByName(v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].createFunctionName, vl_createFunc)) |
| { |
| for (var integer j:=0; j<v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].num; j:=j+1) |
| { |
| if (vl_createFunc==null) { |
| // this is not possible, null functionRefs are not added to database |
| continue; |
| } |
| var EPTF_ExecCtrlClient_CT vl_client := vl_createFunc.apply(v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].hostname, |
| "LGen"&int2str(vl_lgenCounter)&"."&v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].name |
| &"."&v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].hostname |
| ); |
| if (vl_client==null) { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId& |
| " Couldn't create LGen with function ", v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].createFunctionName, |
| " on host ", v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].hostname, |
| ": Function returned null!" |
| )); |
| continue; // LGen Creation failed |
| } |
| vl_lgenCounter := vl_lgenCounter + 1; |
| // store poolIdx of the lgen into the shadow hashmap: |
| var integer vl_lgenCompRef := f_EPTF_Base_upcast(vl_client); |
| f_EPTF_int2int_HashMap_Insert(v_EPTF_ExecCtrl_lgenPoolCompRefHash, vl_lgenCompRef, pl_lgenPoolIdx); |
| v_ExecCtrl_nrOfClients := v_ExecCtrl_nrOfClients + 1; |
| } |
| } |
| else |
| { |
| f_EPTF_ExecCtrl_warning(log2str( |
| %definitionId&": Couldn't find create function: ", v_EPTF_ExecCtrl_lgenPools[pl_lgenPoolIdx].lgenPoolItems[i].createFunctionName, |
| " Available create functions: ", v_EPTF_ExecCtrl_lgenFunctions |
| )); |
| } |
| } |
| } |
| v_ExecCtrl_allLGensCreated:=true; |
| t_ExecCtrl_allLGensCreated.start; |
| // load buffered EntityResourceInfo messages |
| f_EPTF_ExecCtrl_loadBuffered_EntityResourceInfo(); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_nrOfClients |
| // |
| // Purpose: |
| // Returns the number of ExecCtrlClient components |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // integer - number of ExecCtrlClients |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_nrOfClients() runs on EPTF_ExecCtrl_CT return integer { |
| return v_ExecCtrl_nrOfClients; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenPool_dumpInstanceDB |
| // |
| // Purpose: |
| // Writes the LGenPool intance DB into the log file for debug purposes |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // It dumps the entity group, scenario, traffic case and the LGen instance DB |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_LGenPool_dumpInstanceDB() |
| runs on EPTF_ExecCtrl_CT |
| { |
| f_EPTF_ExecCtrl_debug("---------------------------"&%definitionId&"---------------------------"); |
| f_EPTF_ExecCtrl_debug("LGenPools:"); |
| f_EPTF_ExecCtrl_debug(log2str(v_EPTF_ExecCtrl_lgenPools)); |
| f_EPTF_ExecCtrl_debug("LGenFunctions:"); |
| f_EPTF_ExecCtrl_debug(log2str(v_EPTF_ExecCtrl_lgenFunctions)); |
| f_EPTF_ExecCtrl_debug("---------------------------"&%definitionId&"---------------------------"); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addEntityGroups2LGenPoolsFromDeclarators |
| // |
| // Purpose: |
| // Add Entity group to LGen Pool declarators to the instance DB |
| // |
| // Parameters: |
| // pl_entityGroups2LGenPools - *in* <EPTF_ExecCtrl_EntityGroup2LGenPool_List> - entity group to Lgen pool declarators to add |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_addEntityGroups2LGenPoolsFromDeclarators( |
| in EPTF_ExecCtrl_EntityGroup2LGenPool_List pl_entityGroup2LGenPool_List |
| ) |
| runs on EPTF_ExecCtrl_CT |
| { |
| for(var integer i := 0, size := sizeof(pl_entityGroup2LGenPool_List); i < size; i := i + 1) { |
| f_EPTF_ExecCtrl_addEntityGroup2LGenPool(pl_entityGroup2LGenPool_List[i].eGrpName,pl_entityGroup2LGenPool_List[i].lgenPoolName); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addEntityGroup2LGenPool |
| // |
| // Purpose: |
| // Adds an entity group to an LGenPool |
| // |
| // Parameters: |
| // pl_entityGroupName - *in* *charstring* - entity group to add |
| // pl_lgenPoolName - *in* *charstring* - LGen pool to add to |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_addEntityGroup2LGenPool(in charstring pl_entityGroupName, in charstring pl_lgenPoolName) |
| runs on EPTF_ExecCtrl_CT |
| { |
| var integer vl_eGrpIdx := f_EPTF_ExecCtrl_getEntityGroupIdx(pl_entityGroupName); |
| var integer vl_lgenPoolIdx := f_EPTF_ExecCtrl_getLGenPoolIdx(pl_lgenPoolName); |
| |
| if (vl_eGrpIdx !=-1) { |
| // check if the entity group is already in pool |
| if (v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenPoolIdx!=-1) { |
| f_EPTF_ExecCtrl_error(%definitionId&": Cannot add Entity Group "&pl_entityGroupName& |
| " to the LGenPool: "&pl_lgenPoolName&": already in pool: "& |
| v_EPTF_ExecCtrl_lgenPools[v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenPoolIdx].name); |
| f_EPTF_Base_stopAll(); |
| } |
| } else { |
| f_EPTF_ExecCtrl_error(%definitionId&": Cannot add Entity Group "&pl_entityGroupName& |
| " to the LGenPool: "&pl_lgenPoolName&": EntityGroup does not exists! "); |
| f_EPTF_Base_stopAll(); |
| } |
| v_ExecCtrl_entityGroups[vl_eGrpIdx].lgenPoolIdx := vl_lgenPoolIdx; |
| } |
| |
| // R3 LGenFunctions DB |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenFunctions_initInstanceDB |
| // |
| // Purpose: |
| // Initializes the LGen creator functions instance DB of the LGPools |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_LGenFunctions_initInstanceDB() |
| runs on EPTF_ExecCtrl_CT |
| { |
| v_EPTF_ExecCtrl_lgenFunctions :={} |
| v_EPTF_ExecCtrl_lgenFunctionsHash := f_EPTF_str2int_HashMap_New(c_EPTF_ExecCtrl_LGenFunctionsDB_HashName); |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_LGenFunctions_cleanupInstanceDB |
| // |
| // Purpose: |
| // Cleans up the LGen creator functions instance DB of the LGPools |
| // |
| // Parameters: |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_LGenFunctions_cleanupInstanceDB() |
| runs on EPTF_ExecCtrl_CT |
| { |
| v_EPTF_ExecCtrl_lgenFunctions :={} |
| if (v_EPTF_ExecCtrl_lgenFunctionsHash!=c_ExecCtrl_invalidIdx) { |
| v_EPTF_ExecCtrl_lgenFunctionsHash := c_ExecCtrl_invalidIdx; |
| f_EPTF_str2int_HashMap_Delete(c_EPTF_ExecCtrl_LGenFunctionsDB_HashName); |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addLGenFunctionsFromDeclarators |
| // |
| // Purpose: |
| // Adds the LGen creator functions to the instance DB from declarators |
| // |
| // Parameters: |
| // pl_lgenFunctionsDecl - *in* <EPTF_ExecCtrl_LGenFunction_Entry_List> - the lgen creator functions |
| // |
| // Return Value: |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // Note, that in the declarator, the name is optional. If the |
| // name is not specified, the function is registered with the |
| // auto-generated name only. The automatic name is generated in the format: |
| // ModuleName.FunctionName, where ModuleName is the TTCN3 module that |
| // contains the function, and FunctionName is the name of the |
| // registered function. This autogenerated name can always be used |
| // to find the function, but if the name is specified, |
| // the function can be found by using the specified name too. |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_addLGenFunctionsFromDeclarators( |
| in EPTF_ExecCtrl_LGenFunction_Entry_List pl_lgenFunctionsDecl |
| ) |
| runs on EPTF_ExecCtrl_CT |
| { |
| for(var integer i := 0, size := sizeof(pl_lgenFunctionsDecl); i < size; i := i + 1) { |
| if(-1==f_EPTF_ExecCtrl_addLGenFunctionInstance(pl_lgenFunctionsDecl[i])) {/*ignore null functions*/}; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_addLGenFunctionInstance |
| // |
| // Purpose: |
| // Adds an LGen creator function to the instance DB |
| // |
| // Parameters: |
| // p_declarator - *in* <EPTF_ExecCtrl_LGenFunction_Entry> - the lgen creator function |
| // |
| // Return Value: |
| // integer - the id of the registered function, -1 if unsuccessful |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_addLGenFunctionInstance( |
| in EPTF_ExecCtrl_LGenFunction_Entry p_declarator |
| ) runs on EPTF_ExecCtrl_CT |
| return integer |
| { |
| if (p_declarator.fn==null) { |
| f_EPTF_ExecCtrl_warning(log2str( |
| "LGen Creator function ignored, because it is null in declarator: ",p_declarator)); |
| return -1; |
| } |
| |
| var integer vl_plIdx := -1; |
| var charstring vl_fnName := log2str(p_declarator.fn); |
| var integer vl_strLen := lengthof(vl_fnName); |
| vl_fnName := substr(log2str(p_declarator.fn),7,vl_strLen-8); // cut the refers() out; |
| |
| // registering automatic (ModuleName.FunctionName) name: |
| f_EPTF_ExecCtrl_debug(log2str("Registering automatic function name for function ",p_declarator.fn,": ", vl_fnName)); |
| |
| if (not f_EPTF_str2int_HashMap_Find(v_EPTF_ExecCtrl_lgenFunctionsHash, vl_fnName, vl_plIdx)) |
| { |
| vl_plIdx := sizeof(v_EPTF_ExecCtrl_lgenFunctions); |
| v_EPTF_ExecCtrl_lgenFunctions[vl_plIdx] := p_declarator.fn; |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrl_lgenFunctionsHash, vl_fnName, vl_plIdx); |
| } else { |
| f_EPTF_ExecCtrl_warning(log2str( |
| "LGen Creator function ",p_declarator," ignored, because another function is already added with name: ",vl_fnName)); |
| vl_plIdx := -1; |
| } |
| |
| // registering user defined name also |
| if (not ispresent(p_declarator.name)) { |
| return vl_plIdx; |
| } |
| vl_fnName := p_declarator.name |
| f_EPTF_ExecCtrl_debug(log2str("Registering user defined function name for function ",p_declarator.fn,": ", vl_fnName)); |
| |
| if (not f_EPTF_str2int_HashMap_Find(v_EPTF_ExecCtrl_lgenFunctionsHash, vl_fnName, vl_plIdx)) |
| { |
| // do not store it into the database if it was already stored |
| if (vl_plIdx==-1) { |
| vl_plIdx := sizeof(v_EPTF_ExecCtrl_lgenFunctions); |
| v_EPTF_ExecCtrl_lgenFunctions[vl_plIdx] := p_declarator.fn; |
| } |
| |
| f_EPTF_str2int_HashMap_Insert(v_EPTF_ExecCtrl_lgenFunctionsHash, vl_fnName, vl_plIdx); |
| } else { |
| f_EPTF_ExecCtrl_warning(log2str( |
| "LGen Creator function ",p_declarator," ignored, because another function is already added with name: ",vl_fnName)); |
| vl_plIdx := -1; |
| } |
| return vl_plIdx; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getLGenFunction |
| // |
| // Purpose: |
| // Returns the LGen creator function reference |
| // |
| // Parameters: |
| // p_idx - *in integer* - the idx of lgen creator function |
| // p_creatorFunction - *in* <EPTF_ExecCtrl_CreateLGen_FT> - the reference to the lgen creator function |
| // |
| // Return Value: |
| // boolean - true on success, false otherwise (e.g.: invalid idx) |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_getLGenFunction( |
| in integer p_idx, |
| out EPTF_ExecCtrl_CreateLGen_FT p_creatorFunction |
| ) runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| if (p_idx < 0 or p_idx >= sizeof(v_EPTF_ExecCtrl_lgenFunctions)) { |
| return false; // invalid idx |
| } |
| p_creatorFunction := v_EPTF_ExecCtrl_lgenFunctions[p_idx]; |
| return true; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getLGenFunctionByName |
| // |
| // Purpose: |
| // Returns the LGen creator function reference |
| // |
| // Parameters: |
| // p_functionName - *in charstring* - the name of lgen creator function |
| // p_creatorFunction - *in* <EPTF_ExecCtrl_CreateLGen_FT> - the reference to the lgen creator function |
| // |
| // Return Value: |
| // boolean - true on success, false otherwise (e.g.: invalid idx) |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| private function f_EPTF_ExecCtrl_getLGenFunctionByName( |
| in charstring p_functionName, |
| out EPTF_ExecCtrl_CreateLGen_FT p_creatorFunction |
| ) runs on EPTF_ExecCtrl_CT |
| return boolean |
| { |
| var integer vl_key := -1; |
| |
| if (f_EPTF_str2int_HashMap_Find(v_EPTF_ExecCtrl_lgenFunctionsHash, p_functionName, vl_key)) |
| { |
| if (f_EPTF_ExecCtrl_getLGenFunction(vl_key, p_creatorFunction)) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_getLGenCompRefsOfPool |
| // |
| // Purpose: |
| // Returns the LGen component indexes for a given LGen pool |
| // |
| // Parameters: |
| // pl_poolName - *in charstring* - the name of lgen creator function |
| // pl_lgenIdxList - *out* <EPTF_IntegerList> - the list of LGen component indexes |
| // |
| // Return Value: |
| // - |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_getLGenCompRefsOfPool(in charstring pl_poolName, out EPTF_IntegerList pl_lgenIdxList) runs on EPTF_ExecCtrl_CT { |
| |
| var integer vl_lgenPoolIdxOfLGen := -1; |
| |
| pl_lgenIdxList:={}; |
| for(var integer i := 0, size := sizeof(v_ExecCtrl_lgens); i < size; i := i + 1) { |
| f_EPTF_int2int_HashMap_Find(v_EPTF_ExecCtrl_lgenPoolCompRefHash, v_ExecCtrl_lgens[i].lgenCompRef , vl_lgenPoolIdxOfLGen) |
| if(pl_poolName == v_EPTF_ExecCtrl_lgenPools[vl_lgenPoolIdxOfLGen].name) { |
| pl_lgenIdxList[sizeof(pl_lgenIdxList)] := v_ExecCtrl_lgens[i].lgenCompRef; |
| } |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Function: f_EPTF_ExecCtrl_checkCreatorFnNameOfPool |
| // |
| // Purpose: |
| // It checks whether an LGen creator function was used to create LGens in a specific pool. |
| // |
| // Parameters: |
| // pl_poolName - *in charstring* - the name of lgen creator function |
| // pl_creatorFunctionName - *in charstring* - the name of LGen creator function |
| // pl_poolIdx - *out* *integer* - the index of the LGen pool (-1 if pool is not found) |
| // |
| // Return Value: |
| // *boolean* - true if the behavior function was used to create LGens in the pool, |
| // false if not, or the pool is not found |
| // |
| // Errors: |
| // |
| // Detailed Comments: |
| // |
| /////////////////////////////////////////////////////////// |
| public function f_EPTF_ExecCtrl_checkCreatorFnNameOfPool( |
| in charstring pl_poolName, |
| in charstring pl_creatorFunctionName, |
| out integer pl_poolIdx) runs on EPTF_ExecCtrl_CT |
| return boolean { |
| |
| pl_poolIdx := -1; |
| |
| for(var integer i := 0, size := sizeof(v_EPTF_ExecCtrl_lgenPools); i < size; i := i + 1) { |
| if (v_EPTF_ExecCtrl_lgenPools[i].name == pl_poolName) { |
| pl_poolIdx := i; |
| for(var integer j := 0, isize := sizeof(v_EPTF_ExecCtrl_lgenPools[i].lgenPoolItems); j < isize; j := j + 1) { |
| if (v_EPTF_ExecCtrl_lgenPools[i].lgenPoolItems[j].createFunctionName == pl_creatorFunctionName) { |
| return true; |
| } |
| } |
| return false; // pool found, but given behavior fn is not present |
| } |
| } |
| return false; // pool not found |
| } |
| |
| } // group EPTF_ExecCtrl_LGenPools |
| |
| |
| group ByeBye { |
| |
| // handles Bye and ByeAck messages |
| private altstep as_EPTF_ExecCtrl_MgmtIf_handleByeMsgs() runs on EPTF_ExecCtrl_CT { |
| var EPTF_ExecCtrlClient_CT vl_client; |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_Bye:?) -> sender vl_client { |
| f_EPTF_ExecCtrl_debug("EPTF_ExecCtrl_Bye received from "&log2str(vl_client)); |
| // remove client from database: |
| var integer vl_lgenCompRef := f_EPTF_Base_upcast(vl_client); |
| var integer vl_lgenIdx := f_EPTF_ExecCtrl_getLGenIdx(int2str(vl_lgenCompRef)); |
| if (vl_lgenIdx!=-1) { |
| f_EPTF_ExecCtrl_deleteLGenInstance(vl_lgenIdx); |
| } else { |
| f_EPTF_ExecCtrl_warning(%definitionId&": Some problem might have occured with the ExecCtrl client "&log2str(vl_client) |
| &": It exited before ExecCtrl startup."); |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_ByeAck:{}) to vl_client; |
| repeat; |
| } |
| [] ExecCtrl_MgmtIf_CP.receive(EPTF_ExecCtrl_ByeAck:?) -> sender vl_client { |
| f_EPTF_ExecCtrl_debug("EPTF_ExecCtrl_ByeAck received from "&log2str(vl_client)); |
| v_ExecCtrl_pendingByeCounter := v_ExecCtrl_pendingByeCounter - 1; |
| repeat; |
| } |
| } |
| |
| // sends bye to all clients and waits for responses |
| friend function f_EPTF_ExecCtrl_sendByeToAllClients() runs on EPTF_ExecCtrl_CT { |
| |
| //Remove variable refresh for EGrps //HP34819 |
| for(var integer eg:=0; eg<f_EPTF_ExecCtrl_numEntityGroups(); eg:=eg+1) { |
| var charstring vl_eGrpName := f_EPTF_ExecCtrl_eGrp_name(eg); |
| var charstring vl_varName := c_EPTF_ExecCtrl_statisticsRoot&".EG."&vl_eGrpName&".nofActiveEntities"; |
| var integer vl_varIdx := f_EPTF_Var_getId(vl_varName); |
| if (-1 < vl_varIdx){ |
| f_EPTF_Var_removePostProcFn(vl_varIdx,{refers(f_EPTF_ExecCtrl_eGrp_activeEntities_PostProcFn),{eg}}) |
| } |
| } |
| |
| v_ExecCtrl_pendingByeCounter := 0; |
| for (var integer lgenidx:=0, size := sizeof(v_ExecCtrl_lgens);lgenidx<size;lgenidx:=lgenidx+1) { |
| if (v_ExecCtrl_lgens[lgenidx].lgenCompRef == -1) { |
| continue; // do not send packet to LGen if it already disconnected |
| } |
| ExecCtrl_MgmtIf_CP.send(EPTF_ExecCtrl_Bye:{}) |
| to f_EPTF_Base_downcast(v_ExecCtrl_lgens[lgenidx].lgenCompRef); |
| v_ExecCtrl_pendingByeCounter := v_ExecCtrl_pendingByeCounter + 1; |
| // remove client from database: |
| f_EPTF_ExecCtrl_deleteLGenInstance(lgenidx); |
| } |
| timer t_wait := 0.0; |
| t_wait.start; |
| timer t_maxWait := tsp_EPTF_ExecCtrl_maxKillTime; |
| t_maxWait.start; |
| f_EPTF_ExecCtrl_debug(log2str(%definitionId&": Waiting for all LGens to stop...")); |
| alt { |
| [v_ExecCtrl_pendingByeCounter==0] t_wait.timeout; |
| [] t_maxWait.timeout { |
| f_EPTF_ExecCtrl_warning(log2str(%definitionId& |
| ": MaxWaitTime expired. Not all the LGens stopped. Exiting anyway...")); |
| } |
| } |
| } |
| |
| } // group ByeBye |
| |
| } // group R3 |
| |
| } // module |