Changeset 11524


Ignore:
Timestamp:
Aug 29, 2018 1:20:05 PM (15 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Refactoring external evaluation

Location:
trunk/Compiler
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/Compiler/GenericCodeGen/src/jastadd/ExternalCEvalTag.jrag

    r10338 r11524  
    5757        if (ext == null) {
    5858            for (FExternalStmt ext : fClass.myExternals()) {
    59                 if (ext.canEvaluate(ASTNode.defaultVariableEvaluator().createEmptyAlgorithmEvaluator(ext.myOptions()))
    60                         && !ext.isConstructorStmt() && !ext.isDestructorStmt()) {
     59                if (!ext.isConstructorStmt() && !ext.isDestructorStmt()) {
    6160                    generate_wrap(str, ext, unitCgc, unitTempMap);
    6261                }
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r11514 r11524  
    9898            stmt.setCodeGenContext(cgc.createProxy());
    9999            ArrayList<FExp> args = stmt.myConstructorArgs();
    100             CommonVariableDecl out = stmt.myConstructorOutput();
     100            ExternalArgument out = stmt.myConstructorOutput();
    101101            String name = acquireTemp(name());
    102102            stmt.getCodeGenContext().setAlias(out.name_C(), name());
     
    165165     */
    166166    public void FExternalStmt.genSerialize_C(TypePrinter_C tp, String indent,
    167             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    168         for (CommonVariableDecl cvd : cvds) {
     167            CodeGenContext cgc, Map<String,String> tempMap, Iterable<ExternalArgument> cvds) {
     168        for (ExternalArgument cvd : cvds) {
    169169            tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
    170170            cvd.type().print(tp);
     
    173173   
    174174    public void FExternalStmt.genSerializeComps_C(TypePrinter_C tp, String indent,
    175             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    176         for (CommonVariableDecl cvd : cvds) {
     175            CodeGenContext cgc, Map<String,String> tempMap, Iterable<ExternalArgument> cvds) {
     176        for (ExternalArgument cvd : cvds) {
    177177            tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
    178178            tp.printComps((FExternalObjectType)cvd.type());
     
    181181   
    182182    public void FExternalStmt.genSerializeNoComps_C(TypePrinter_C tp, String indent,
    183             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    184         for (CommonVariableDecl cvd : cvds) {
     183            CodeGenContext cgc, Map<String,String> tempMap, Iterable<ExternalArgument> cvds) {
     184        for (ExternalArgument cvd : cvds) {
    185185            tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
    186186            tp.printExt((FExternalObjectType)cvd.type());
     
    198198        prettyPrint_C(p, str, indent);
    199199        genCheckPoint(str, indent, "DONE");
    200         for (CommonVariableDecl cvd : varsToDeserialize())
     200        for (ExternalArgument cvd : varsToDeserialize())
    201201            cvd.type().genSerialize_C(str, indent, cvd.name_C(), false);
    202202        str.println();
     
    232232   
    233233    /**
    234      * List of CommonVariableDecl which has to be sent to the process
     234     * List of ExternalArgument which has to be sent to the process
    235235     * when evaluating an external function.
    236236     */
    237     syn ArrayList<CommonVariableDecl> FExternalStmt.varsToSerialize() {
     237    syn ArrayList<ExternalArgument> FExternalStmt.varsToSerialize() {
    238238        if (!hasArg() && !hasReturnVar())
    239             return myCommonVarDecls();
     239            return new ArrayList<ExternalArgument>(myCommonVarDecls());
    240240       
    241         ArrayList<CommonVariableDecl> res = new ArrayList<CommonVariableDecl>();
     241        ArrayList<ExternalArgument> res = new ArrayList<>();
    242242        if (hasReturnVar())
    243243            res.add(getReturnVar().myCommonVarDecl());
     
    248248    }
    249249   
    250     public void FExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
     250    public void FExp.varsToSerialize(ArrayList<ExternalArgument> decls) {
    251251       
    252252    }
    253253   
    254     public void FIdUseExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
    255         CommonVariableDecl cvd = myCommonVarDecl();
     254    public void FIdUseExp.varsToSerialize(ArrayList<ExternalArgument> decls) {
     255        ExternalArgument cvd = myCommonVarDecl();
    256256        if (!decls.contains(cvd))
    257257            decls.add(cvd);
    258258    }
    259259   
    260     public void FSizeExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
     260    public void FSizeExp.varsToSerialize(ArrayList<ExternalArgument> decls) {
    261261        getFExp().varsToSerialize(decls);
    262262        //getDim().varsToSerialize(decls);
    263263    }
    264264   
    265     syn ArrayList<CommonVariableDecl> FExternalStmt.externalObjectsToSerialize() {
    266         ArrayList<CommonVariableDecl> externalObjects = new ArrayList<CommonVariableDecl>();
    267 
    268         for (CommonVariableDecl var : varsToSerialize()) {
     265    syn ArrayList<ExternalArgument> FExternalStmt.externalObjectsToSerialize() {
     266        ArrayList<ExternalArgument> externalObjects = new ArrayList<ExternalArgument>();
     267
     268        for (ExternalArgument var : varsToSerialize()) {
    269269            if (var.type().isExternalObject()) {
    270270                externalObjects.add(var);
     
    275275    }
    276276   
    277     syn ArrayList<CommonVariableDecl> FExternalStmt.functionArgsToSerialize() {
    278         ArrayList<CommonVariableDecl> functionArgs = new ArrayList<CommonVariableDecl>();
    279 
    280         for (CommonVariableDecl var : varsToSerialize()) {
     277    syn ArrayList<ExternalArgument> FExternalStmt.functionArgsToSerialize() {
     278        ArrayList<ExternalArgument> functionArgs = new ArrayList<ExternalArgument>();
     279
     280        for (ExternalArgument var : varsToSerialize()) {
    281281            if (!var.type().isExternalObject()) {
    282282                functionArgs.add(var);
     
    292292     */
    293293    syn ArrayList<CommonVariableDecl> FExternalStmt.varsToDeserialize() {
    294         ArrayList<CommonVariableDecl> res = new ArrayList<CommonVariableDecl>();
    295         for (CommonVariableDecl cvd : varsToSerialize())
    296             if (cvd.isOutput())
    297                 res.add(cvd);
     294        ArrayList<CommonVariableDecl> res = new ArrayList<>();
     295        for (ExternalArgument cvd : varsToSerialize()) {
     296            cvd.addVarToDeserialize(res);
     297        }
    298298        return res;
     299    }
     300   
     301    @Override
     302    public void InstComponentDecl.addVarToDeserialize(ArrayList<CommonVariableDecl> res) {
     303        if (isOutput()) {
     304            res.add(this);
     305        }
     306    }
     307   
     308    @Override
     309    public void FAbstractVariable.addVarToDeserialize(ArrayList<CommonVariableDecl> res) {
     310        if (isOutput()) {
     311            res.add(this);
     312        }
    299313    }
    300314   
     
    315329    public Map<String,FType> FExternalStmt.usedTypes() {
    316330        Map<String,FType> res = new LinkedHashMap<String,FType>();
    317         for (CommonVariableDecl cvd : varsToSerialize()) {
     331        for (ExternalArgument cvd : varsToSerialize()) {
    318332            cvd.type().usedTypes(res);
    319333        }
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CGenerator.jrag

    r11514 r11524  
    14021402            indent = p.indent(indent);
    14031403            TypePrinter_C tp = new DeclPrinter_ECE(p, str, tempMap, cgc);
    1404             for (CommonVariableDecl cvd : ext.externalObjectsToSerialize()) {
    1405                  tp.reset(cvd.name_C(), null, cvd.size(), false, indent);
     1404            for (ExternalArgument cvd : ext.externalObjectsToSerialize()) {
     1405                 tp.reset(cvd.name_C(), null, cvd.type().size(), false, indent);
    14061406                 tp.print(cvd.type());
    14071407            }
     
    14191419            indent = p.indent(indent);
    14201420            TypePrinter_C tp = new FreePrinter_ECE(p, str, tempMap, cgc);
    1421             for (CommonVariableDecl cvd : ext.externalObjectsToSerialize()) {
    1422                  tp.reset(cvd.name_C(), null, cvd.size(), false, indent);
     1421            for (ExternalArgument cvd : ext.externalObjectsToSerialize()) {
     1422                 tp.reset(cvd.name_C(), null, cvd.type().size(), false, indent);
    14231423                 tp.printExt((FExternalObjectType)cvd.type());
    14241424            }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluationStatements.jrag

    r11514 r11524  
    304304    @Override
    305305    public int FExternalStmt.evaluate(AlgorithmEvaluator evaluator) {
    306         if (!canEvaluate(evaluator) || hasUnknownArguments(evaluator.getValues())) {
    307             throw new ConstantEvaluationException(null, "Could not evaluate external function");
    308         }
    309306        return evaluateExternal(evaluator);
    310307    }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ExternalConstantEvaluation.jrag

    r10911 r11524  
    3434aspect ExternalConstantEvaluation {
    3535   
     36    public interface ExternalArgument {
     37        CValue ceval();
     38        FType type();
     39       
     40        String name_C();
     41        void addVarToDeserialize(ArrayList<CommonVariableDecl> res);
     42    }
     43   
     44    public interface CommonVariableDecl extends ExternalArgument {}
     45   
    3646    class ModelicaCompiler {}
    3747   
    38     ModelicaCompiler   implements ExternalProcessMultiCache.Compiler<CommonVariableDecl, FExternalStmt>;
    39     FExternalStmt      implements ExternalProcessMultiCache.External<CommonVariableDecl>;
    40     CommonVariableDecl implements ExternalProcessMultiCache.Variable<CValue,FType>;
     48    ModelicaCompiler   implements ExternalProcessMultiCache.Compiler<ExternalArgument, FExternalStmt>;
     49    FExternalStmt      implements ExternalProcessMultiCache.External<ExternalArgument>;
     50    ExternalArgument   extends    ExternalProcessMultiCache.Variable<CValue,FType>;
    4151    CValue             implements ExternalProcessMultiCache.Value;
    4252    FType              implements ExternalProcessMultiCache.Type<CValue>;
    4353   
    44     public class ExternalFunctionCache extends ExternalProcessMultiCache<CommonVariableDecl, CValue, FType, FExternalStmt> {
     54    public class ExternalFunctionCache extends ExternalProcessMultiCache<ExternalArgument, CValue, FType, FExternalStmt> {
    4555        public ExternalFunctionCache(ModelicaCompiler mc) {
    4656            super(mc);
     
    4959   
    5060    /**
    51      * Check if this external function can be evaluated.
    52      */
    53     syn boolean FExternalStmt.canEvaluate(AlgorithmEvaluator evaluator) {
     61     * Check if this external function can be evaluated. Throw ConstantEvaluationException otherwise
     62     */
     63    public void FExternalStmt.checkCanEvaluate(AlgorithmEvaluator evaluator, Map<ExternalArgument, CValue> values) throws ConstantEvaluationException {
    5464        if (evaluator.externalEvaluation() == 0) {
    55             return false;
     65            throw new ConstantEvaluationException(null, "Could not evaluate external function, external evaluation disabled");
    5666        }
    5767        for (FExp arg : getArgs()) {
    5868            if (!arg.type().externalValid()) {
    59                 return false;
     69                throw new ConstantEvaluationException(null, "Could not evaluate external function, invalid argument type");
    6070            }
    6171        }
    6272        if (hasReturnVar() && !getReturnVar().type().externalValid()) {
    63             return false;
    64         }
    65         return true;
    66     }
    67 
    68     syn boolean FExternalStmt.hasUnknownArguments(Map<CommonVariableDecl, CValue> values) {
    69         for (CommonVariableDecl cvd : varsToSerialize()) {
    70             if (!cvd.isOutput()) {
    71                 CValue val = values.containsKey(cvd) ? values.get(cvd) : cvd.ceval();
    72                 if (val.isPartlyUnknown()) {
    73                     return true;
     73            throw new ConstantEvaluationException(null, "Could not evaluate external function, invalid return type");
     74        }
     75        Collection<CommonVariableDecl> outputs = varsToDeserialize();
     76        for (ExternalArgument arg : values.keySet()) {
     77            if (!outputs.contains(arg)) {
     78                if (values.get(arg).isPartlyUnknown()) {
     79                    throw new ConstantEvaluationException(null, "Could not evaluate external function, unknown values in arguments");
    7480                }
    7581            }
    7682        }
    77         return false;
    7883    }
    7984
     
    8994     * one scalar external object, return null.
    9095     */
    91     syn CommonVariableDecl FExternalStmt.cachedExternalObject() {
    92         CommonVariableDecl eo = null;
    93         for (CommonVariableDecl cvd : varsToSerialize()) {
     96    syn ExternalArgument FExternalStmt.cachedExternalObject() {
     97        ExternalArgument eo = null;
     98        for (ExternalArgument cvd : varsToSerialize()) {
    9499            if (cvd.type().isExternalObject() && cvd.type().isScalar()) {
    95100                if (eo != null) {
     
    158163     * this statement refers to.
    159164     */
    160     public ExternalFunction<CommonVariableDecl, CValue> FExternalStmt.myExternalFunction() {
     165    public ExternalFunction<ExternalArgument, CValue> FExternalStmt.myExternalFunction() {
    161166        ExternalFunctionCache efc = root().getUtilInterface().getExternalFunctionCache();
    162167        if (efc == null) {
     
    172177    public int FExternalStmt.evaluateExternal(AlgorithmEvaluator evaluator) {
    173178       
    174         Map<CommonVariableDecl, CValue> values = evaluator.getValues();
     179        Map<ExternalArgument, CValue> values = new LinkedHashMap<>();
     180        for (ExternalArgument arg : varsToSerialize()) {
     181            values.put(arg, arg.ceval());
     182        }
     183       
     184        checkCanEvaluate(evaluator, values);
    175185       
    176186        if (isConstructorStmt()) {
    177             return evaluateConstructor(values);
     187            return evaluateConstructor(evaluator.getValues());
    178188        }
    179189       
    180190        int res = 0;
    181191        int timeout = evaluator.externalEvaluation();
    182         ExternalFunction<CommonVariableDecl,CValue> ef = myExternalFunction();
     192        ExternalFunction<ExternalArgument,CValue> ef = myExternalFunction();
    183193        String error = null;
    184194        try {
     
    193203        if (error != null) {
    194204            throw new ConstantEvaluationException(null, ExternalProcessCacheImpl.failedEvalMsg(getName(), error));
     205        }
     206       
     207        for (CommonVariableDecl output : varsToDeserialize()) {
     208            evaluator.getValues().put(output, values.get(output));
    195209        }
    196210       
  • trunk/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r11285 r11524  
    19671967  Could not evaluate binding expression for structural parameter 'n': 'f(a)'
    19681968    in function 'EvaluationTests.EvalNoBinding5.f'
    1969     Could not evaluate external function
     1969    Could not evaluate external function, unknown values in arguments
    19701970
    19711971Error at line 25, column 12, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
  • trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessMultiCache.java

    r11291 r11524  
    3535        public Iterable<K> functionArgsToSerialize();
    3636
    37         public Iterable<K> varsToDeserialize();
     37        public Iterable<? extends K> varsToDeserialize();
    3838    }
    3939
  • trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ProcessCommunicator.java

    r10911 r11524  
    7171     */
    7272    public void put(V val, T type) throws IOException {
    73         // mc.log().debug("ProcessCommunicator WRITE: " + val.toString() + " of type:
    74         // "+type.toString());
     73//        mc.log().debug("ProcessCommunicator WRITE: " + val.toString() + " of type:" + type.toString());
    7574        val.serialize(out);
    7675        out.flush();
     
    8281    public V get(T type) throws IOException {
    8382        V val = type.deserialize(this);
    84         // mc.log().debug("ProcessCommunicator READ: " + val.toString());
     83//        mc.log().debug("ProcessCommunicator READ: " + val.toString());
    8584        return val;
    8685    }
Note: See TracChangeset for help on using the changeset viewer.