Use of delayed and physical connections as provided by the C++ runtime

org.lflang/src/lib/cpp/lfutil.hh

@@ -101,4 +101,42 @@ void bind_multiple_ports(
   }
 }
 
+template<class T>
+void bind_multiple_connections_with_ports(
+    std::vector<reactor::Connection<T>*>& connections,
+    std::vector<reactor::Port<T>*>& ports,
+    bool repeat_left) {
+
+  if (repeat_left) {
+    size_t l_size = connections.size();
+    size_t r_size = ports.size();
+    // divide and round up
+    size_t repetitions = r_size / l_size + (r_size % l_size != 0);
+    // repeat repetitions-1 times
+    connections.reserve(repetitions * l_size);
+    for (size_t i = 1; i < repetitions; i++) {
+      std::copy_n(connections.begin(), l_size, std::back_inserter(connections));
+    }
+  }
+
+  auto left_it = connections.begin();
+  auto right_it = ports.begin();
+
+  if (connections.size() < ports.size()) {
+    reactor::log::Warn() << "There are more right ports than left ports. "
+                         << "Not all ports will be connected!";
+  } else if (connections.size() > ports.size()) {
+    reactor::log::Warn() << "There are more left ports than right ports. "
+                         << "Not all ports will be connected!";
+  }
+
+  while (left_it != connections.end() && right_it != ports.end()) {
+    auto left = *left_it;
+    auto right = *right_it;
+    left->bind_downstream_port(right);
+    left_it++;
+    right_it++;
+  }
+}
+
 }

org.lflang/src/org/lflang/generator/cpp/CppAssembleMethodGenerator.kt

@@ -24,11 +24,11 @@
 
 package org.lflang.generator.cpp
 
+import org.lflang.*
 import org.lflang.generator.PrependOperator
-import org.lflang.hasMultipleConnections
-import org.lflang.isBank
-import org.lflang.isMultiport
-import org.lflang.joinWithLn
+import org.lflang.generator.cpp.CppConnectionGenerator.Companion.name
+import org.lflang.generator.cpp.CppConnectionGenerator.Companion.requiresConnectionClass
+import org.lflang.generator.cpp.CppPortGenerator.Companion.dataType
 import org.lflang.lf.Action
 import org.lflang.lf.Connection
 import org.lflang.lf.ParameterReference
@@ -143,22 +143,25 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) {
         }
     }
 
