Fix for broken deadline propagation mechanism

org.lflang/src/org/lflang/generator/GeneratorBase.java

@@ -198,6 +198,12 @@ public abstract class GeneratorBase extends AbstractLFValidator {
      */
     public boolean hasModalReactors = false;
 
+    /**
+     * Indicates whether the program has any deadlines and thus
+     * needs to propagate deadlines through the reaction instance graph
+     */
+    public boolean hasDeadlines = false;
+
     // //////////////////////////////////////////
     // // Target properties, if they are included.
     /**

org.lflang/src/org/lflang/generator/GeneratorUtils.java

@@ -36,6 +36,7 @@
 import org.lflang.lf.KeyValuePair;
 import org.lflang.lf.KeyValuePairs;
 import org.lflang.lf.Model;
+import org.lflang.lf.Reaction;
 import org.lflang.lf.Reactor;
 import org.lflang.lf.TargetDecl;
 import org.lflang.util.FileUtil;

org.lflang/src/org/lflang/generator/ReactionInstance.java

@@ -351,6 +351,7 @@ public Set<ReactionInstance> dependsOnReactions() {
     public Set<Integer> getLevels() {
         Set<Integer> result = new LinkedHashSet<>();
         // Force calculation of levels if it has not been done.
+        // FIXME: Is it necessary to repeat this everywhere?
         parent.assignLevels();
         for (Runtime runtime : runtimeInstances) {
             result.add(runtime.level);

org.lflang/src/org/lflang/generator/ReactionInstanceGraph.java

@@ -92,14 +92,13 @@ public void rebuild() {
             // Do not throw an exception so that cycle visualization can proceed.
             // throw new InvalidSourceException("Reactions form a cycle!");
         }
-        // FIXME: Is it OK to also assign deadlines here?
-        // Also do the traversal in the opposite order to calculate the deadlines
+    }
+
+    public void rebuildAndAssignDeadlines() {
         this.clear();
         addNodesAndEdges(main);
-        // Assign a level to each reaction. 
-        // If there are cycles present in the graph, it will be detected here.
         assignInferredDeadlines();
-
+        this.clear();
     }
 
     /*

org.lflang/src/org/lflang/generator/ReactorInstance.java

@@ -190,6 +190,23 @@ public ReactionInstanceGraph assignLevels() {
         }
         return cachedReactionLoopGraph;
     }
+
+    /**
+     * This function assigns/propagates deadlines through the Reaction Instance Graph
+     * it performs Kahn`s algorithm in reverse, starting from the leaf nodes and
+     * propagates deadlines upstream. To reduce cost, it should only be invoked when
+     * there are user-specified deadlines in the program
+     * @return
+     */
+    public ReactionInstanceGraph assignDeadlines() {
+        if (depth != 0) return root().assignDeadlines();
+        if (cachedReactionLoopGraph == null) {
+            cachedReactionLoopGraph = new ReactionInstanceGraph(this);
+        }
+        cachedReactionLoopGraph.rebuildAndAssignDeadlines();
+        return cachedReactionLoopGraph;
+
+    }
 
     /** 
      * Return the instance of a child rector created by the specified

org.lflang/src/org/lflang/generator/c/CGenerator.java

@@ -2571,6 +2571,9 @@ private void createMainReactorInstance() {
                     errorReporter.reportError("Main reactor has causality cycles. Skipping code generation.");
                     return;
                 }
+                if (hasDeadlines) {
+                    this.main.assignDeadlines();
+                }
                 // Inform the run-time of the breadth/parallelism of the reaction graph
                 var breadth = reactionInstanceGraph.getBreadth();
                 if (breadth == 0) {

org.lflang/src/org/lflang/generator/c/CTriggerObjectsGenerator.java

@@ -343,30 +343,42 @@ private static boolean setReactionPriorities(
     ) {
         var foundOne = false;
         // Force calculation of levels if it has not been done.
+        // FIXME: Why is this repeated all over? Are there scenarios where we haven't assigned levels yet?
         reactor.assignLevels();
 
-        // If any reaction has multiple levels, because it is in a bank of reactors
-        // then we need to create an array with the levels and deadlines here
+        // We handle four different scenarios
+        //  1) A reactionInstance has 1 level and 1 deadline
+        //  2) A reactionInstance has 1 level but multiple deadlines
+        //  3) A reaction instance has multiple levels but all have the same deadline
+        //  4) Multple deadlines and levels
+
         var prolog = new CodeBuilder();
         var epilog = new CodeBuilder();
         for (ReactionInstance r : reactor.reactions) {
             if (currentFederate.contains(r.getDefinition())) {
                 var levelSet = r.getLevels();
                 var deadlineSet = r.getInferredDeadlines();
 
-                if (levelSet.size() != 1 || deadlineSet.size() != 1) {
+                if (levelSet.size() > 1 || deadlineSet.size() > 1) {
+                    // Scenario 2-4
                     if (prolog.length() == 0) {
                         prolog.startScopedBlock();
                         epilog.endScopedBlock();
                     }
-                    // Get inferredDeadlines and map to string representations
+                }
+                if (deadlineSet.size() > 1) {
+                    // Scenario (2) or (4)
                     var deadlines = r.getInferredDeadlinesList().stream()
                         .map(elt -> ("0x" + Long.toString(elt.toNanoSeconds(), 16) + "LL"))
                         .collect(Collectors.toList());
 
+                    prolog.pr("interval_t "+r.uniqueID()+"_inferred_deadlines[] = { "+joinObjects(deadlines, ", ")+" };");
+                }
+
+                if (levelSet.size() > 1) {
+                    // Scenario (3) or (4)
                     // Cannot use the above set of levels because it is a set, not a list.
                     prolog.pr("int "+r.uniqueID()+"_levels[] = { "+joinObjects(r.getLevelsList(), ", ")+" };");
-                    prolog.pr("interval_t "+r.uniqueID()+"_inferred_deadlines[] = { "+joinObjects(deadlines, ", ")+" };");
                 }
             }
         }
@@ -382,16 +394,15 @@ private static boolean setReactionPriorities(
                 // reaction have the same level and deadline
                 var levelSet = r.getLevels();
                 var deadlineSet = r.getInferredDeadlines();
-                if (levelSet.size() == 1 && deadlineSet.size() == 1) {
-                    var level = -1;
-                    for (Integer l : levelSet) {
-                        level = l;
-                    }
 
-                    var inferredDeadline = TimeValue.MAX_VALUE;
-                    for (TimeValue t : deadlineSet) {
-                        inferredDeadline = t;
-                    }
+                // Get the head of the associated lists. To avoid duplication in
+                //  several of the following cases
+                var level = r.getLevelsList().get(0);
+                var inferredDeadline = r.getInferredDeadlinesList().get(0);
+                var runtimeIdx =CUtil.runtimeIndex(r.getParent());
+
+                if (levelSet.size() == 1 && deadlineSet.size() == 1) {
+                    // Scenario (1)
 
                     // xtend doesn't support bitwise operators...
                     var indexValue = inferredDeadline.toNanoSeconds() << 16 | level;
@@ -404,11 +415,28 @@ private static boolean setReactionPriorities(
                         "// deadline "+ inferredDeadline.toNanoSeconds()+" shifted left 16 bits.",
                         CUtil.reactionRef(r)+".index = "+reactionIndex+";"
                     ));
-                } else {
-                    // The general case where the different reactions in the bank
-                    //  have different level or deadline and thus need its own index
-                    var runtimeIdx =CUtil.runtimeIndex(r.getParent());
+                } else if (levelSet.size() == 1 && deadlineSet.size() > 1) {
+                    // Scenario 2
+                    temp.pr(String.join("\n",
+                        CUtil.reactionRef(r)+".chain_id = "+r.chainID+";",
+                        "// index is the OR of levels["+runtimeIdx+"] and ",
+                        "// deadlines["+runtimeIdx+"] shifted left 16 bits.",
+                        CUtil.reactionRef(r)+".index = ("+r.uniqueID()+"_inferred_deadlines["+runtimeIdx+"] << 16) | " +
+                            level+";"
+                    ));
+
+                } else if (levelSet.size() > 1 && deadlineSet.size() == 1) {
+                    // Scenarion (3)
+                    temp.pr(String.join("\n",
+                        CUtil.reactionRef(r)+".chain_id = "+r.chainID+";",
+                        "// index is the OR of levels["+runtimeIdx+"] and ",
+                        "// deadlines["+runtimeIdx+"] shifted left 16 bits.",
+                        CUtil.reactionRef(r)+".index = ("+inferredDeadline.toNanoSeconds()+" << 16) | " +
+                            r.uniqueID()+"_levels["+runtimeIdx+"];"
+                    ));
 
+                } else if (levelSet.size() > 1 && deadlineSet.size() > 1) {
+                    // Scenario (4)
                     temp.pr(String.join("\n",
                         CUtil.reactionRef(r)+".chain_id = "+r.chainID+";",
                         "// index is the OR of levels["+runtimeIdx+"] and ",