- moved sorting of hpcom sim equations to the HpcOmSimCodeMain-module

- fixed memory optimization for fixed level scheduler

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@23539 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Marcus Walther

Compiler/BackEnd/HpcOmMemory.mo

@@ -430,6 +430,7 @@ encapsulated package HpcOmMemory
     list<PartlyFilledCacheLine> partlyFilledCacheLines; //cache lines that are shared between all threads -- SHARED variables -- but not fully filled
   algorithm
     print("createCacheMapLevelFixedOptimized: started \n");
+    printNodeSimCodeVarMapping(iNodeSimCodeVarMapping);
     cacheMap := CACHEMAP(iCacheLineSize,{},{});
     scVarCLMapping := arrayCreate(arrayLength(iAllSCVarsMapping),(-1,-1));
     numCL := 0;
@@ -438,7 +439,7 @@ encapsulated package HpcOmMemory
     cacheMapMeta := CACHEMAPMETA(iAllSCVarsMapping, iSimCodeVarTypes, scVarCLMapping);
     //Iterate over levels
     ((threadCacheLines,partlyFilledCacheLines,cacheMap as CACHEMAP(cacheVariables=cacheVariables, cacheLinesFloat=cacheLinesFloat),cacheMapMeta,numCL,_)) := List.fold(iTasksOfLevels, function createCacheMapLevelFixedOptimized0(iTaskGraph=iTaskGraph, iTaskGraphMeta=iTaskGraphMeta, iNumberOfThreads=iNumberOfThreads, iSchedulerInfo=iSchedulerInfo, iNodeSimCodeVarMapping=iNodeSimCodeVarMapping), (threadCacheLines, partlyFilledCacheLines,cacheMap,cacheMapMeta,numCL,1));
-    cacheLinesFloat := List.map(partlyFilledCacheLines, getCacheLineMapOfPartlyFilledCacheLine);
+    cacheLinesFloat := listAppend(cacheLinesFloat, List.map(partlyFilledCacheLines, getCacheLineMapOfPartlyFilledCacheLine));
     oCacheMap := CACHEMAP(iCacheLineSize, cacheVariables, Array.fold(threadCacheLines, listAppend, cacheLinesFloat));
     CACHEMAPMETA(scVarCLMapping=oScVarCLMapping) := cacheMapMeta;
     printCacheMap(oCacheMap);
@@ -474,22 +475,6 @@ encapsulated package HpcOmMemory
     CACHEMAP(cacheLinesFloat=cacheLinesFloat,cacheLineSize=cacheLineSize) := cacheMap;
     //print("createCacheMapLevelFixedOptimized0: Handling new level. Shared CL: " + stringDelimitList(List.map(sharedCacheLines,intString), ",") + " Number of CL: " + intString(numCL) + "\n");
     ((cacheMap,cacheMapMeta,createdCL,partlyFilledCacheLines)) := List.fold(getTaskListTasks(iLevelTasks), function createCacheMapLevelFixedOptimizedForTask(iTaskGraph=iTaskGraph, iTaskGraphMeta=iTaskGraphMeta, iSchedulerInfo=iSchedulerInfo, iNumberOfThreads=iNumberOfThreads, iLevel=level, iNodeSimCodeVarMapping = iNodeSimCodeVarMapping, iThreadCacheLines = threadCacheLines), (cacheMap,cacheMapMeta,numCL,partlyFilledCacheLines));
