@sdeverywhere/compile 0.7.18 → 0.7.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",

package/src/model/model.js

@@ -25,6 +25,7 @@ import Variable from './variable.js'
 let variables = []
 let inputVars = []
 let constantExprs = new Map()
+let cachedSortedVarsByType = new Map()
 let cachedVarIndexInfo
 let cachedJsonList
 
@@ -46,6 +47,7 @@ function resetModelState() {
   variablesByName.clear()
   constantExprs.clear()
   nonAtoANames = Object.create(null)
+  cachedSortedVarsByType.clear()
   cachedVarIndexInfo = undefined
   cachedJsonList = undefined
 }
@@ -439,8 +441,8 @@ function resolveDuplicateDeclarations() {
   // Least and greatest safe double values in C rounded to convenient consts
   const MIN_SAFE_DBL = -1e308
   const MAX_SAFE_DBL = 1e308
-  let data = dataVars()
-  for (let constVar of constVars()) {
+  let data = varsOfType('data')
+  for (let constVar of varsOfType('const')) {
     if (data.find(d => d.varName === constVar.varName)) {
       // Change the var type from const to data and add lookup data points.
       // For a constant, the equivalent lookup has the same value over the entire x axis.
@@ -524,26 +526,53 @@ function allVars() {
   }
   return R.filter(isNotPlaceholderVar, variables)
 }
+function cachedSortedVars(varType, generate) {
+  // Return the cached array of sorted variables for the given type if
+  // available, otherwise call the `generate` function to generate the
+  // array and cache it in the map.
+  let vars = cachedSortedVarsByType.get(varType)
+  if (!vars) {
+    vars = generate()
+    cachedSortedVarsByType.set(varType, vars)
+  }
+  return vars
+}
 function constVars() {
-  return vsort(varsOfType('const'))
+  // Return an array of vars of type `const`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('const', () => vsort(varsOfType('const')))
 }
 function lookupVars() {
-  return vsort(varsOfType('lookup'))
+  // Return an array of vars of type `lookup`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('lookup', () => vsort(varsOfType('lookup')))
 }
 function dataVars() {
-  return vsort(varsOfType('data'))
+  // Return an array of vars of type `data`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('data', () => vsort(varsOfType('data')))
 }
 function auxVars() {
-  // console.error('AUX VARS');
-  return sortVarsOfType('aux')
+  // Return an array of vars of type `aux`, sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('aux', () => sortVarsOfType('aux'))
 }
 function levelVars() {
-  // console.error('LEVEL VARS');
-  return sortVarsOfType('level')
+  // Return an array of vars of type `level`, sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('level', () => sortVarsOfType('level'))
 }
 function initVars() {
-  // console.error('INIT VARS');
-  return sortInitVars()
+  // Return an array of all vars that have the `hasInitValue` flag set to true,
+  // sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('init', () => sortInitVars())
 }
 function varWithRefId(refId) {
   const findVarWithRefId = rid => {
@@ -1055,26 +1084,52 @@ function printDepsGraph(graph, varType) {
 
 function allListedVars() {
   // Put variables into the order that they are evaluated by SDE in the generated model
-  let vars = []
-  vars.push(...constVars())
-  vars.push(...lookupVars())
-  vars.push(...dataVars())
+  const listedVars = []
+  const visitedRefIds = new Set()
+  function addUnique(vars) {
+    for (const v of vars) {
+      // Skip variables that have already been visited
+      if (visitedRefIds.has(v.refId)) {
+        continue
+      }
+      visitedRefIds.add(v.refId)
+
+      // Filter out variables that are generated/used internally
+      if (v.includeInOutput === false) {
+        continue
+      }
+
+      // Include the variable
+      listedVars.push(v)
+    }
+  }
+
+  // The order of execution/evaluation in the generated model is:
+  //   initConstants (vars of type `const` only)
+  //   initLookups (vars of type `lookup` only)
+  //   initData (vars of type `data` only)
+  //   initLevels (vars returned by `initVars`, a mix of initial, aux, and level vars)
+  //   evalAux (vars of type `aux` only)
+  //   evalLevels (vars of type `level` only)
+  // So to make the ordering in the listing better match the order of evaluation,
+  // we emit variables in the above order, but filter to avoid having duplicates.
+  addUnique(constVars())
+  addUnique(lookupVars())
+  addUnique(dataVars())
   // The special exogenous `Time` variable may have already been removed by
   // `removeUnusedVariables` if it is not referenced explicitly in the model,
-  // so we will only include it in the listing if it is defined here
+  // so we will only include it in the listing if it is defined here.  Note
+  // that `_time` is set to `_initial_time` as the first step in the
+  // `initLevels` function, which is why it is included here.
   const timeVar = varWithName('_time')
   if (timeVar) {
-    vars.push(timeVar)
-  }
-  vars.push(...auxVars())
-  vars.push(...levelVars())
-
-  // Filter out variables that are generated/used internally
-  const isInternal = v => {
-    return v.includeInOutput === false
+    addUnique([timeVar])
   }
+  addUnique(initVars())
+  addUnique(auxVars())
+  addUnique(levelVars())
 
-  return R.filter(v => !isInternal(v), vars)
+  return listedVars
 }
 
 function filteredListedVars() {