- some fixes for hpcom-memory-mapping

- isVarIndexListConsecutive-function added to SimCodeUtil - we are now able to check if all elements of an array are stored consecutive

Compiler/BackEnd/HpcOmMemory.mo

@@ -1942,17 +1942,15 @@ encapsulated package HpcOmMemory
           //print("convertCacheToVarArrayMapping: The first " + intString(Util.tuple31(currentVarIndices)) + " elements are reserved for states and state derivatives\n");
           varSizeFloat = Util.tuple31(currentVarIndices);
 
-          varIdxOffsets = arrayCreate(3,0);
+          varIdxOffsets = arrayCreate(3,1);
           varIdxOffsets = arrayUpdate(varIdxOffsets, 1, Util.tuple31(currentVarIndices) + 1);
           allCacheLines = List.sort(getAllCacheLinesOfCacheMap(iCacheMap), compareCacheLineMapByIdx);
           ((varArrayIndexMappingHashTable,varIndexMappingHashTable)) = List.fold(allCacheLines, function addCacheLineMapToVarArrayMapping(iCacheLineSize=cacheLineSize, iVarIdxOffsets=varIdxOffsets, iCacheVariables=cacheVariablesArray), (varArrayIndexMappingHashTable,varIndexMappingHashTable));
-          ((varArrayIndexMappingHashTable,varIndexMappingHashTable)) = List.fold(cacheLinesInt, function addCacheLineMapToVarArrayMapping(iCacheLineSize=cacheLineSize, iVarIdxOffsets=varIdxOffsets, iCacheVariables=cacheVariablesArray), (varArrayIndexMappingHashTable,varIndexMappingHashTable));
-          ((varArrayIndexMappingHashTable,varIndexMappingHashTable)) = List.fold(cacheLinesBool,function addCacheLineMapToVarArrayMapping(iCacheLineSize=cacheLineSize, iVarIdxOffsets=varIdxOffsets, iCacheVariables=cacheVariablesArray), (varArrayIndexMappingHashTable,varIndexMappingHashTable));
-
 
           currentVarIndices = (Util.tuple31(currentVarIndices) + intMul(listLength(cacheLinesFloat), maxNumElemsFloat), intMul(listLength(cacheLinesInt), maxNumElemsInt), intMul(listLength(cacheLinesBool), maxNumElemsBool));
           ((currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable)) = List.fold(notOptimizedVarsFloat, function SimCodeUtil.addVarToArrayIndexMapping(iVarType=VARDATATYPE_FLOAT), (currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable));
           ((currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable)) = List.fold(notOptimizedVarsInt, function SimCodeUtil.addVarToArrayIndexMapping(iVarType=VARDATATYPE_INTEGER), (currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable));
+          //print("convertCacheToVarArrayMapping: " + intString(Util.tuple33(currentVarIndices)) + " is the start index for bool variables\n");
           ((currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable)) = List.fold(notOptimizedVarsBool, function SimCodeUtil.addVarToArrayIndexMapping(iVarType=VARDATATYPE_BOOLEAN), (currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable));
 
           ((currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable)) = List.fold(iAliasVars, function SimCodeUtil.addVarToArrayIndexMapping(iVarType=VARDATATYPE_FLOAT), (currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable));
@@ -1964,6 +1962,7 @@ encapsulated package HpcOmMemory
           //print("\n");
           //print("convertCacheToVarArrayMapping: " + intString(intMul(listLength(cacheLinesFloat), maxNumElemsFloat)) + " elements are reserved optimized variables. " + intString(varSizeFloat) + " variables at all.\n");
           varSizeInt = intMul(listLength(cacheLinesInt), maxNumElemsInt) + listLength(notOptimizedVarsInt);
+          //print("convertCacheToVarArrayMapping: " + intString(intMul(listLength(cacheLinesBool), maxNumElemsBool)) + " elements are reserved for optimized variables [bool]\n");
           varSizeBool = intMul(listLength(cacheLinesBool), maxNumElemsBool) + listLength(notOptimizedVarsBool);
 
         then (varArrayIndexMappingHashTable, SOME(HpcOmSimCode.MEMORYMAP_ARRAY(varSizeFloat,varSizeInt,varSizeBool)));