-    /*
-    availableCLold := List.setDifferenceIntN(allCL,cacheLinesPrevLevel,numCL);
-    //append free space to available cache lines and remove full cache lines
-    detailedCacheLineInfo := createDetailedCacheMapInformations(availableCLold, cacheLinesFloat, cacheLineSize);
-    detailedCacheLineInfo := listReverse(detailedCacheLineInfo);
-    //print("createCacheMapLevelOptimized0: clCandidates: " + stringDelimitList(List.map(List.map(detailedCacheLineInfo,Util.tuple21),intString), ",") + "\n");
-    availableCL := List.map(detailedCacheLineInfo, Util.tuple21);
-    //append the used cachelines to the writtenCL-list
-    //print("createCacheMapLevelOptimized0: New cacheLines created: " + intString(createdCL) + "\n");
-    writtenCL := List.setDifferenceIntN(availableCLold,availableCL,numCL);
-    //print("createCacheMapLevelOptimized0: Written CL_0: " + stringDelimitList(List.map(writtenCL,intString), ",") + " -- numCL: " + intString(numCL) + "\n");
-    writtenCL := listAppend(writtenCL, if intLe(numCL+1, numCL+createdCL) then List.intRange2(numCL+1, numCL+createdCL) else {});
-    //print("createCacheMapLevelOptimized0: Written CL_1: " + stringDelimitList(List.map(writtenCL,intString), ",") + "\n");
-    //print("======================================\n");
-    //printCacheMap(cacheMap);
-    //print("======================================\n"); */
     oInfo := (threadCacheLines,partlyFilledCacheLines,cacheMap,cacheMapMeta,createdCL,level+1);
   end createCacheMapLevelFixedOptimized0;
 
@@ -511,22 +496,25 @@ encapsulated package HpcOmMemory
     CacheMapMeta cacheMapMeta;
     tuple<CacheMap,CacheMapMeta,Integer,list<PartlyFilledCacheLine>> tmpInfo;
     Integer threadIdx, varType, numNewCL;
+    array<Option<SimCodeVar.SimVar>> allSCVarsMapping;
     list<PartlyFilledCacheLine> partlyFilledCacheLines; //map each non full Cachline to: PrefetchLevel, WriteLevel (LevelIdx, ThreadIdx)
   algorithm
     oInfo := match(iTask, iTaskGraph, iTaskGraphMeta, iSchedulerInfo, iNumberOfThreads, iNodeSimCodeVarMapping, iInfo)
-      case(HpcOmSimCode.CALCTASK_LEVEL(nodeIdc=nodeIdc,threadIdx=SOME(threadIdx)),_,_,_,_,_,(cacheMap,cacheMapMeta,numNewCL,partlyFilledCacheLines))
+      case(HpcOmSimCode.CALCTASK_LEVEL(nodeIdc=nodeIdc,threadIdx=SOME(threadIdx)),_,_,_,_,_,(cacheMap,cacheMapMeta as CACHEMAPMETA(allSCVarsMapping=allSCVarsMapping),numNewCL,partlyFilledCacheLines))
         equation
-          //print("\t\tcreateCacheMapLevelFixedOptimizedForTask: handling task with node-indices: " + stringDelimitList(List.map(nodeIdc, intString), ",") + "\n");
+          print("\t\tcreateCacheMapLevelFixedOptimizedForTask: handling task with node-indices: " + stringDelimitList(List.map(nodeIdc, intString), ",") + "\n");
           //Get successor tasks
           successorTasks = List.flatten(List.map(nodeIdc, function arrayGet(arr=iTaskGraph)));
           nodeVars = List.flatten(List.map(nodeIdc, function arrayGet(arr=iNodeSimCodeVarMapping)));
           nodeVars = List.sortedUnique(nodeVars,intEq);
           varType = getCacheLineVarTypeBySuccessorList(successorTasks, iSchedulerInfo, iNumberOfThreads, threadIdx);
           if(intEq(varType,1)) then
-            print("\t\t\tcreateCacheMapLevelFixedOptimizedForTask: Handling variables " + stringDelimitList(List.map(nodeVars, intString), ",") + " as THREAD_ONLY\n");
+            print("\t\t\tcreateCacheMapLevelFixedOptimizedForTask: Handling variables " + stringDelimitList(List.map(nodeVars, intString), ",") + " as THREAD_ONLY by Thread " + intString(threadIdx) + "\n");            
+            print("\t\t\t " + stringDelimitList(List.map(nodeVars, function dumpScVarsByIdx(iAllSCVarsMapping=allSCVarsMapping)), "\n\t\t\t ") + "\n");
             ((cacheMap,cacheMapMeta,numNewCL)) = addFixedLevelVarToThreadCL(nodeVars,threadIdx,iThreadCacheLines,(cacheMap,cacheMapMeta,numNewCL));
           else