-    private fun declareConnection(c: Connection, idx: Int): String {
-        return if (c.hasMultipleConnections) {
+    private fun declareConnection(c: Connection, idx: Int): String =
+        if (c.hasMultipleConnections) {
             declareMultiportConnection(c, idx)
         } else {
             val leftPort = c.leftPorts[0]
             val rightPort = c.rightPorts[0]
 
-            """
+            if (c.requiresConnectionClass)
+                """
+                    // connection $idx
+                    ${c.name}.bind_upstream_port(&${leftPort.name});
+                    ${c.name}.bind_downstream_port(&${rightPort.name});
+                """.trimIndent()
+            else
+                """
                     // connection $idx
                     ${leftPort.name}.bind_to(&${rightPort.name});
                 """.trimIndent()
         }
-    }
-
-    private val VarRef.isMultiport get() = (variable as? Port)?.isMultiport == true
-    private val VarRef.isInBank get() = container?.isBank == true
 
     /**
      * Return the C++ type of a port.
@@ -167,30 +170,49 @@ class CppAssembleMethodGenerator(private val reactor: Reactor) {
      * complex logic for finding the actual type, we return a decltype statement and let the C++ compiler do the job.
      */
     private val VarRef.portType: String
-        get() = when {
-            isInBank && isMultiport  -> "reactor::Port<std::remove_reference<decltype(${container.name}[0]->${variable.name}[0])>::type::value_type>*"
-            isInBank && !isMultiport -> "reactor::Port<std::remove_reference<decltype(${container.name}[0]->${variable.name})>::type::value_type>*"
-            !isInBank && isMultiport -> "reactor::Port<std::remove_reference<decltype($name[0])>::type::value_type>*"
-            else                     -> "reactor::Port<std::remove_reference<decltype($name)>::type::value_type>*"
-        }
+        get() = "reactor::Port<${dataType}>*"
 
     private fun declareMultiportConnection(c: Connection, idx: Int): String {
         // It should be safe to assume that all ports have the same type. Thus we just pick the
         // first left port to determine the type of the entire connection
         val portType = c.leftPorts[0].portType
 
+        // TODO this does not work with generics
+        val leftPort = c.leftPorts[0].variable as Port
+        val dataType = leftPort.inferredType.cppType
+
         // Generate code which adds all left hand ports and all right hand ports to a vector each. If we are handling multiports
         // within a bank, then we normally iterate over all banks in an outer loop and over all ports in an inner loop. However,
         // if the connection is a cross connection, than we change the order on the right side and iterate over ports before banks.
         return with(PrependOperator) {
-            """
-                |// connection $idx
-                |std::vector<$portType> __lf_left_ports_$idx;
-            ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }}
-                |std::vector<$portType> __lf_right_ports_$idx;
-            ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }}
-                |lfutil::bind_multiple_ports(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated});
-            """.trimMargin()
+            if (!c.requiresConnectionClass) {
+                """
+                    |// connection $idx
+                    |std::vector<$portType> __lf_left_ports_$idx;
+                ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }}
+                    |std::vector<$portType> __lf_right_ports_$idx;
+                ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }}
+                    |lfutil::bind_multiple_ports(__lf_left_ports_$idx, __lf_right_ports_$idx, ${c.isIterated});
+                """.trimMargin()
+            } else {
+                """
+                    |// connection $idx
+                    |std::vector<$portType> __lf_left_ports_$idx;
+                ${" |"..c.leftPorts.joinWithLn { addAllPortsToVector(it, "__lf_left_ports_$idx") }}
+                    |${c.name}.reserve(__lf_left_ports_$idx.size());
+                    |for(size_t __lf_idx{0}; __lf_idx < __lf_left_ports_$idx.size(); __lf_idx++) {
+                    |  ${c.name}.emplace_back("${c.name}" + std::to_string(__lf_idx), this, ${c.delay.toCppTime()});
+                    |  ${c.name}.back().bind_upstream_port(__lf_left_ports_$idx[__lf_idx]);
+                    |}
+                    |std::vector<reactor::Connection<$dataType>*> __lf_connection_pointers_$idx;
+                    |for (auto& connection : ${c.name}) {
+                    |  __lf_connection_pointers_$idx.push_back(&connection);
+                    |}
+                    |std::vector<$portType> __lf_right_ports_$idx;
+                ${" |"..c.rightPorts.joinWithLn { addAllPortsToVector(it, "__lf_right_ports_$idx") }}
+                    |lfutil::bind_multiple_connections_with_ports(__lf_connection_pointers_$idx, __lf_right_ports_$idx, ${c.isIterated});
+                """.trimMargin()
+            }
         }
     }
 

org.lflang/src/org/lflang/generator/cpp/CppConnectionGenerator.kt

@@ -0,0 +1,59 @@
+package org.lflang.generator.cpp
+
+import org.lflang.*
+import org.lflang.generator.cpp.CppConnectionGenerator.Companion.cppType
+import org.lflang.generator.cpp.CppPortGenerator.Companion.dataType
+import org.lflang.lf.Connection
+import org.lflang.lf.Port
+import org.lflang.lf.Reactor
+import org.lflang.lf.VarRef
+
+class CppConnectionGenerator(private val reactor: Reactor) {
+
+    companion object {
+        val Connection.name: String
+            get() =
+                "connection_" + leftPorts.joinToString("__") {
+                    if (it.container == null) {
+                        it.variable.name
+                    } else {
+                        it.container.name + "_" + it.variable.name
+                    }
+                }
+
+        val Connection.cppType: String
+            get() {
+                val leftPort = leftPorts.first()
+                return when {
+                    isPhysical    -> "reactor::PhysicalConnection<${leftPort.dataType}>"
+                    delay != null -> "reactor::DelayedConnection<${leftPort.dataType}>"
+                    else          -> throw IllegalArgumentException("Connection is neither physical nor delayed")
+                }
+            }
+
+        val Connection.requiresConnectionClass: Boolean get() = isPhysical || delay != null
+    }
+
+    fun generateDeclarations() =
+        reactor.connections.mapNotNull { generateDecleration(it) }
+            .joinToString("\n", "// connections \n", postfix = "\n")
+
+    fun generateInitializers() =
+        reactor.connections.mapNotNull { generateConstructorInitializer(it) }.joinLn()
+
+    private fun generateDecleration(connection: Connection): String? =
+        if (connection.requiresConnectionClass) {
+            if (connection.hasMultipleConnections) {
+                "std::vector<${connection.cppType}> ${connection.name};"
+            } else {
+                "${connection.cppType} ${connection.name};"
+            }
+        } else null
+
+    private fun generateConstructorInitializer(connection: Connection): String? =
+        if (connection.requiresConnectionClass && !connection.hasMultipleConnections) {
+            val delay = connection.delay.toCppTime()
+            val name = connection.name
+            """, $name{"$name", this, $delay}"""
+        } else null
+}

org.lflang/src/org/lflang/generator/cpp/CppExtensions.kt

@@ -73,8 +73,8 @@ fun Expression.toCppCode(inferredType: InferredType? = null): String =
  * @param outerContext A flag indicating whether to generate code for the scope of the outer reactor class.
  *                    This should be set to false if called from code generators for the inner class.
  */
-fun Expression.toCppTime(): String =
-    this.toCppCode(inferredType = InferredType.time())
+fun Expression?.toCppTime(): String =
+    this?.toCppCode(inferredType = InferredType.time()) ?: "reactor::Duration::zero()"
 
 /** Get the textual representation of a width in C++ code */
 fun WidthSpec.toCppCode(): String = terms.joinToString(" + ") {

org.lflang/src/org/lflang/generator/cpp/CppGenerator.kt

@@ -29,7 +29,6 @@ package org.lflang.generator.cpp
 import org.eclipse.emf.ecore.resource.Resource
 import org.lflang.ErrorReporter
 import org.lflang.Target
-import org.lflang.ast.AfterDelayTransformation
 import org.lflang.generator.CodeMap
 import org.lflang.generator.GeneratorBase
 import org.lflang.generator.GeneratorResult
@@ -67,8 +66,6 @@ class CppGenerator(
     }
 
     override fun doGenerate(resource: Resource, context: LFGeneratorContext) {
-        // Register the after delay transformation to be applied by GeneratorBase.
-        registerTransformation(AfterDelayTransformation(CppDelayBodyGenerator, CppTypes, resource))
         super.doGenerate(resource, context)
 
         if (!canGenerate(errorsOccurred(), mainDef, errorReporter, context)) return

org.lflang/src/org/lflang/generator/cpp/CppPortGenerator.kt

@@ -25,15 +25,33 @@
 package org.lflang.generator.cpp
 
 import org.lflang.inferredType
+import org.lflang.isBank
 import org.lflang.isMultiport
 import org.lflang.joinWithLn
-import org.lflang.lf.Input
-import org.lflang.lf.Output
-import org.lflang.lf.Port
-import org.lflang.lf.Reactor
+import org.lflang.lf.*
 
 class CppPortGenerator(private val reactor: Reactor) {
 
+    companion object {
+        private val VarRef.isMultiport get() = (variable as? Port)?.isMultiport == true
+        private val VarRef.isInBank get() = container?.isBank == true
+
+        /**
+         * Return the C++ type of a port reference.
+         *
+         * We cannot easily infer this type directly, because it might be used within a generic reactor but the reference is
+         * likely used outside of it. Instead of implementing complex logic for finding the actual type, we return a decltype
+         * statement and let the C++ compiler do the job.
+         */
+        val VarRef.dataType: String
+            get() = when {
+                isInBank && isMultiport  -> "std::remove_reference<decltype(${container.name}[0]->${variable.name}[0])>::type::value_type"
+                isInBank && !isMultiport -> "std::remove_reference<decltype(${container.name}[0]->${variable.name})>::type::value_type"
+                !isInBank && isMultiport -> "std::remove_reference<decltype($name[0])>::type::value_type"
+                else                     -> "std::remove_reference<decltype($name)>::type::value_type"
+            }
+    }
+
     private fun generateDeclaration(port: Port): String = with(port) {
         return if (isMultiport) {
             //val initializerLists = (0 until getValidWidth()).joinToString(", ") { """{"${name}_$it", this}""" }
@@ -84,7 +102,7 @@ class CppPortGenerator(private val reactor: Reactor) {
             ${name}.reserve($width);
             for (size_t __lf_idx = 0; __lf_idx < $width; __lf_idx++) {
               std::string __lf_port_name = "${name}_" + std::to_string(__lf_idx);
-              ${name}.emplace_back(__lf_port_name, this, (reactor::BaseMultiport*)&${name}, __lf_idx);
+              ${name}.emplace_back(__lf_port_name, this);
             }
         """.trimIndent()
     }