@@ -2002,6 +2001,7 @@ encapsulated package HpcOmMemory
           CACHELINEENTRY(dataType=dataType, size=size)::_ = entries;
           //print("addCacheLineMapToVarArrayMapping: Adding cache line '" + intString(idx) + "' with '" + intString(listLength(entries)) + "' entries\n");
           (varArrayIndexMappingHashTable, varIndexMappingHashTable) = List.fold(entries, function addCacheLineEntryToVarArrayMapping(iArrayIdx=dataType, iClIdxSize=(idx, iCacheLineSize), iVarIdxOffsets=iVarIdxOffsets, iCacheVariables=iCacheVariables), iPositionMapping);
+          _ = arrayUpdate(iVarIdxOffsets, dataType, intAdd(arrayGet(iVarIdxOffsets, dataType), intDiv(iCacheLineSize, size)));
           //_ = convertCacheToVarArrayMapping2Helper(iVarIdxOffsets, 1, dataType);
         then ((varArrayIndexMappingHashTable, varIndexMappingHashTable));
        else
@@ -2032,9 +2032,10 @@ encapsulated package HpcOmMemory
     oPositionMapping := match(iCacheLineEntry, iArrayIdx, iClIdxSize, iVarIdxOffsets, iCacheVariables, iPositionMapping)
       case(CACHELINEENTRY(scVarIdx=scVarIdx, start=start, size=size),_,(clIdx, clSize),_,_,(varArrayIndexMappingHashTable, varIndexMappingHashTable))
         equation
-          //print("convertCacheMapToMemoryMap2: offset-array-size=" + intString(arrayLength(iVarIdxOffsets)) + " array-index=" + intString(iArrayIdx) + "\n");
           offset = arrayGet(iVarIdxOffsets, iArrayIdx);
-          arrayPosition = intDiv(start, size) + (clIdx - 1)*intDiv(clSize, size) + offset;
+          //arrayPosition = intDiv(start, size) + (clIdx - 1)*intDiv(clSize, size) + offset;
+          arrayPosition = intDiv(start, size) + offset;
+          //print("convertCacheMapToMemoryMap2: offset=" + intString(offset) + " array-index=" + intString(iArrayIdx) + " array-position=" + intString(arrayPosition) + "\n");
           currentVarIndices = (arrayPosition, arrayPosition, arrayPosition);
           //print("convertCacheMapToMemoryMap2: number of variables=" + intString(arrayLength(iCacheVariables)) + " arrayPosition=" + intString(arrayPosition) + "\n");
           (_, varArrayIndexMappingHashTable, varIndexMappingHashTable) = SimCodeUtil.addVarToArrayIndexMapping(arrayGet(iCacheVariables, arrayLength(iCacheVariables) - scVarIdx + 1), iArrayIdx, (currentVarIndices, varArrayIndexMappingHashTable, varIndexMappingHashTable));

Compiler/SimCode/SimCodeUtil.mo

@@ -12768,6 +12768,53 @@ algorithm
   oVarIndexList := tmpVarIndexListNew;
 end getVarIndexListByMapping;
 
