Changeset 13437

Timestamp:

Sep 9, 2019 9:59:31 PM (3 months ago)

Author:

Christian Andersson

Message:

Updated to compiler to use the evaluator. Related to ticket:5837

Location:

branches/dev-cw-evaluator/Compiler

Files:

• ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag (modified) (1 diff)
• ModelicaCompiler/module.options (modified) (1 diff)
• ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessCacheImpl.java (modified) (9 diffs)
• ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessMultiCache.java (modified) (1 diff)
• ModelicaFrontEnd/src/java/org/jmodelica/util/SystemUtil.java (modified) (1 diff)
• ModelicaFrontEnd/test/junit/org/jmodelica/test/common/ExternalProcessCacheTest.java (modified) (2 diffs)

branches/dev-cw-evaluator/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

@@ -288 +288 @@
         }
         return functionArgs;
+    }
+    
+    syn String FExternalStmt.convertFtypeToExternalString(FType arg, boolean useSeparator) {
+        String input = "";
+        if (arg.isReal()) {
+            input = input.concat("d");
+        } else if (arg.isInteger() || arg.isEnum()) {
+            input = input.concat("i");
+        } else if (arg.isString()) {
+            input = input.concat("s");
+        } else if (arg.isRecord()) {
+            input = input.concat("R[");
+            for (FRecordComponentType rType: ((FRecordType)arg).getComponents()) {
+                input = input.concat(convertFtypeToExternalString(rType.getFType(), true));
+            }
+            input = input.concat("]");
+        }
+        if (useSeparator) {
+            input = input.concat(",");
+        }
+        return input;
+    }
+    
+    syn String FExternalStmt.functionArgsSerialized(boolean returnVar) {
+        boolean skippedReturnVar = false;
+        String input = "";
+        for (ExternalArgument var : functionArgsToSerialize()) {
+            if (returnVar) {
+                if (hasReturnVar()) {
+                    return convertFtypeToExternalString(var.type(), false);
+                } else {
+                    return "void";
+                }
+            }
+            if (hasReturnVar() && skippedReturnVar != true) { 
+                skippedReturnVar = true;
+                continue; 
+            }
+            if (var.isOutput()) {
+               input = input.concat("*");
+            }
+            input = input.concat(convertFtypeToExternalString(var.type(), true));
+        }
+        return input;
     }
     

branches/dev-cw-evaluator/Compiler/ModelicaCompiler/module.options

@@ -458 +458 @@
 
 ********************************************************************************
-
+BOOLEAN enable_external_evaluator compiler experimental false
+
+"If enabled, the external function will be evaluated using a pre-compiled
+program (instead of generating and compiling one), if possible."
+********************************************************************************

branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessCacheImpl.java

@@ -3 +3 @@
 import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.FilenameFilter;
 import java.io.IOException;
 import java.io.PrintStream;
@@ -16 +17 @@
 import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Variable;
 import org.jmodelica.util.EnvironmentUtils;
+import org.jmodelica.util.SystemUtil;
 import org.jmodelica.util.ccompiler.CCompilerDelegator;
 import org.jmodelica.util.exceptions.CcodeCompilationException;
@@ -42 +44 @@
         return mc.log();
     }