-            print("\t\t\tcreateCacheMapLevelFixedOptimizedForTask: Handling variables " + stringDelimitList(List.map(nodeVars, intString), ",") + " as SHARED\n");
+            print("\t\t\tcreateCacheMapLevelFixedOptimizedForTask: Handling variables " + stringDelimitList(List.map(nodeVars, intString), ",") + " as SHARED by Thread " + intString(threadIdx) + "\n");
+            print("\t\t\t " + stringDelimitList(List.map(nodeVars, function dumpScVarsByIdx(iAllSCVarsMapping=allSCVarsMapping)), "\n\t\t\t ") + "\n");
             ((cacheMap,cacheMapMeta,numNewCL,partlyFilledCacheLines)) = addFixedLevelVarToSharedCL(nodeVars,threadIdx,iLevel,(cacheMap,cacheMapMeta,numNewCL,partlyFilledCacheLines));
             print("\t\t\tcreateCacheMapLevelFixedOptimizedForTask: Number of partly filled CLs: " + intString(listLength(partlyFilledCacheLines)) + "\n");
           end if;
@@ -714,7 +702,7 @@ encapsulated package HpcOmMemory
   algorithm
     oInfo := match(iMatchedCacheLine, iThreadIdx, iVarIdx, iLevelIdx, iInfo)
       case(SOME((partlyFilledCacheLine as PARTLYFILLEDCACHELINE(cacheLineMap, prefetchLevel, writeLevel),listIndex)),_,_,_,(CACHEMAP(cacheLineSize=cacheLineSize,cacheVariables=cacheVariables,cacheLinesFloat=cacheLinesFloat),CACHEMAPMETA(allSCVarsMapping=allSCVarsMapping,simCodeVarTypes=simCodeVarTypes,scVarCLMapping=scVarCLMapping),numNewCL,partlyFilledCLs))
-        equation
+        equation //this case is used if the partly filled cache line has enough space to store the variable 
           CACHELINEMAP(idx,numBytesFree,entries) = cacheLineMap;
           ((varType,varSize)) = arrayGet(simCodeVarTypes, iVarIdx);
           numBytesFree = numBytesFree - varSize;
@@ -733,25 +721,30 @@ encapsulated package HpcOmMemory
 
           scVarCLMapping = arrayUpdate(scVarCLMapping, iVarIdx, (idx,varType));
 
-          if(intEq(numBytesFree - varSize, 0)) then //CL is now full - remove it from partly filled CL list and at it to cachemap
+          if(intEq(numBytesFree, 0)) then //CL is now full - remove it from partly filled CL list and at it to cachemap
             partlyFilledCLs = listDelete(partlyFilledCLs, listIndex);
+            print("addFixedLevelVarToSharedCL0: Cache line with index " + intString(idx) + " is now fully filled\n");
             cacheLinesFloat = cacheLineMap::cacheLinesFloat;
+            numNewCL = numNewCL - 1;
+          else
+            partlyFilledCLs = List.set(partlyFilledCLs, listIndex, partlyFilledCacheLine);
           end if;
+          print("addFixedLevelVarToSharedCL0: Used existing cache line with index " + intString(idx) + " to store the variable\n");
         then ((CACHEMAP(cacheLineSize,cacheVariables,cacheLinesFloat),CACHEMAPMETA(allSCVarsMapping,simCodeVarTypes,scVarCLMapping),numNewCL,partlyFilledCLs));
       case(NONE(),_,_,_,(CACHEMAP(cacheLineSize=cacheLineSize,cacheVariables=cacheVariables,cacheLinesFloat=cacheLinesFloat),CACHEMAPMETA(allSCVarsMapping=allSCVarsMapping,simCodeVarTypes=simCodeVarTypes,scVarCLMapping=scVarCLMapping),numNewCL,partlyFilledCLs))
         equation
           ((varType,varSize)) = arrayGet(simCodeVarTypes, iVarIdx);
 
           numNewCL = numNewCL + 1;
           idx = listLength(cacheLinesFloat) + numNewCL;
-          numBytesFree = cacheLineSize;
+          numBytesFree = cacheLineSize - varSize;
           entries = {};
           prefetchLevel = {};
           writeLevel = {};
 
           SOME(cacheVariable) = arrayGet(allSCVarsMapping, iVarIdx);
           cacheVariables = cacheVariable::cacheVariables;
