From e44b65be54cf6bf9b4697cf526008989f4a9ed47 Mon Sep 17 00:00:00 2001 From: Lennart Ochel Date: Mon, 21 Sep 2015 14:03:35 +0200 Subject: [PATCH] Exclude removeInitializationStuff from postOptModules since it is essential --- Compiler/BackEnd/BackendDAEUtil.mo | 44 ++++++++++++++++-------------- Compiler/Util/Flags.mo | 2 -- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo index 2eae6c401ad..a2cd08e3dc0 100644 --- a/Compiler/BackEnd/BackendDAEUtil.mo +++ b/Compiler/BackEnd/BackendDAEUtil.mo @@ -6492,14 +6492,14 @@ public function getSolvedSystem "Run the equation system pipeline." input Option strmatchingAlgorithm = NONE(); input Option strdaeHandler = NONE(); input Option> strPostOptModules = NONE(); - output BackendDAE.BackendDAE outSODE; + output BackendDAE.BackendDAE outSimDAE; output BackendDAE.BackendDAE outInitDAE; output Boolean outUseHomotopy "true if homotopy(...) is used during initialization"; output list outRemovedInitialEquationLst; output list outPrimaryParameters "already sorted"; output list outAllPrimaryParameters "already sorted"; protected - BackendDAE.BackendDAE optdae, sode, sode1, optsode; + BackendDAE.BackendDAE dae, simDAE; list> preOptModules; list> postOptModules; tuple daeHandler; @@ -6518,59 +6518,62 @@ algorithm end if; // pre-optimization phase - optdae := preOptimizeDAE(inDAE, preOptModules); + dae := preOptimizeDAE(inDAE, preOptModules); // transformation phase (matching and sorting using index reduction method) - sode := causalizeDAE(optdae, NONE(), matchingAlgorithm, daeHandler, true); + dae := causalizeDAE(dae, NONE(), matchingAlgorithm, daeHandler, true); SimCodeFunctionUtil.execStat("matching and sorting"); + dae := BackendDAEOptimize.removeUnusedFunctions(dae); + SimCodeFunctionUtil.execStat("remove unused functions"); + if Flags.isSet(Flags.GRAPHML) then - HpcOmTaskGraph.dumpBipartiteGraph(sode, fileNamePrefix); + HpcOmTaskGraph.dumpBipartiteGraph(dae, fileNamePrefix); end if; if Flags.isSet(Flags.BLT_DUMP) then - BackendDump.bltdump("bltdump", sode); + BackendDump.bltdump("bltdump", dae); end if; if Flags.isSet(Flags.EVAL_OUTPUT_ONLY) then // prepare the equations - sode := BackendDAEOptimize.evaluateOutputsOnly(sode); + dae := BackendDAEOptimize.evaluateOutputsOnly(dae); end if; - sode := BackendDAEOptimize.removeUnusedFunctions(sode); - // generate system for initialization - (outInitDAE, outUseHomotopy, outRemovedInitialEquationLst, outPrimaryParameters, outAllPrimaryParameters) := Initialization.solveInitialSystem(sode); + (outInitDAE, outUseHomotopy, outRemovedInitialEquationLst, outPrimaryParameters, outAllPrimaryParameters) := Initialization.solveInitialSystem(dae); + + simDAE := Initialization.removeInitializationStuff(dae); // post-optimization phase - optsode := postOptimizeDAE(sode, postOptModules, matchingAlgorithm, daeHandler); + simDAE := postOptimizeDAE(simDAE, postOptModules, matchingAlgorithm, daeHandler); - sode1 := FindZeroCrossings.findZeroCrossings(optsode); + simDAE := FindZeroCrossings.findZeroCrossings(simDAE); SimCodeFunctionUtil.execStat("findZeroCrossings"); - _ := traverseBackendDAEExpsNoCopyWithUpdate(sode1, ExpressionSimplify.simplifyTraverseHelper, 0) "simplify all expressions"; + _ := traverseBackendDAEExpsNoCopyWithUpdate(simDAE, ExpressionSimplify.simplifyTraverseHelper, 0) "simplify all expressions"; SimCodeFunctionUtil.execStat("SimplifyAllExp"); - outSODE := calculateValues(sode1); + outSimDAE := calculateValues(simDAE); SimCodeFunctionUtil.execStat("calculateValue"); if Flags.isSet(Flags.DUMP_INDX_DAE) then - BackendDump.dumpBackendDAE(outSODE, "dumpindxdae"); + BackendDump.dumpBackendDAE(outSimDAE, "dumpindxdae"); if Flags.isSet(Flags.ADDITIONAL_GRAPHVIZ_DUMP) then - BackendDump.graphvizBackendDAE(outSODE, "dumpindxdae"); + BackendDump.graphvizBackendDAE(outSimDAE, "dumpindxdae"); end if; end if; if Flags.isSet(Flags.DUMP_TRANSFORMED_MODELICA_MODEL) then - BackendDump.dumpBackendDAEToModelica(outSODE, "dumpindxdae"); + BackendDump.dumpBackendDAEToModelica(outSimDAE, "dumpindxdae"); end if; if Flags.isSet(Flags.DUMP_BACKENDDAE_INFO) or Flags.isSet(Flags.DUMP_STATESELECTION_INFO) or Flags.isSet(Flags.DUMP_DISCRETEVARS_INFO) then - BackendDump.dumpCompShort(outSODE); + BackendDump.dumpCompShort(outSimDAE); end if; if Flags.isSet(Flags.DUMP_EQNINORDER) then - BackendDump.dumpEqnsSolved(outSODE, "indxdae: eqns in order"); + BackendDump.dumpEqnsSolved(outSimDAE, "indxdae: eqns in order"); end if; - checkBackendDAEWithErrorMsg(outSODE); + checkBackendDAEWithErrorMsg(outSimDAE); end getSolvedSystem; public function preOptimizeBackendDAE " @@ -7253,7 +7256,6 @@ algorithm (EvaluateParameter.evaluateReplaceProtectedFinalEvaluateParameters, "evaluateReplaceProtectedFinalEvaluateParameters", false), (ExpressionSolve.solveSimpleEquations, "solveSimpleEquations", false), (HpcOmEqSystems.partitionLinearTornSystem, "partlintornsystem", false), - (Initialization.removeInitializationStuff, "removeInitializationStuff", true), (InlineArrayEquations.inlineArrayEqn, "inlineArrayEqn", false), (OnRelaxation.relaxSystem, "relaxSystem", false), (RemoveSimpleEquations.removeSimpleEquations, "removeSimpleEquations", false), diff --git a/Compiler/Util/Flags.mo b/Compiler/Util/Flags.mo index 7133c743a73..5d538e97516 100644 --- a/Compiler/Util/Flags.mo +++ b/Compiler/Util/Flags.mo @@ -764,7 +764,6 @@ constant ConfigFlag INDEX_REDUCTION_METHOD = CONFIG_FLAG(15, "indexReductionMeth constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules", NONE(), EXTERNAL(), STRING_LIST_FLAG({ - "removeInitializationStuff", "lateInlineFunction", "simplifyConstraints", "CSE", @@ -828,7 +827,6 @@ constant ConfigFlag POST_OPT_MODULES = CONFIG_FLAG(16, "postOptModules", ("relaxSystem", Util.notrans("relaxation from gausian elemination")), ("removeConstants", Util.gettext("Remove all constants in the system.")), ("removeEqualFunctionCalls", Util.notrans("Detects equal function calls of the form a=f(b) and c=f(b) and substitutes them to get speed up.")), - ("removeInitializationStuff", Util.gettext("Does simplifications by removing initialization information like homotopy(..) and initial().")), ("removeSimpleEquations", removeSimpleEquationDesc), ("removeUnusedParameter", Util.gettext("Strips all parameter not present in the equations from the system to get speed up for compilation of target code.")), ("removeUnusedVariables", Util.notrans("Strips all variables not present in the equations from the system to get speed up for compilation of target code.")),