+public function isVarIndexListConsecutive "author: marcusw
+  Check if all variable indices of the given variables, stored in the hash table, are consecutive."
+  input HashTableCrIListArray.HashTable iVarToArrayIndexMapping;
+  input DAE.ComponentRef iVarName;
+  output Boolean oIsConsecutive;
+protected
+  DAE.ComponentRef varName = iVarName;
+  Integer arrayIdx, idx, arraySize;
+  Integer currentIndex = -1;
+  array<Integer> varIndices;
+  Boolean consecutive = true;
+algorithm
+  varName := ComponentReference.crefStripLastSubs(varName);//removeSubscripts(varName);
+  if(BaseHashTable.hasKey(varName, iVarToArrayIndexMapping)) then
+    ((_,varIndices)) := BaseHashTable.get(varName, iVarToArrayIndexMapping);
+    arraySize := arrayLength(varIndices);
+    for arrayIdx in 0:(arraySize-1) loop
+      idx := arrayGet(varIndices, arraySize-arrayIdx);
+      if(intLt(idx, 0)) then
+        if(intEq(currentIndex, -1)) then
+          currentIndex := intMul(idx, -1) - 1;
+        else
+          consecutive := boolAnd(consecutive, intEq(currentIndex, intMul(idx, -1)));
+          currentIndex := intMul(idx, -1) - 1;
+        end if;
+        //print("SimCodeUtil.isVarIndexListConsecutive: Warning, negativ aliases (" + ComponentReference.printComponentRefStr(iVarName) + ") are not supported at the moment!\n");
+      else
+        if(intEq(idx, 0)) then
+          currentIndex := -2;
+          consecutive := false;
+        else
+          if(intEq(currentIndex, -1)) then
+            currentIndex := idx - 1;
+          else
+            //print("SimCodeUtil.isVarIndexListConsecutive: Checking if " + intString(currentIndex) + " is consecutive with " + intString(idx) + "\n");
+            consecutive := boolAnd(consecutive, intEq(currentIndex, idx));
+            //print("SimCodeUtil.isVarIndexListConsecutive: " + boolString(consecutive) + "\n");
+            currentIndex := idx - 1;
+          end if;
+        end if;
+      end if;
+    end for;
+  end if;
+  oIsConsecutive := consecutive;
+end isVarIndexListConsecutive;
+
+
 protected function getUnrolledArrayIndex "author: marcusw
   Calculate a flat array index, by the given subscripts. E.g. [2,1] for array of size 3x3 will lead to: 2."
   input DAE.Subscript iCurrentSubscript;

Compiler/Template/CodegenCpp.tpl

@@ -7310,7 +7310,7 @@ template MemberVariableDefine2(SimVar simVar, HashTableCrIListArray.HashTable va
           '<%typeString%> <%arrayName%>;'
       else
         <<
-        RefArrayDim<%dims%><<%typeString%>, <%array_dimensions%>> <%arrayName%>;
+        RefArrayDim<%dims%><<%typeString%>, <%array_dimensions%>> <%arrayName%>; //consecutive: <%SimCodeUtil.isVarIndexListConsecutive(varToArrayIndexMapping,name)%>
         >>
    /*special case for variables that marked as array but are not arrays */
     case SIMVAR(numArrayElement=_::_) then

Compiler/Template/SimCodeTV.mo

@@ -944,6 +944,11 @@ package SimCodeUtil
     output list<String> oVarIndexList;
   end getVarIndexListByMapping;
 
+  function isVarIndexListConsecutive
+    input HashTableCrIListArray.HashTable iVarToArrayIndexMapping;
+    input DAE.ComponentRef iVarName;
+    output Boolean oIsConsecutive;
+  end isVarIndexListConsecutive;
 end SimCodeUtil;
 
 

SimulationRuntime/cpp/Core/System/SimVars.cpp

@@ -23,11 +23,11 @@ SimVars::SimVars(size_t dim_real, size_t dim_int, size_t dim_bool, size_t dim_pr
     throw std::runtime_error("Wrong pre variable size");
   //allocate memory for all model variables
   if(dim_bool>0)
-  _bool_vars = boost::shared_ptr<AlignedArray<bool> >(new AlignedArray<bool>(dim_bool));
+    _bool_vars = boost::shared_ptr<AlignedArray<bool> >(new AlignedArray<bool>(dim_bool));
   if(dim_int>0)
-  _int_vars = boost::shared_ptr<AlignedArray<int> >(new AlignedArray<int>(dim_int));
+    _int_vars = boost::shared_ptr<AlignedArray<int> >(new AlignedArray<int>(dim_int));
   if(dim_real>0)
-  _real_vars = boost::shared_ptr<AlignedArray<double> >(new AlignedArray<double>(dim_real));
+    _real_vars = boost::shared_ptr<AlignedArray<double> >(new AlignedArray<double>(dim_real));
   if (dim_pre_vars > 0)
     _pre_vars =  new double[dim_pre_vars];
   //initialize all model variables