-
+    
+    private String getSharedLibrary(External<K> ext) {
+        /* Messy messy... */
+        String sharedLib = "";
+        final String extName = ext.getName();
+        String platform = CCompilerDelegator.reduceBits(EnvironmentUtils.getJavaPlatform(),
+                mc.getCCompiler().getTargetPlatforms());
+        File f = new File(ext.libraryDirectory(), platform);
+        String libLoc = f.isDirectory() ? f.getPath() : ext.libraryDirectory();
+        File dir = new File(libLoc);
+        File[] matches = dir.listFiles(new FilenameFilter()
+        {
+          public boolean accept(File dir, String name)
+          {
+             return name.contains(extName) && name.endsWith(SystemUtil.sharedLibraryExtension());
+          }
+        });
+        for(File file : matches) {
+            sharedLib = file.toString();
+            break;
+        }
+        if (sharedLib.equals("")) {
+            for (String lib : ext.library()) {
+                File tmp = new File(libLoc, lib.concat(SystemUtil.sharedLibraryExtension()));
+                if (tmp.exists() && !tmp.isDirectory()) {
+                    sharedLib = tmp.toString();
+                }
+            }
+        }
+        return sharedLib;
+    }
+    
+    private String getOutputArguments(E ext) {
+        String output = ext.functionArgsSerialized(true);
+        if (output.equals("")) {
+            return "void";
+        }
+        return output;
+    }
+    
+    private String getInputArguments(E ext) {
+        return ext.functionArgsSerialized(false);
+    }
+    
+    public boolean canUseEvaluator(E ext) {
+        for (K eo : ext.externalObjectsToSerialize()) {
+            return false;
+        }
+        
+        if (!(ext.myOptions().getBooleanOption("enable_external_evaluator"))) {
+            return false;
+        }
+        /* TODO:
+         * Verify that the library used is a shared library, not static. */
+        /* Builtins, such as Modelica functions should be accepted 
+           Verify that the actual inputs/outputs are supported */
+        
+        return true;
+    }
+    
     @Override
     public ExternalFunction<K, V> getExternalFunction(E ext) {
@@ -52 +113 @@
             try {
                 long time = System.currentTimeMillis();
-                String executable = mc.compileExternal(ext);
+                String executable = null;
+                ArrayList<String> arguments = null;
+                if (canUseEvaluator(ext)) {
+                    String jmHome = System.getenv("JMODELICA_HOME");
+                    executable = jmHome + File.separator + "bin" + File.separator + CCompilerDelegator.reduceBits(EnvironmentUtils.getJavaPlatform(),mc.getCCompiler().getTargetPlatforms()) + File.separator + "jmi_evaluator" + SystemUtil.executableExtension();
+                    
+                    String sharedLibrary = getSharedLibrary(ext);
+                    if (sharedLibrary.equals("")) { sharedLibrary = "NoSharedLibrary"; }
+                    
+                    arguments = new ArrayList<String>();
+                    arguments.add(executable);
+                    arguments.add(sharedLibrary);
+                    arguments.add(ext.getName());
+                    arguments.add(getOutputArguments(ext));
+                    arguments.add(getInputArguments(ext));
+                    
+                    mc.log().debug("Using pre-compiled evaluator for outputs: '" + getOutputArguments(ext) + "' and inputs: '" + getInputArguments(ext));
+                } else {
+                    executable = mc.compileExternal(ext);
+                }
                 if (ext.shouldCacheProcess()) {
-                    ef = new MappedExternalFunction(ext, executable);
+                    ef = new MappedExternalFunction(ext, executable, arguments);
                 } else {
-                    ef = new CompiledExternalFunction(ext, executable);
+                    ef = new CompiledExternalFunction(ext, executable, arguments);
                 }
                 time = System.currentTimeMillis() - time;
@@ -142 +222 @@
     private class CompiledExternalFunction implements ExternalFunction<K, V> {
         protected String executable;
+        protected ArrayList<String> arguments;
         protected ProcessBuilder processBuilder;
         private String msg;
 
-        public CompiledExternalFunction(External<K> ext, String executable) {
+        public CompiledExternalFunction(External<K> ext, String executable, ArrayList<String> arguments) {
             this.executable = executable;
+            this.arguments = arguments;
             this.processBuilder = createProcessBuilder(ext);
             this.msg = "Succesfully compiled external function '" + ext.getName() + "'";
@@ -189 +271 @@
         public void evaluate(External<K> ext, Map<K, V> values, int timeout, ProcessCommunicator<V, T> com)
                 throws IOException {
+            long time = System.currentTimeMillis();
+            log().debug("Evaluating external function: " + ext.getName());
             com.startTimer(timeout);
             com.check("EVAL");
@@ -201 +285 @@
             com.accept("READY");
             com.cancelTimer();
+            time = System.currentTimeMillis() - time;
+            log().debug("Finished evaluating external function, time: " + time + "ms");
         }
 
@@ -220 +306 @@
         @Override
         public void remove() {
-            new File(executable).delete();
+            if (arguments == null) {
+                new File(executable).delete();
+            }
+        }
+        
+        public ProcessBuilder _createProcessBuilder(External<K> ext) {
+            ProcessBuilder pb;
+            if (arguments == null) {
+                pb = new ProcessBuilder(executable);
+            } else {
+                pb = new ProcessBuilder(arguments);
+            }
+            return pb;
         }
 
         private ProcessBuilder createProcessBuilder(External<K> ext) {
-            ProcessBuilder pb = new ProcessBuilder(executable);
+            ProcessBuilder pb = _createProcessBuilder(ext);
             Map<String, String> env = pb.environment();
             if (env.keySet().contains("Path")) {
@@ -268 +366 @@
         private final int externalConstantEvaluationMaxProc;
 
-        public MappedExternalFunction(External<K> ext, String executable) {
-            super(ext, executable);
+        public MappedExternalFunction(External<K> ext, String executable, ArrayList<String> arguments) {
+            super(ext, executable, arguments);
             externalConstantEvaluationMaxProc = ext.myOptions()
                     .getIntegerOption("external_constant_evaluation_max_proc");

branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessMultiCache.java

@@ -34 +34 @@
 
         public Iterable<K> functionArgsToSerialize();
+        
+        public String functionArgsSerialized(boolean returnVar);
 
         public Iterable<K> varsToDeserialize();
+        
+        public String[] library();
     }
 

branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/SystemUtil.java

@@ -72 +72 @@
         return isLinux() ? "" : ".exe";
     }
+    
+    public static String sharedLibraryExtension() {
+        if (isWindows()) {
+            return ".dll";
+        } else if (isLinux()) {
+            return ".so";
+        } else {
+            return ".dylib";
+        }
+    }
 
     /**

branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/ExternalProcessCacheTest.java

@@ -223 +223 @@
             return null;
         }
+        
+        @Override
+        public String functionArgsSerialized(boolean returnVar) {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
         @Override
@@ -229 +235 @@
             return null;
         }
+        
+        @Override
+        public String[] library() {
+            // TODO Auto-generated method stub
+            return null;
+        }
 
     }