-          entry = CACHELINEENTRY(cacheLineSize - numBytesFree, varType, varSize, listLength(cacheVariables));
+          entry = CACHELINEENTRY(0, varType, varSize, listLength(cacheVariables));
           cacheLineMap = CACHELINEMAP(idx,numBytesFree,entry::entries);
 
           if(intGt(iLevelIdx - 1, 0)) then
@@ -768,7 +761,7 @@ encapsulated package HpcOmMemory
           else //Add new CL as partly filled CL
             partlyFilledCLs = partlyFilledCacheLine::partlyFilledCLs;
           end if;
-          print("addFixedLevelVarToSharedCL0: New CL added\n");
+          print("addFixedLevelVarToSharedCL0: Created a new cache line with index " + intString(idx) + " to store the variable\n");
         then ((CACHEMAP(cacheLineSize,cacheVariables,cacheLinesFloat),CACHEMAPMETA(allSCVarsMapping,simCodeVarTypes,scVarCLMapping),numNewCL,partlyFilledCLs));
     end match;
   end addFixedLevelVarToSharedCL0;
@@ -1883,6 +1876,25 @@ encapsulated package HpcOmMemory
     print("Scc " + intString(iIdx) + " is solved by node " + intString(iMappingEntry) + "\n");
     oIdx := iIdx + 1;
   end printSccNodeMapping0;
+  
+  protected function dumpScVarsByIdx
+    input Integer iSimCodeVarIdx;
+    input array<Option<SimCodeVar.SimVar>> iAllSCVarsMapping;
+    output String oString;
+  protected
+    String tmpString;
+    SimCodeVar.SimVar simVar;
+  algorithm
+    oString := matchcontinue(iSimCodeVarIdx, iAllSCVarsMapping)
+      case(_,_)
+        equation
+          SOME(simVar) = arrayGet(iAllSCVarsMapping, iSimCodeVarIdx);
+          tmpString = dumpSimCodeVar(simVar);
+        then tmpString;
+      else
+      then "NONE";
+    end matchcontinue;
+  end dumpScVarsByIdx;
 
   // -------------------------------------------
   // SUSAN

Compiler/BackEnd/HpcOmScheduler.mo

@@ -194,7 +194,7 @@ algorithm
 
         //print("Eq idc: " + stringDelimitList(List.map(eqIdc, intString), ",") + "\n");
         simEqIdc = List.map(List.map1(eqIdc,getSimEqSysIdxForComp,iSccSimEqMapping), List.last);
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
 
         newTask = HpcOmSimCode.CALCTASK(weighting,index,calcTime,threadFinishTime,threadId,simEqIdc);
         threadTasks = newTask::threadTasks;
@@ -231,7 +231,7 @@ algorithm
         simEqIdc = List.flatten(List.map1(eqIdc,getSimEqSysIdxForComp,iSccSimEqMapping));
         //print("\tEq idc: " + stringDelimitList(List.map(eqIdc, intString), ",") + "\n");
         //print("\tSimcodeeq idc: " + stringDelimitList(List.map(simEqIdc, intString), ",") + "\n");
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
         newTask = HpcOmSimCode.CALCTASK(weighting,index,calcTime,threadFinishTime,threadId,simEqIdc);
         allThreadTasks = arrayUpdate(allThreadTasks,threadId,newTask::threadTasks);
         //!print("\n\tZeile 243\t" + stringDelimitList(List.map(listGet(arrayList(allThreadTasks), threadId), dumpTask), "\t\t"));
@@ -381,7 +381,7 @@ algorithm
         threadTasks = listAppend(lockTasks, threadTasks);
 
         simEqIdc = List.map(List.map1(eqIdc, getSimEqSysIdxForComp, iSccSimEqMapping), List.last);
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
 
 
         //! Add task to thread
@@ -422,7 +422,7 @@ algorithm
         threadTasks = arrayGet(allThreadTasks, threadId);
 
         simEqIdc = List.flatten(List.map1(eqIdc, getSimEqSysIdxForComp, iSccSimEqMapping));
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
 
         newTask = HpcOmSimCode.CALCTASK(weighting, index, calcTime, threadFinishTime, threadId, simEqIdc);
         allThreadTasks = arrayUpdate(allThreadTasks, threadId, newTask::threadTasks);
