[CodeGen] Introduce index map for resizable arrays (#12964)

- WIP use array index to access variables
- TODO
  1. load resizable parameters before calling initializeDataStruc
  2. correctly compute index map based on sizes of variables

Author: phannebohm

OMCompiler/Compiler/SimCode/SimCodeUtil.mo

@@ -15217,7 +15217,6 @@ algorithm
   n := 2*varInfo.numStateVars+varInfo.numAlgVars+varInfo.numDiscreteReal+varInfo.numOptimizeConstraints+varInfo.numOptimizeFinalConstraints;
 end nVariablesReal;
 
-
 public function getSimCode
   output SimCode.SimCode code;
 protected

OMCompiler/Compiler/Template/CodegenC.tpl

@@ -1521,11 +1521,11 @@ template populateModelInfo(ModelInfo modelInfo, String fileNamePrefix, String gu
     %>
     data->modelData->runTestsuite = <%if Testsuite.isRunning() then "1" else "0"%>;
     data->modelData->nStates = <%varInfo.numStateVars%>;
-    data->modelData->nVariablesReal = <%nVariablesReal(varInfo)%>;
+    data->modelData->nVariablesRealArray = <%nVariablesReal(varInfo)%>;
     data->modelData->nDiscreteReal = <%varInfo.numDiscreteReal%>;
-    data->modelData->nVariablesInteger = <%varInfo.numIntAlgVars%>;
-    data->modelData->nVariablesBoolean = <%varInfo.numBoolAlgVars%>;
-    data->modelData->nVariablesString = <%varInfo.numStringAlgVars%>;
+    data->modelData->nVariablesIntegerArray = <%varInfo.numIntAlgVars%>;
+    data->modelData->nVariablesBooleanArray = <%varInfo.numBoolAlgVars%>;
+    data->modelData->nVariablesStringArray = <%varInfo.numStringAlgVars%>;
     data->modelData->nParametersReal = <%varInfo.numParams%>;
     data->modelData->nParametersInteger = <%varInfo.numIntParams%>;
     data->modelData->nParametersBoolean = <%varInfo.numBoolParams%>;

OMCompiler/Compiler/Template/CodegenCFunctions.tpl

@@ -4862,27 +4862,27 @@ template crefToCStr(ComponentRef cr, Integer ix, Boolean isPre, Boolean isStart,
   match cr
   case CREF_IDENT(ident = "time") then "data->localData[0]->timeValue"
   case CREF_IDENT(ident = "$DAE_CJ") then "jacobian->dae_cj"
-  case CREF_QUAL(ident="$PRE", subscriptLst={}) then
+  case CREF_QUAL(ident = "$PRE", subscriptLst = {}) then
     (if isPre then error(sourceInfo(), 'Got $PRE for something that is already pre: <%crefStrNoUnderscore(cr)%>')
     else crefToCStr(componentRef, ix, true, isStart, &sub))
-  case CREF_QUAL(ident="$START") then
+  case CREF_QUAL(ident = "$START") then
     crefToCStr(componentRef, ix, isPre, true, &sub)
   else match cref2simvar(cr, getSimCode())
-    case SIMVAR(varKind=ALG_STATE_OLD(), index=index) then '(data->simulationInfo->inlineData->algOldVars[<%index%>])<%&sub%>'
-    case SIMVAR(aliasvar=ALIAS(varName=varName)) then crefToCStr(varName, ix, isPre, isStart, &sub)
-    case SIMVAR(aliasvar=NEGATEDALIAS(varName=varName), type_=T_BOOL()) then '!(<%crefToCStr(varName, ix, isPre, isStart, &sub)%>)'
-    case SIMVAR(aliasvar=NEGATEDALIAS(varName=varName)) then '-(<%crefToCStr(varName, ix, isPre, isStart, &sub)%>)'
-    case v as SIMVAR(varKind=JAC_VAR()) then '(parentJacobian->resultVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
-    case v as SIMVAR(varKind=JAC_TMP_VAR()) then '(parentJacobian->tmpVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
-    case v as SIMVAR(varKind=SEED_VAR()) then '(parentJacobian->seedVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
-    case v as SIMVAR(varKind=DAE_RESIDUAL_VAR()) then '(data->simulationInfo->daeModeData->residualVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
-    case v as SIMVAR(varKind=DAE_AUX_VAR()) then '(data->simulationInfo->daeModeData->auxiliaryVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
-    case SIMVAR(index=-2) then
+    case SIMVAR(varKind = ALG_STATE_OLD(), index = index) then '(data->simulationInfo->inlineData->algOldVars[<%index%>])<%&sub%>'
+    case SIMVAR(aliasvar = ALIAS(varName = varName)) then crefToCStr(varName, ix, isPre, isStart, &sub)
+    case SIMVAR(aliasvar = NEGATEDALIAS(varName = varName), type_=T_BOOL()) then '!(<%crefToCStr(varName, ix, isPre, isStart, &sub)%>)'
+    case SIMVAR(aliasvar = NEGATEDALIAS(varName = varName)) then '-(<%crefToCStr(varName, ix, isPre, isStart, &sub)%>)'
+    case v as SIMVAR(varKind = JAC_VAR()) then '(parentJacobian->resultVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
+    case v as SIMVAR(varKind = JAC_TMP_VAR()) then '(parentJacobian->tmpVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
+    case v as SIMVAR(varKind = SEED_VAR()) then '(parentJacobian->seedVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
+    case v as SIMVAR(varKind = DAE_RESIDUAL_VAR()) then '(data->simulationInfo->daeModeData->residualVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
+    case v as SIMVAR(varKind = DAE_AUX_VAR()) then '(data->simulationInfo->daeModeData->auxiliaryVars[<%index%>])<%&sub%><%crefCCommentWithVariability(v)%>'
+    case SIMVAR(index = -2) then
       (let s = (if isPre then crefNonSimVar(crefPrefixPre(cr)) else crefNonSimVar(cr))
       if intEq(ix,0) then s
       else '_<%s%>(<%ix%>)')
-    case var as SIMVAR(index=-1) then error(sourceInfo(), 'crefToCStr got index=-1 for <%variabilityString(varKind)%> <%crefStrNoUnderscore(name)%>')
-    case var as SIMVAR(__) then '<%varArrayNameValues(var, ix, isPre, isStart, &sub)%>'
+    case SIMVAR(index = -1) then error(sourceInfo(), 'crefToCStr got index=-1 for <%variabilityString(varKind)%> <%crefStrNoUnderscore(name)%>')
+    case v as SIMVAR(__) then varArrayNameValues(v, ix, isPre, isStart, &sub)
     else "CREF_NOT_IDENT_OR_QUAL"
 end crefToCStr;
 
@@ -7837,18 +7837,19 @@ template varArrayNameValues(SimVar var, Integer ix, Boolean isPre, Boolean isSta
           '(<%arr%>data->simulationInfo->extObjs[<%index%>])<%&sub%>'
         case SIMVAR(__) then
           let c_comment = CodegenUtil.crefCCommentWithVariability(var)
+          let ty = crefShortType(name)
           '<%if isStart then '<%varAttributes(var, &sub)%>.start'
-             else if isPre then '(<%arr%>data->simulationInfo-><%crefShortType(name)%>VarsPre[<%index%>]<%c_comment%>)<%&sub%>'
-             else '(<%arr%>data->localData[<%ix%>]-><%crefShortType(name)%>Vars[<%index%>]<%c_comment%>)<%sub%>'%>'
+             else if isPre then '(<%arr%>data->simulationInfo-><%ty%>VarsPre[<%index%>]<%c_comment%>)<%&sub%>'
+             else '(<%arr%>data->localData[<%ix%>]-><%ty%>Vars[data->simulationInfo-><%ty%>VarsIndex[<%index%>]]<%c_comment%>)<%sub%>'%>'
       end match
   end match
 end varArrayNameValues;
 
 template varArrayName(SimVar var)
 ::=
   match var
-  case SIMVAR(varKind=PARAM()) then '<%crefShortType(name)%>Parameter'
-  case SIMVAR(__) then '<%crefShortType(name)%>Vars'
+    case SIMVAR(varKind=PARAM()) then '<%crefShortType(name)%>Parameter'
+    case SIMVAR(__)              then '<%crefShortType(name)%>Vars'
 end varArrayName;
 
 template crefVarInfo(ComponentRef cr)

OMCompiler/SimulationRuntime/c/simulation/simulation_runtime.cpp

@@ -1063,6 +1063,8 @@ int initRuntimeAndSimulation(int argc, char**argv, DATA *data, threadData_t *thr
     data->simulationInfo->maxWarnDisplays = DEFAULT_FLAG_LV_MAX_WARN;
   }
 
+  // TODO this needs to happen after read_init_xml,
+  // or we need to read resizable parameters before this.
   initializeDataStruc(data, threadData);
   if(!data)
   {
@@ -1285,6 +1287,8 @@ void communicateMsg(char id, unsigned int size, const char *data)
  */
 int _main_initRuntimeAndSimulation(int argc, char**argv, DATA *data, threadData_t *threadData) {
 
+  // FIXME this looks like it's just a wrapper!
+
   if (initRuntimeAndSimulation(argc, argv, data, threadData)) //initRuntimeAndSimulation returns 1 if an error occurs
     return 1;
 

OMCompiler/SimulationRuntime/c/simulation/solver/model_help.c

@@ -1004,6 +1004,23 @@ void initializeDataStruc(DATA *data, threadData_t *threadData)
     throwStreamPrint(threadData, "Your memory is not strong enough for our ringbuffer!");
   }
 
+  /* index map */
+  data->simulationInfo->realVarsIndex = (size_t*) calloc(data->modelData->nVariablesRealArray + 1, sizeof(size_t));
+  data->simulationInfo->integerVarsIndex = (size_t*) calloc(data->modelData->nVariablesIntegerArray + 1, sizeof(size_t));
+  data->simulationInfo->booleanVarsIndex = (size_t*) calloc(data->modelData->nVariablesBooleanArray + 1, sizeof(size_t));
+  data->simulationInfo->stringVarsIndex = (size_t*) calloc(data->modelData->nVariablesStringArray + 1, sizeof(size_t));
+
+  /* compute index map */
+  for (i = 0; i < data->modelData->nVariablesRealArray + 1; i++)    data->simulationInfo->realVarsIndex[i] = i;
+  for (i = 0; i < data->modelData->nVariablesIntegerArray + 1; i++) data->simulationInfo->integerVarsIndex[i] = i;
+  for (i = 0; i < data->modelData->nVariablesBooleanArray + 1; i++) data->simulationInfo->booleanVarsIndex[i] = i;
+  for (i = 0; i < data->modelData->nVariablesStringArray + 1; i++)  data->simulationInfo->stringVarsIndex[i] = i;
+
+  data->modelData->nVariablesReal     = data->simulationInfo->realVarsIndex[data->modelData->nVariablesRealArray];
+  data->modelData->nVariablesInteger  = data->simulationInfo->integerVarsIndex[data->modelData->nVariablesIntegerArray];
+  data->modelData->nVariablesBoolean  = data->simulationInfo->booleanVarsIndex[data->modelData->nVariablesBooleanArray];
+  data->modelData->nVariablesString   = data->simulationInfo->stringVarsIndex[data->modelData->nVariablesStringArray];
+
   /* prepare RingBuffer */
   for(i=0; i<SIZERINGBUFFER; i++)
   {
@@ -1316,6 +1333,12 @@ void deInitializeDataStruc(DATA *data)
   free(data->simulationInfo->states_left);
   free(data->simulationInfo->states_right);
 
+  /* free buffer for index map */
+  free(data->simulationInfo->realVarsIndex);
+  free(data->simulationInfo->integerVarsIndex);
+  free(data->simulationInfo->booleanVarsIndex);
+  free(data->simulationInfo->stringVarsIndex);
+
   /* free buffer for old state variables */
   free(data->simulationInfo->realVarsOld);
   free(data->simulationInfo->integerVarsOld);

OMCompiler/SimulationRuntime/c/simulation_data.h

@@ -576,6 +576,13 @@ typedef struct MODEL_DATA
   long nBaseClocks;                    /* total number of base-clocks*/
 
   fortran_integer nStates;
+
+  /* numbers of unscalarized variables (arrays counted as one variable, used for index map) */
+  size_t nVariablesRealArray;
+  size_t nVariablesIntegerArray;
+  size_t nVariablesBooleanArray;
+  size_t nVariablesStringArray;
+
   long nVariablesReal;                 /* all Real Variables of the model (states, statesderivatives, algebraics, real discretes) */
   long nDiscreteReal;                  /* only all _discrete_ reals */
   long nVariablesInteger;
@@ -761,6 +768,12 @@ typedef struct SIMULATION_INFO
   modelica_real* states_left;          /* work array for findRoot in event.c */
   modelica_real* states_right;         /* work array for findRoot in event.c */
 
+  /* index map: arr_idx -> start_idx */
+  size_t* realVarsIndex;
+  size_t* integerVarsIndex;
+  size_t* booleanVarsIndex;
+  size_t* stringVarsIndex;
+
   /* old vars for event handling */
   modelica_real timeValueOld;
   modelica_real* realVarsOld;