Changeset 13610


Ignore:
Timestamp:
Sep 27, 2019 8:20:54 AM (3 months ago)
Author:
Christian Andersson
Message:

Updated compiler code for the evaluator after review. Related to ticket:5837

Location:
branches/dev-cw-evaluator/Compiler
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-cw-evaluator/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r13533 r13610  
    290290    }
    291291   
    292     syn String FType.cMappedTypeString() = "e";
    293     eq FArrayType.cMappedTypeString() = getFPrimitiveType().cMappedTypeString() + "v";
    294     eq FIntegerType.cMappedTypeString() = "i";
    295     eq FEnumType.cMappedTypeString() = "i";
    296     eq FBooleanType.cMappedTypeString() = "i";
    297     eq FRealType.cMappedTypeString() = "d";
    298     eq FStringType.cMappedTypeString() = "s";
    299     eq FRecordType.cMappedTypeString() {
     292
     293    syn String FType.cMappedTypeString() = cMappedTypeStringScalar() + (isArray() ? "v" : "");
     294
     295    syn String FType.cMappedTypeStringScalar() {
     296        throw new InternalCompilerError("cMappedTypeStringScalar() is not supported for class type " + getClass().getSimpleName());
     297    }
     298    eq FArrayType.cMappedTypeStringScalar() = getFPrimitiveType().cMappedTypeStringScalar();
     299    eq FIntegerType.cMappedTypeStringScalar() = "i";
     300    eq FEnumType.cMappedTypeStringScalar() = "i";
     301    eq FBooleanType.cMappedTypeStringScalar() = "i";
     302    eq FRealType.cMappedTypeStringScalar() = "d";
     303    eq FStringType.cMappedTypeStringScalar() = "s";
     304    eq FRecordType.cMappedTypeStringScalar() {
    300305        String o = "R[";
    301306        for (FRecordComponentType rType: getComponents()) {
    302                 o = o.concat(rType.getFType().cMappedTypeString());
     307                o = o.concat(rType.getFType().cMappedTypeStringScalar());
    303308                o = o.concat(",");
    304309        }
     
    306311    }
    307312   
    308     syn String FExternalStmt.functionArgsSerialized(boolean returnVar) {
     313    syn String FExternalStmt.functionReturnArgSerialized() {
     314        if (hasReturnVar()) {
     315            ExternalArgument var = functionArgsToSerialize().iterator().next();
     316            return var.type().cMappedTypeString();
     317        } else {
     318            return "void";
     319        }
     320    }
     321   
     322    syn String FExternalStmt.functionArgsSerialized() {
     323        final boolean hasReturnVar = hasReturnVar();
    309324        boolean skippedReturnVar = false;
    310         final boolean hasReturnVar = hasReturnVar();
    311325       
    312326        String input = "";
    313327        for (ExternalArgument var : functionArgsToSerialize()) {
    314             if (returnVar) {
    315                 if (hasReturnVar) {
    316                     return var.type().cMappedTypeString();
    317                 } else {
    318                     return "void";
    319                 }
    320             }
    321328            if (hasReturnVar && !skippedReturnVar) {
    322329                skippedReturnVar = true;
    323330                continue;
    324331            }
     332           
    325333            if (var.isOutput()) {
    326334               input = input.concat("*");
    327335            }
     336           
    328337            input += var.type().cMappedTypeString() + ",";
    329338        }
  • branches/dev-cw-evaluator/Compiler/ModelicaCompiler/module.options

    r13533 r13610  
    458458
    459459********************************************************************************
    460 BOOLEAN external_constant_dynamic_evaluator compiler experimental true
     460BOOLEAN external_constant_evaluation_dynamic compiler experimental true
    461461
    462462"If enabled, the external function will be evaluated using a pre-compiled
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessCacheImpl.java

    r13562 r13610  
    8585   
    8686    private String getOutputArguments(E ext) {
    87         String output = ext.functionArgsSerialized(true);
    88         if (output.equals("")) {
    89             return "void";
    90         }
    91         return output;
     87        return ext.functionReturnArgSerialized();
    9288    }
    9389   
    9490    private String getInputArguments(E ext) {
    95         return ext.functionArgsSerialized(false);
     91        return ext.functionArgsSerialized();
    9692    }
    9793   
     
    117113   
    118114    public boolean canUseEvaluator(E ext, ArrayList<String> arguments) {
    119         if (!(ext.myOptions().getBooleanOption("external_constant_dynamic_evaluator"))) {
     115        if (!(ext.myOptions().getBooleanOption("external_constant_evaluation_dynamic"))) {
    120116            return false;
    121117        }
     
    165161                ArrayList<String> arguments = new ArrayList<String>();
    166162                String debugMsg = "";
     163                ExternalFunctionExecutable extFunctionExecutable;
    167164                if (canUseEvaluator(ext, arguments)) {
    168165                    String jmHome = System.getenv("JMODELICA_HOME");
     
    172169                    arguments.add(0, executable); /* Needs to be first */
    173170                   
     171                    extFunctionExecutable = new DynamicExternalFunctionExecutable(arguments);
     172                   
    174173                    debugMsg = "Succesfully connected external function '" + ext.getName() + "' to the evaluator '"
    175174                            + executable + "' with outputs: '" + getOutputArguments(ext) + "' and inputs: '" + getInputArguments(ext) + "'";
    176175                } else {
    177176                    executable = mc.compileExternal(ext);
     177                   
     178                    extFunctionExecutable = new CompiledExternalFunctionExecutable(executable);
     179                   
    178180                    debugMsg = "Succesfully compiled external function '" + ext.getName() + "' to executable '"
    179181                            + executable + "' code for evaluation";
    180182                }
    181                 arguments = arguments.size() == 0 ? null : arguments; /* Can likely be made better...*/
     183               
    182184                if (ext.shouldCacheProcess()) {
    183                     ef = new MappedExternalFunction(ext, executable, arguments);
     185                    ef = new MappedExternalFunction(ext, extFunctionExecutable);
    184186                } else {
    185                     ef = new CompiledExternalFunction(ext, executable, arguments);
     187                    ef = new CompiledExternalFunction(ext, extFunctionExecutable);
    186188                }
    187189                time = System.currentTimeMillis() - time;
     
    229231        return "Failed to evaluate external function '" + name + "', " + msg;
    230232    }
     233   
     234    private abstract class ExternalFunctionExecutable {
     235       
     236        public abstract ProcessBuilder createProcessBuilder();
     237       
     238        public abstract void remove();
     239    }
     240   
     241    private class CompiledExternalFunctionExecutable extends ExternalFunctionExecutable {
     242        protected String executable;
     243       
     244        public CompiledExternalFunctionExecutable(String executable) {
     245            this.executable = executable;
     246        }
     247       
     248        @Override
     249        public ProcessBuilder createProcessBuilder() {
     250            return new ProcessBuilder(executable);
     251        }
     252       
     253        @Override
     254        public void remove() {
     255            new File(executable).delete();
     256        }
     257    }
     258   
     259   
     260    private class DynamicExternalFunctionExecutable extends ExternalFunctionExecutable {
     261        protected ArrayList<String> executable;
     262       
     263        public DynamicExternalFunctionExecutable(ArrayList<String> executable) {
     264            this.executable = executable;
     265        }
     266       
     267        @Override
     268        public ProcessBuilder createProcessBuilder() {
     269            return new ProcessBuilder(executable);
     270        }
     271        @Override
     272        public void remove() {
     273            // Do not remove the dynamic executable
     274        }
     275    }
    231276
    232277    private class FailedExternalFunction implements ExternalFunction<K, V> {
     
    267312     */
    268313    private class CompiledExternalFunction implements ExternalFunction<K, V> {
    269         protected String executable;
    270         protected ArrayList<String> arguments;
     314        protected ExternalFunctionExecutable extFunctionExecutable;
    271315        protected ProcessBuilder processBuilder;
    272316        private String msg;
    273317
    274         public CompiledExternalFunction(External<K> ext, String executable, ArrayList<String> arguments) {
    275             this.executable = executable;
    276             this.arguments = arguments;
     318        public CompiledExternalFunction(External<K> ext, ExternalFunctionExecutable extFunctionExecutable) {
     319            this.extFunctionExecutable = extFunctionExecutable;
    277320            this.processBuilder = createProcessBuilder(ext);
    278321            this.msg = "Succesfully compiled external function '" + ext.getName() + "'";
     
    348391        @Override
    349392        public void remove() {
    350             if (arguments == null) {
    351                 new File(executable).delete();
    352             }
     393            extFunctionExecutable.remove();
    353394        }
    354395
    355396        private ProcessBuilder createProcessBuilder(External<K> ext) {
    356             ProcessBuilder pb;
    357             if (arguments == null) {
    358                 pb = new ProcessBuilder(executable);
    359             } else {
    360                 pb = new ProcessBuilder(arguments);
    361             }
     397            ProcessBuilder pb = extFunctionExecutable.createProcessBuilder();
    362398            Map<String, String> env = pb.environment();
    363399            if (env.keySet().contains("Path")) {
     
    403439        private final int externalConstantEvaluationMaxProc;
    404440
    405         public MappedExternalFunction(External<K> ext, String executable, ArrayList<String> arguments) {
    406             super(ext, executable, arguments);
     441        public MappedExternalFunction(External<K> ext, ExternalFunctionExecutable extFunctionExecutable) {
     442            super(ext, extFunctionExecutable);
    407443            externalConstantEvaluationMaxProc = ext.myOptions()
    408444                    .getIntegerOption("external_constant_evaluation_max_proc");
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessMultiCache.java

    r13437 r13610  
    3434
    3535        public Iterable<K> functionArgsToSerialize();
    36        
    37         public String functionArgsSerialized(boolean returnVar);
     36
     37        public String functionArgsSerialized();
     38
     39        public String functionReturnArgSerialized();
    3840
    3941        public Iterable<K> varsToDeserialize();
    40        
     42
    4143        public String[] library();
    4244    }
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/ExternalProcessCacheTest.java

    r13437 r13610  
    225225       
    226226        @Override
    227         public String functionArgsSerialized(boolean returnVar) {
     227        public String functionArgsSerialized() {
     228            // TODO Auto-generated method stub
     229            return null;
     230        }
     231       
     232        @Override
     233        public String functionReturnArgSerialized() {
    228234            // TODO Auto-generated method stub
    229235            return null;
Note: See TracChangeset for help on using the changeset viewer.