@@ -1367,12 +1367,15 @@ protected
   String lockId, s;
   HpcOmSimCode.Schedule taskSchedule;
   Boolean outgoing;
+  Integer threadIdx;
 algorithm
   oString := match(iTask)
     case(HpcOmSimCode.CALCTASK(weighting=weighting,timeFinished=timeFinished, index=index, eqIdc=eqIdc))
       then ("Calculation task with index " + intString(index) + " including the equations: "+stringDelimitList(List.map(eqIdc,intString),", ")+ " is finished at  " + realString(timeFinished) + "\n");
-    case(HpcOmSimCode.CALCTASK_LEVEL(eqIdc=eqIdc, nodeIdc=nodeIdc))
+    case(HpcOmSimCode.CALCTASK_LEVEL(eqIdc=eqIdc, nodeIdc=nodeIdc, threadIdx=NONE()))
       then ("Calculation task ("+stringDelimitList(List.map(nodeIdc,intString),", ")+") including the equations: "+stringDelimitList(List.map(eqIdc,intString),", ")+"\n");
+    case(HpcOmSimCode.CALCTASK_LEVEL(eqIdc=eqIdc, nodeIdc=nodeIdc, threadIdx=SOME(threadIdx)))
+      then ("Calculation task ("+stringDelimitList(List.map(nodeIdc,intString),", ")+") including the equations: "+stringDelimitList(List.map(eqIdc,intString),", ")+" by thread " + intString(threadIdx) + "\n");
     case(HpcOmSimCode.DEPTASK(sourceTask=HpcOmSimCode.CALCTASK(index=sourceIndex), targetTask=HpcOmSimCode.CALCTASK(index=targetIndex),outgoing=outgoing))
       equation
         s = "Dependency task ";
@@ -1636,7 +1639,7 @@ algorithm
         // generate a serial section
         compLst = List.flatten(List.map1(section,Array.getIndexFirst,inComps));
         simEqSysIdcs = getSimEqSysIdcsForCompLst(compLst,iSccSimEqMapping);
-        simEqSysIdcs = List.sort(simEqSysIdcs,intGt);
+        //simEqSysIdcs = List.sort(simEqSysIdcs,intGt);
         task = makeCalcLevelTask(simEqSysIdcs,section);
         taskLst = HpcOmSimCode.SERIALTASKLIST({task}, true);
     then taskLst;
@@ -1647,7 +1650,7 @@ algorithm
         sectionComps = List.mapList1_1(sectionComps,List.sort,intGt);
         sectionSimEqSys = List.map1(sectionComps,getSimEqSysIdcsForNodeLst,iSccSimEqMapping);
         sectionSimEqSysIdcs = List.map(sectionSimEqSys,List.flatten);
-        sectionSimEqSysIdcs = List.map1(sectionSimEqSysIdcs,List.sort,intGt);
+        //sectionSimEqSysIdcs = List.map1(sectionSimEqSysIdcs,List.sort,intGt);
         taskLst = makeCalcLevelParTaskLst(sectionSimEqSysIdcs,level);
     then taskLst;
   end matchcontinue;
@@ -1954,7 +1957,7 @@ algorithm
     print("number of level: "+intString(listLength(level))+"\nnumber of processors :"+intString(Flags.getConfigInt(Flags.NUM_PROC))+"\n");
   end if;
   levelComps := List.mapList1_1(level,Array.getIndexFirst,inComps);
-  levelComps := List.mapList1_1(levelComps,List.sort,intGt);
+  //levelComps := List.mapList1_1(levelComps,List.sort,intGt);
   SCCs := List.map1(levelComps,getSimEqSysIdcsForNodeLst,iSccSimEqMapping);
   levelTasks := List.threadMap(SCCs,List.mapList(level,List.create),makeCalcLevelParTaskLst);
   oSchedule := HpcOmSimCode.LEVELSCHEDULE(levelTasks, false);