org.lflang/src/org/lflang/generator/cpp/CppReactorGenerator.kt

@@ -25,8 +25,6 @@ package org.lflang.generator.cpp
 
 import org.lflang.ErrorReporter
 import org.lflang.generator.PrependOperator
-import org.lflang.generator.cpp.CppParameterGenerator.Companion.targetType
-import org.lflang.generator.cpp.CppParameterGenerator.Companion.typeAlias
 import org.lflang.isGeneric
 import org.lflang.lf.Reactor
 import org.lflang.toText
@@ -58,6 +56,7 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi
     private val ports = CppPortGenerator(reactor)
     private val reactions = CppReactionGenerator(reactor, ports, instances)
     private val assemble = CppAssembleMethodGenerator(reactor)
+    private val connections = CppConnectionGenerator(reactor)
 
     private fun publicPreamble() =
         reactor.preambles.filter { it.isPublic }
@@ -113,6 +112,7 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi
         ${" |  "..instances.generateDeclarations()}
         ${" |  "..timers.generateDeclarations()}
         ${" |  "..actions.generateDeclarations()}
+        ${" |  "..connections.generateDeclarations()}
         ${" |  "..reactions.generateReactionViews()}
         ${" |  "..reactions.generateDeclarations()}
             |
@@ -184,6 +184,7 @@ class CppReactorGenerator(private val reactor: Reactor, fileConfig: CppFileConfi
             ${" |  "..instances.generateInitializers()}
             ${" |  "..timers.generateInitializers()}
             ${" |  "..actions.generateInitializers()}
+            ${" |  "..connections.generateInitializers()}
             ${" |  "..reactions.generateReactionViewInitializers()}
                 |{
             ${" |  "..ports.generateConstructorInitializers()}

test/C/src/PhysicalConnection.lf

@@ -11,7 +11,7 @@ reactor Destination {
     input in: int
 
     reaction(in) {=
-        interval_t time = lf_time_physical_elapsed();
+        interval_t time = lf_time_logical_elapsed();
         printf("Received %d at logical time %lld.\n", in->value, time);
         if (time <= 0LL) {
             fprintf(stderr, "ERROR: Logical time should have been greater than zero.\n");