Multiport iterator for more efficient access to sparse inputs

org.lflang/src/org/lflang/ASTUtils.java

@@ -62,7 +62,6 @@
 import org.lflang.lf.Action;
 import org.lflang.lf.ActionOrigin;
 import org.lflang.lf.Assignment;
-import org.lflang.lf.Attribute;
 import org.lflang.lf.Code;
 import org.lflang.lf.Connection;
 import org.lflang.lf.Element;

org.lflang/src/org/lflang/AttributeUtils.java

@@ -86,7 +86,20 @@ public static String findLabelAttribute(EObject node) {
                     .map(it -> it.getAttrParms().get(0).getValue().getStr())
                     .findFirst()
                     .orElse(null);
-
+    }
+
+    /**
+     * Return true if the specified node is an Input and has an {@code @sparse}
+     * attribute.
+     * @param node An AST node.
+     */
+    public static boolean isSparse(EObject node) {
+        if (node instanceof Input) {
+            for (var attribute : getAttributes(node)) {
+                if (attribute.getAttrName().equals("sparse")) return true;
+            }
+        }
+        return false;
     }
 
     /**

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

@@ -61,6 +61,8 @@ private static List<String> getBaseCoreFiles() {
             "tag.c",
             "trace.h",
             "trace.c",
+            "port.h",
+            "port.c",
             "utils/pqueue.c",
             "utils/pqueue.h",
             "utils/pqueue_support.h",

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

@@ -2224,6 +2224,7 @@ protected void setUpGeneralParameters() {
         targetConfig.compileDefinitions.put("LOG_LEVEL", targetConfig.logLevel.ordinal() + "");
         targetConfig.compileAdditionalSources.addAll(CCoreFilesUtils.getCTargetSrc());
         targetConfig.compileAdditionalSources.add("core" + File.separator + "mixed_radix.c");
+        targetConfig.compileAdditionalSources.add("core" + File.separator + "port.c");
         setCSpecificDefaults();
         // Create the main reactor instance if there is a main reactor.
         createMainReactorInstance();

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

@@ -1,6 +1,7 @@
 package org.lflang.generator.c;
 
 import org.lflang.ASTUtils;
+import org.lflang.AttributeUtils;
 import org.lflang.ErrorReporter;
 import org.lflang.Target;
 import org.lflang.generator.CodeBuilder;
@@ -62,9 +63,16 @@ public static String generateAuxiliaryStruct(
         var code = new CodeBuilder();
         code.pr("typedef struct {");
         code.indent();
+        // NOTE: The following fields are required to be the first ones so that
+        // pointer to this struct can be cast to a (lf_port_base_t*) to access
+        // these fields for any port.
+        code.pr(String.join("\n",
+                "bool is_present;",
+                "lf_sparse_io_record_t* sparse_record;",
+                "int destination_channel;"
+        ));
         code.pr(valueDeclaration(port, target, errorReporter, types));
         code.pr(String.join("\n",
-                    "bool is_present;",
                     "int num_destinations;",
                     "lf_token_t* token;",
                     "int length;",
@@ -88,22 +96,39 @@ public static String initializeInputMultiport(
     ) {
         var portRefName = CUtil.portRefName(input);
         // If the port is a multiport, create an array.
-        return input.isMultiport() ?
-                String.join("\n",
-                    portRefName+"_width = "+input.getWidth()+";",
-                    "// Allocate memory for multiport inputs.",
-                    portRefName+" = ("+variableStructType(input)+"**)_lf_allocate(",
-                    "        "+input.getWidth()+", sizeof("+variableStructType(input)+"*),",
-                    "        &"+reactorSelfStruct+"->base.allocations); ",
-                    "// Set inputs by default to an always absent default input.",
-                    "for (int i = 0; i < "+input.getWidth()+"; i++) {",
-                    "    "+portRefName+"[i] = &"+reactorSelfStruct+"->_lf_default__"+input.getName()+";",
+        if (input.isMultiport()) {
+            String result = String.join("\n",
+                portRefName+"_width = "+input.getWidth()+";",
+                "// Allocate memory for multiport inputs.",
+                portRefName+" = ("+variableStructType(input)+"**)_lf_allocate(",
+                "        "+input.getWidth()+", sizeof("+variableStructType(input)+"*),",
+                "        &"+reactorSelfStruct+"->base.allocations); ",
+                "// Set inputs by default to an always absent default input.",
+                "for (int i = 0; i < "+input.getWidth()+"; i++) {",
+                "    "+portRefName+"[i] = &"+reactorSelfStruct+"->_lf_default__"+input.getName()+";",
+                "}"
+            );
+            if (AttributeUtils.isSparse(input.getDefinition())) {
+                return String.join("\n", result,
+                    "if ("+input.getWidth()+" >= LF_SPARSE_WIDTH_THRESHOLD) {",
+                    "    "+portRefName+"__sparse = _lf_allocate(1,",
+                    "            sizeof(lf_sparse_io_record_t) + sizeof(size_t) * "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER,",
+                    "            &"+reactorSelfStruct+"->base.allocations);",
+                    "    "+portRefName+"__sparse->capacity = "+input.getWidth()+"/LF_SPARSE_CAPACITY_DIVIDER;",
+                    "    if (_lf_sparse_io_record_sizes.start == NULL) {",
+                    "        _lf_sparse_io_record_sizes = vector_new(1);",
+                    "    }",
+                    "    vector_push(&_lf_sparse_io_record_sizes, (void*)&"+portRefName+"__sparse->size);",
                     "}"
-                ) :
-                String.join("\n",
-                    "// width of -2 indicates that it is not a multiport.",
-                    portRefName+"_width = -2;"
                 );
+            }
+            return result;
+        } else {
+            return String.join("\n",
+                "// width of -2 indicates that it is not a multiport.",
+                portRefName+"_width = -2;"
+            );
+        }
     }
 
     /**
@@ -220,7 +245,9 @@ private static void generateInputDeclarations(
                     variableStructType(input, decl)+"** _lf_"+inputName+";",
                     "int _lf_"+inputName+"_width;",
                     "// Default input (in case it does not get connected)",
-                    variableStructType(input, decl)+" _lf_default__"+inputName+";"
+                    variableStructType(input, decl)+" _lf_default__"+inputName+";",
+                    "// Struct to support efficiently reading sparse inputs.",
+                    "lf_sparse_io_record_t* _lf_"+inputName+"__sparse;"
                 ));
             } else {
                 // input is not a multiport.

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

@@ -52,6 +52,7 @@ public static String generateIncludeStatements(
             code.pr("#include \"core/trace.c\"");
         }
         code.pr("#include \"core/mixed_radix.h\"");
+        code.pr("#include \"core/port.h\"");
         return code.toString();
     }
 

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

@@ -15,6 +15,7 @@
 import java.util.stream.Collectors;
 
 import org.lflang.ASTUtils;
+import org.lflang.AttributeUtils;
 import org.lflang.TargetConfig;
 import org.lflang.TargetProperty.CoordinationType;
 import org.lflang.TargetProperty.LogLevel;
@@ -483,8 +484,12 @@ private static String connectPortToEventualDestinations(
                         // An output port of a contained reactor is triggering a reaction.
                         code.pr(CUtil.portRefNested(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";");
                     } else {
-                        // An output port is triggering
+                        // An output port is triggering an input port.
                         code.pr(CUtil.portRef(dst, dr, db, dc)+" = ("+destStructType+"*)&"+CUtil.portRef(src, sr, sb, sc)+";");
+                        if (AttributeUtils.isSparse(dst.getDefinition())) {
+                            code.pr(CUtil.portRef(dst, dr, db, dc)+"->sparse_record = "+CUtil.portRefName(dst, dr, db, dc)+"__sparse;");
+                            code.pr(CUtil.portRef(dst, dr, db, dc)+"->destination_channel = "+dc+";");
+                        }
                     }
                     code.endScopedRangeBlock(srcRange, dstRange, isFederated);
                 }

org.lflang/src/org/lflang/generator/python/PythonGenerator.java

@@ -124,10 +124,16 @@ private PythonGenerator(FileConfig fileConfig, ErrorReporter errorReporter, Pyth
      * statically allocated arrays in Lingua Franca.
      * This template is defined as
      *   typedef struct {
-     *       PyObject* value;
      *       bool is_present;
+     *       lf_sparse_io_record_t* sparse_record; // NULL if there is no sparse record.
+     *       int destination_channel;              // -1 if there is no destination.
+     *       PyObject* value;
      *       int num_destinations;
-     *       FEDERATED_CAPSULE_EXTENSION
+     *       lf_token_t* token;
+     *       int length;
+     *       void (*destructor) (void* value);
+     *       void* (*copy_constructor) (void* value);
+     *       FEDERATED_GENERIC_EXTENSION
      *   } generic_port_instance_struct;
      *
      * @see reactor-c-py/lib/pythontarget.h

org.lflang/src/org/lflang/validation/AttributeSpec.java

@@ -1,5 +1,5 @@
 /*************
- * Copyright (c) 2019-2020, The University of California at Berkeley.
+ * Copyright (c) 2019-2022, The University of California at Berkeley.
 
  * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
@@ -37,7 +37,7 @@
 import org.lflang.lf.LfPackage.Literals;
 
 /**
- * Specification of the structure of an annotation.
+ * Specification of the structure of an attribute annotation.
  * 
  * @author{Clément Fournier, TU Dresden, INSA Rennes}
  * @author{Shaokai Lin <shaokai@berkeley.edu>}
@@ -52,7 +52,11 @@ class AttributeSpec {
     public static final Map<String, AttributeSpec> ATTRIBUTE_SPECS_BY_NAME = new HashMap<>();
 
     public AttributeSpec(List<AttrParamSpec> params) {
-        paramSpecByName = params.stream().collect(Collectors.toMap(it -> it.name, it -> it));
+        if (params != null) {
+            paramSpecByName = params.stream().collect(Collectors.toMap(it -> it.name, it -> it));
+        } else {
+            paramSpecByName = null;
+        }
     }
 
     /**
@@ -61,11 +65,17 @@ public AttributeSpec(List<AttrParamSpec> params) {
      */
     public void check(LFValidator validator, Attribute attr) {
         Set<String> seen;
-        // Check to see if there is one or multiple parameters.
-        if (attr.getAttrParms().size() == 1 && attr.getAttrParms().get(0).getName() == null) {
+        // If there is just one parameter, it is required to be named "value".
+        if (attr.getAttrParms() != null
+                && attr.getAttrParms().size() == 1
+                && attr.getAttrParms().get(0).getName() == null) {
             // If we are in this branch,
             // then the user has provided @attr("value"),
             // which is a shorthand for @attr(value="value").
+            if (paramSpecByName == null) {
+                validator.error("Attribute doesn't take a parameter.", Literals.ATTRIBUTE__ATTR_NAME);
+                return;
+            }
             AttrParamSpec valueSpec = paramSpecByName.get(VALUE_ATTR);
             if (valueSpec == null) {
                 validator.error("Attribute doesn't have a 'value' parameter.", Literals.ATTR_PARM__NAME);
@@ -75,47 +85,55 @@ public void check(LFValidator validator, Attribute attr) {
             valueSpec.check(validator, attr.getAttrParms().get(0));
             seen = Set.of(VALUE_ATTR);
         } else {
-            // Process multiple attributes, each of which has to be named.
+            // Process multiple parameters, each of which has to be named.
             seen = processNamedAttrParms(validator, attr);
         }
 
         // Check if there are any missing parameters required by this attribute.
-        Map<String, AttrParamSpec> missingParams = new HashMap<>(paramSpecByName);
-        missingParams.keySet().removeAll(seen);
-        missingParams.forEach((name, paramSpec) -> {
-            if (!paramSpec.isOptional()) {
-                validator.error("Missing required attribute parameter '" + name + "'.", Literals.ATTRIBUTE__ATTR_PARMS);
-            }
-        });
+        if (paramSpecByName != null) {
+            Map<String, AttrParamSpec> missingParams = new HashMap<>(paramSpecByName);
+            missingParams.keySet().removeAll(seen);
+            missingParams.forEach((name, paramSpec) -> {
+                if (!paramSpec.isOptional()) {
+                    validator.error("Missing required attribute parameter '" + name + "'.", Literals.ATTRIBUTE__ATTR_PARMS);
+                }
+            });
+        }
     }
 
     /**
-     * Check if the attribute parameters are named, whether
+     * Check whether the attribute parameters are named, whether
      * these names are known, and whether the named parameters
      * conform to the param spec (whether the param has the
      * right type, etc.).
      * 
-     * @param validator The current validator in use
-     * @param attr The attribute being checked
-     * @return A set of named attribute parameters the user provides
+     * @param validator The current validator in use.
+     * @param attr The attribute being checked.
+     * @return A set of named attribute parameters the user provides.
      */
     private Set<String> processNamedAttrParms(LFValidator validator, Attribute attr) {
         Set<String> seen = new HashSet<>();
-        for (AttrParm parm : attr.getAttrParms()) {
-            if (parm.getName() == null) {
-                validator.error("Missing name for attribute parameter.", Literals.ATTRIBUTE__ATTR_NAME);
-                continue;
-            }
-
-            AttrParamSpec parmSpec = paramSpecByName.get(parm.getName());
-            if (parmSpec == null) {
-                validator.error("\"" + parm.getName() + "\"" + " is an unknown attribute parameter.",
-                                Literals.ATTRIBUTE__ATTR_NAME);
-                continue;
+        if (attr.getAttrParms() != null) {
+            for (AttrParm parm : attr.getAttrParms()) {
+                if (paramSpecByName == null) {
+                    validator.error("Attribute does not take parameters.", Literals.ATTRIBUTE__ATTR_NAME);
+                    break;
+                }
+                if (parm.getName() == null) {
+                    validator.error("Missing name for attribute parameter.", Literals.ATTRIBUTE__ATTR_NAME);
+                    continue;
+                }
+
+                AttrParamSpec parmSpec = paramSpecByName.get(parm.getName());
+                if (parmSpec == null) {
+                    validator.error("\"" + parm.getName() + "\"" + " is an unknown attribute parameter.",
+                                    Literals.ATTRIBUTE__ATTR_NAME);
+                    continue;
+                }
+                // Check whether a parameter conforms to its spec.
+                parmSpec.check(validator, parm);
+                seen.add(parm.getName());
             }
-            // Check whether a parameter conforms to its spec.
-            parmSpec.check(validator, parm);
-            seen.add(parm.getName());
         }
         return seen;
     }
@@ -162,7 +180,6 @@ public void check(LFValidator validator, AttrParm parm) {
                     }
                     break;
             }
-
         }
     }
 
@@ -185,5 +202,7 @@ enum AttrParamType {
         ATTRIBUTE_SPECS_BY_NAME.put("label", new AttributeSpec(
             List.of(new AttrParamSpec(AttributeSpec.VALUE_ATTR, AttrParamType.STRING, null))
         ));
+        // @sparse
+        ATTRIBUTE_SPECS_BY_NAME.put("sparse", new AttributeSpec(null));
     }
 }

org.lflang/src/org/lflang/validation/LFValidator.java

@@ -37,12 +37,10 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -58,7 +56,6 @@
 import org.eclipse.xtext.validation.Check;
 import org.eclipse.xtext.validation.CheckType;
 import org.eclipse.xtext.validation.ValidationMessageAcceptor;
-
 import org.lflang.ASTUtils;
 import org.lflang.ModelInfo;
 import org.lflang.Target;
@@ -69,7 +66,6 @@
 import org.lflang.lf.Action;
 import org.lflang.lf.ActionOrigin;
 import org.lflang.lf.Assignment;
-import org.lflang.lf.AttrParm;
 import org.lflang.lf.Attribute;
 import org.lflang.lf.BuiltinTrigger;
 import org.lflang.lf.BuiltinTriggerRef;
@@ -114,8 +110,6 @@
 import org.lflang.lf.WidthSpec;
 import org.lflang.lf.WidthTerm;
 import org.lflang.util.FileUtil;
-import org.lflang.validation.AttributeSpec.AttrParamSpec;
-import org.lflang.validation.AttributeSpec.AttrParamType;
 
 import com.google.inject.Inject;