@@ -2126,15 +2129,28 @@ protected
   list<HpcOmSimCode.Task> taskList;
   HpcOmSimCode.Task newTask;
   list<Integer> components, simEqs;
+  Integer taskIdx;
 algorithm
   (threadIdx, taskList) := iIdxTaskList;
-  components := List.flatten(List.map1(iTaskList, Array.getIndexFirst, iComps)); //Components of each task
-  simEqs := List.flatten(List.map(List.map1(components,Array.getIndexFirst,iSccSimEqMapping), listReverse));
-  print("createFixedLevelScheduleForLevel0: eqs=" + stringDelimitList(List.map(simEqs, intString), ",") + "\n");
-  simEqs := listReverse(simEqs);
-  print("createFixedLevelScheduleForLevel0: eqs=" + stringDelimitList(List.map(simEqs, intString), ",") + "\n");
-  newTask := HpcOmSimCode.CALCTASK_LEVEL(simEqs, iTaskList, SOME(threadIdx));
-  taskList := newTask :: taskList;
+  for taskIdx in iTaskList loop
+    components := arrayGet(iComps, taskIdx); //Components of the task
+    print("createFixedLevelScheduleForLevel0: Handling task with idx: " + intString(taskIdx) + "\n");
+    simEqs := List.flatten(List.map(List.map1(components,Array.getIndexFirst,iSccSimEqMapping), listReverse));
+    if(intGt(listLength(simEqs), 0)) then
+      simEqs := simEqs;
+      newTask := HpcOmSimCode.CALCTASK_LEVEL(simEqs, {taskIdx}, SOME(threadIdx));
+      taskList := newTask :: taskList;
+    end if;  
+  end for;
+  
+  //This code merges all tasks handled by the same thread -- makes efficient memory management more complicated
+  //components := List.flatten(List.map1(iTaskList, Array.getIndexFirst, iComps)); //Components of each task
+  //simEqs := List.flatten(List.map(List.map1(components,Array.getIndexFirst,iSccSimEqMapping), listReverse));
+  //if(intGt(listLength(simEqs), 0)) then
+  //  simEqs := listReverse(simEqs);
+  //  newTask := HpcOmSimCode.CALCTASK_LEVEL(simEqs, iTaskList, SOME(threadIdx));
+  //  taskList := newTask :: taskList;
+  //end if;
   oIdxTaskList := (threadIdx+1,taskList);
 end createFixedLevelScheduleForLevel0;
 
@@ -2851,7 +2867,7 @@ algorithm
         //print("Eq idc: " + stringDelimitList(List.map(eqIdc, intString), ",") + "\n");
         simEqIdc = List.map(List.map1(eqIdc,getSimEqSysIdxForComp,iSccSimEqMapping), List.last);
         //print("Simcodeeq idc: " + stringDelimitList(List.map(simEqIdc, intString), ",") + "\n");
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
 
         newTask = HpcOmSimCode.CALCTASK(weighting,index,calcTime,threadFinishTime,threadId,simEqIdc);
         threadTasks = newTask::threadTasks;
@@ -2877,7 +2893,7 @@ algorithm
         threadTasks = arrayGet(allThreadTasks,threadId);
 
         simEqIdc = List.flatten(List.map1(eqIdc,getSimEqSysIdxForComp,iSccSimEqMapping));
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
 
         newTask = HpcOmSimCode.CALCTASK(weighting,index,calcTime,threadFinishTime,threadId,simEqIdc);
         allThreadTasks = arrayUpdate(allThreadTasks,threadId,newTask::threadTasks);
@@ -4700,7 +4716,7 @@ algorithm
         mark = arrayGet(nodeMark,node);
         ((_,exeCost)) = HpcOmTaskGraph.getExeCost(node,taskGraphMetaIn);
         simEqIdc = List.map(List.map1(components,getSimEqSysIdxForComp,SccSimEqMappingIn), List.last);
-        simEqIdc = List.sort(simEqIdc,intGt);
+        //simEqIdc = List.sort(simEqIdc,intGt);
         task = HpcOmSimCode.CALCTASK(mark,node,exeCost,-1.0,proc,simEqIdc);
         taskLst1 = task::taskLstRel;
         taskLst1 = listAppend(taskLstAss,taskLst1);