public static bool Node_In_SESE(GraphVariables.clsSESE clsSESE, int workSESE, int node, int currSESE)
{
bool inside = false;
for (int i = 0; i < clsSESE.SESE[workSESE].SESE[currSESE].nNode; i++)
{
if (clsSESE.SESE[workSESE].SESE[currSESE].Node[i] == node)
{
inside = true;
break;
}
}
if (inside)
{
for (int i = 0; i < clsSESE.SESE[workSESE].SESE[currSESE].nChild; i++)
{
if (currSESE != clsSESE.SESE[workSESE].SESE[currSESE].child[i])
{
for (int j = 0; j < clsSESE.SESE[workSESE].SESE[clsSESE.SESE[workSESE].SESE[currSESE].child[i]].nNode; j++)
{
if (clsSESE.SESE[workSESE].SESE[clsSESE.SESE[workSESE].SESE[currSESE].child[i]].Node[j] == node)
{
return(false);
}
}
}
}
}
else
{
return(false);
}
return(true);
}
//might not use
private void reduceAllChild(ref GraphVariables.clsGraph graph, int currentN, GraphVariables.clsHWLS clsHWLS, int currBlock, GraphVariables.clsLoop clsLoop, int workLoop,
GraphVariables.clsSESE clsSESE, int workSESE, int orgIndex)
{
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
if (clsHWLS.FBLOCK.FBlock[i].parentBlock == currBlock)
{
if (clsHWLS.FBLOCK.FBlock[i].SESE == true)
{
gProAnalyzer.Ultilities.reduceGraph.reduce_SESE(ref graph, currentN, clsSESE, workSESE, orgIndex);
}
if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndex].nEntry == 1)
{
gProAnalyzer.Ultilities.reduceGraph.reduce_Loop(ref graph, currentN, ref clsLoop, workLoop, orgIndex, "", false);
}
//if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndex].nEntry > 1)
//reduceG.reduce_IrLoop(ref graph, currentN, clsLoop, workLoop, orgIndex);
}
}
}
public void total_reduceSubgraph(ref GraphVariables.clsGraph graph, int currentN, GraphVariables.clsHWLS clsHWLS, GraphVariables.clsLoop clsLoop, int workLoop,
GraphVariables.clsSESE clsSESE, int workSESE, int stopDepth) //Reduce all the loops inside (NL, IL)
{
int curDepth = clsHWLS.FBLOCK.maxDepth;
if (curDepth == stopDepth)
{
return;
}
//curDepth = 1;
do
{
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
if (clsHWLS.FBLOCK.FBlock[i].depth != curDepth)
{
continue;
}
int orgIndx = clsHWLS.FBLOCK.FBlock[i].refIndex;
//If SESE => Make subnetwork and find Dominator Behavior relation matrix (1 matrix)
if (clsHWLS.FBLOCK.FBlock[i].SESE)
{
reduce_SESE(ref graph, currentN, clsSESE, workSESE, orgIndx);
}
//If NL => Make subnetwork and find Dom/ Pdom Behavior relation matrix (2 matrices)
if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndx].nEntry == 1)
{
reduce_Loop(ref graph, currentN, ref clsLoop, workLoop, orgIndx, "", false);
}
//if IL => Find CIPd => Make subnetwork with CIPd and find Dom/ Pdom Behavior relation matrix (2 matrices)
if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndx].nEntry > 1)
{
reduce_IrLoop(ref graph, currentN, clsLoop, workLoop, orgIndx);
}
}
curDepth--;
} while (curDepth > stopDepth);
}
public void build_loopDAG(ref GraphVariables.clsGraph graph, int currentN, ref GraphVariables.clsLoop clsLoop, int currentLoop,
ref GraphVariables.clsSESE clsSESE, ref GraphVariables.clsLoopDAG clsLoopDAG, int currentLoopDAG)
{
int init_n = Initialize_loopDAG(graph, currentN, clsLoop, currentLoop);
clsLoopDAG.loopDAG[currentLoopDAG].loopDAG = new GraphVariables.clsLoopDAG.strLoopDAGInfo[init_n];
clsLoopDAG.loopDAG[currentLoopDAG].nLoopDAG = 0;
//clsLoopDAG.loopDAG[currentLoopDAG].loopDAG[1].DAG.header;
//int count_loopDAG = 0;
for (int i = 0; i < clsLoop.Loop[currentLoop].nLoop; i++)
{
gProAnalyzer.GraphVariables.clsLoop.strLoopInform loop = clsLoop.Loop[currentLoop].Loop[i];
if (loop.nEntry == 1) //NL
{
gProAnalyzer.Ultilities.makeSubNetwork.make_subNetwork(ref graph, currentN, graph.acyclicNet, ref clsLoop, currentLoop, i, ref clsSESE, "FF", -1);
}
else //IL
{
}
}
}
public static void make_NestingForest(ref GraphVariables.clsGraph graph, int currentN, ref GraphVariables.clsHWLS clsHWLS, ref GraphVariables.clsLoop clsLoop,
int workLoop, ref GraphVariables.clsSESE clsSESE, int workSESE)
{
int bIndex = 0;
//FBLOCK.FBlock = new strFBlock[SESE[currentSESE].nSESE + Loop[currentLoop].nLoop];
if (workSESE >= 0 && workLoop >= 0)
{
clsHWLS.FBLOCK.FBlock = new GraphVariables.clsHWLS.strFBlock[clsSESE.SESE[workSESE].nSESE + clsLoop.Loop[workLoop].nLoop];
}
else
{
if (workSESE >= 0)
{
clsHWLS.FBLOCK.FBlock = new GraphVariables.clsHWLS.strFBlock[clsSESE.SESE[workSESE].nSESE];
}
else
{
clsHWLS.FBLOCK.FBlock = new GraphVariables.clsHWLS.strFBlock[clsLoop.Loop[workLoop].nLoop];
}
}
//Copy SESE
if (workSESE >= 0 && clsSESE.SESE[workSESE].nSESE > 0)
{
//copy SESE and LOOP to FBlock;
for (int i = 0; i < clsSESE.SESE[workSESE].nSESE; i++)
{
//copy SESE to FBlock
//FBlock[bIndex].child = SESE[currentSESE].SESE[i].child;
//FBlock[bIndex].depth = SESE[currentSESE].SESE[i].depth;
clsHWLS.FBLOCK.FBlock[bIndex].Entry = new int[1];
clsHWLS.FBLOCK.FBlock[bIndex].Entry[0] = clsSESE.SESE[workSESE].SESE[i].Entry;
clsHWLS.FBLOCK.FBlock[bIndex].Exit = new int[1];
clsHWLS.FBLOCK.FBlock[bIndex].Exit[0] = clsSESE.SESE[workSESE].SESE[i].Exit;
clsHWLS.FBLOCK.FBlock[bIndex].nEntry = 1;
clsHWLS.FBLOCK.FBlock[bIndex].nExit = 1;
clsHWLS.FBLOCK.FBlock[bIndex].Node = clsSESE.SESE[workSESE].SESE[i].Node;
clsHWLS.FBLOCK.FBlock[bIndex].nNode = clsSESE.SESE[workSESE].SESE[i].nNode;
//FBlock[bIndex].parentBlock ??
clsHWLS.FBLOCK.FBlock[bIndex].SESE = true;
clsHWLS.FBLOCK.FBlock[bIndex].refIndex = i;
bIndex++;
}
}
//Copy Loop
if (workLoop >= 0 && clsLoop.Loop[workLoop].nLoop > 0)
{
copy_Loop(ref clsLoop, workLoop, clsLoop.newTempLoop);
//modify tempLoop => expand the node
for (int i = 0; i < clsLoop.Loop[clsLoop.newTempLoop].nLoop; i++)
{
if (clsLoop.Loop[clsLoop.newTempLoop].Loop[i].parentLoop != -1)
{
continue; //only start with the outter loop //Log: Otc28_2020
}
//MAKE A SLIGHT CHANGE HERE ======================================
//if (clsLoop.Loop[clsLoop.newTempLoop].Loop[i].depth != 1) continue;
int n = 0;
int[] temp = GetFullNode(ref graph, currentN, ref clsLoop, clsLoop.newTempLoop, i, ref n); //get full node of Loop (newTempLoop) update this loop and all child (including header)
//remove redundancy in Loop[i].Node[];
//temp = removeRedundancyNode(temp);
}
//copy Loop to FBlock
for (int i = 0; i < clsLoop.Loop[clsLoop.newTempLoop].nLoop; i++)
{
//FBlock[bIndex].child = ??
//FBlock[bIndex].depth = ??
clsHWLS.FBLOCK.FBlock[bIndex].Entry = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].Entry;
clsHWLS.FBLOCK.FBlock[bIndex].Exit = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].Exit;
clsHWLS.FBLOCK.FBlock[bIndex].nEntry = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].nEntry;
clsHWLS.FBLOCK.FBlock[bIndex].nExit = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].nExit;
clsHWLS.FBLOCK.FBlock[bIndex].Node = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].Node;
clsHWLS.FBLOCK.FBlock[bIndex].nNode = clsLoop.Loop[clsLoop.newTempLoop].Loop[i].nNode;
//FBlock[bIndex].parentBlock = ??
clsHWLS.FBLOCK.FBlock[bIndex].SESE = false;
clsHWLS.FBLOCK.FBlock[bIndex].refIndex = i;
bIndex++;
}
}
clsHWLS.FBLOCK.nFBlock = bIndex;
//remove same block
check_Block_Same(ref clsHWLS);
//Find parent block
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
int j = find_nearestParentBlock(ref clsHWLS, i);
clsHWLS.FBLOCK.FBlock[i].parentBlock = j;
}
//find Children
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
int[] child_of_i = new int[clsHWLS.FBLOCK.nFBlock];
int nChild = 0;
for (int j = 0; j < clsHWLS.FBLOCK.nFBlock; j++)
{
if (clsHWLS.FBLOCK.FBlock[j].parentBlock == i)
{
child_of_i[nChild] = j;
nChild++;
}
}
clsHWLS.FBLOCK.FBlock[i].child = child_of_i;
clsHWLS.FBLOCK.FBlock[i].nChild = nChild;
}
//find Depth
clsHWLS.FBLOCK.maxDepth = 0;
//int maxDepth = 0;
int curDepth = 0;
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
curDepth = 1;
//FBLOCK.maxDepth = 1;
if (clsHWLS.FBLOCK.FBlock[i].parentBlock != -1)
{
continue;
}
clsHWLS.FBLOCK.FBlock[i].depth = curDepth;
find_BlockDepth(ref clsHWLS, i, ref curDepth);
}
if (clsHWLS.FBLOCK.nFBlock > 0 && clsHWLS.FBLOCK.maxDepth == 0)
{
clsHWLS.FBLOCK.maxDepth = 1;
}
}
//Get concurrency combination of IL<entries> from their CID (Output => SubNet)
public static void check_Concurrency(ref GraphVariables.clsGraph graph, int currentN, int conNet, int subNet, GraphVariables.clsLoop clsLoop, int workLoop, int loop, ref GraphVariables.clsSESE clsSESE)
{
Initialize_All();
//make_ConcurrencyFlow
graph.Network[conNet] = graph.Network[currentN]; //CIDFlow begining is stored in conNet (Network[8])
gProAnalyzer.Ultilities.extendGraph.full_extentNetwork(ref graph, conNet, 0, 0);
gProAnalyzer.Ultilities.copyLoop.copy_Loop(ref clsLoop, workLoop, clsLoop.tempLoop);
//reduce all loop except "loop" and its parents. (Applied NEW TYPE OF IL REDUCTION) ==>> REDUCE SAME DEPTH??? => ITS OK!!
gProAnalyzer.Ultilities.reduceGraph.Preprocessing_total_reduceSubgraph(ref graph, conNet, clsLoop, workLoop, loop);
//make DFlow() + CID in this procedure.
gProAnalyzer.Ultilities.makeSubNetwork.make_subNetwork(ref graph, conNet, subNet, ref clsLoop, clsLoop.tempLoop, loop, ref clsSESE, "CC", -1); //find concurrency set
//============ (by pass) using "CC" subgraph to find other parameter (just lazy) ==============
DFlow_IL_Flow = null;
nNodeDFlow_IL = 0;
expand_DFlow_IL_Flow = null; //combine DFlow+IL and expand nested loops (if any)
expand_nNodeDFlow_IL = 0;
DFlow = null;
nDFlow = 0;
expand_DFlow = null;
expand_nDFlow = 0;
orgCID = getCID_IL(graph, conNet, clsLoop, workLoop, loop); //CID of original graph index (All entries)
expand_boundaryNodes = getBoundaryNode(graph, conNet, subNet, clsLoop, workLoop, loop, ref expand_DFlow_IL_Flow, ref expand_nNodeDFlow_IL, ref expand_DFlow, ref expand_nDFlow, true);
boundaryNodes = getBoundaryNode(graph, conNet, subNet, clsLoop, workLoop, loop, ref DFlow_IL_Flow, ref nNodeDFlow_IL, ref DFlow, ref nDFlow, false);
//==============================================================================================
gProAnalyzer.Ultilities.makeSubNetwork.make_subGraph_DFlow(ref graph, conNet, subNet, ref clsLoop, clsLoop.tempLoop, loop, DFlow, nDFlow, boundaryNodes, orgCID); //subgraph contains DFlow + boundaryNode
//========>>>>> NEED FIX THE CONCURRENT ENTRY SET IDENTIFICATION => Recording all set, not optimize anything
make_ConcurrencyInstance(graph, subNet, ref clsLoop, clsLoop.tempLoop, loop); //find concurrency entry sets using DFlow() => store in clsLoop.
//========>>>>> MUST FIX <<<<<============
//some ERRORS here, check it for QUERY paper (Next paper)
make_ConcurrencyInstance_Untangling(ref graph, subNet, ref clsLoop, clsLoop.tempLoop, loop); //find the instanceNode to each concurrencySet => store in clsLoop also
//copy concurrency inform =============== THIS IS FOR THE VERIFICATION PAPER ONLY
clsLoop.Loop[workLoop].Loop[loop].nConcurrency = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].nConcurrency; //tranfer all the concurrency value from tempLoop [3] to workloop [2]
if (clsLoop.Loop[clsLoop.tempLoop].Loop[loop].Concurrency != null)
{
clsLoop.Loop[workLoop].Loop[loop].Concurrency = new int[clsLoop.Loop[workLoop].Loop[loop].nEntry];
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[loop].nEntry; k++)
{
clsLoop.Loop[workLoop].Loop[loop].Concurrency[k] = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].Concurrency[k];
}
}
//copy InstanceNode_DFlow to workLoop - Concurrent Entry
clsLoop.Loop[workLoop].Loop[loop].nConcurrInst = new int[clsLoop.Loop[clsLoop.tempLoop].Loop[loop].nConcurrInst.Length]; //tranfer all the concurrency value from tempLoop [3] to workloop [2]
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nConcurrInst.Length; i++)
{
clsLoop.Loop[workLoop].Loop[loop].nConcurrInst[i] = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].nConcurrInst[i];
}
if (clsLoop.Loop[clsLoop.tempLoop].Loop[loop].concurrInst != null)
{
clsLoop.Loop[workLoop].Loop[loop].concurrInst = new int[clsLoop.Loop[workLoop].Loop[loop].nConcurrInst.Length][];
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[loop].nConcurrInst.Length; k++)
{
if (clsLoop.Loop[clsLoop.tempLoop].Loop[loop].concurrInst[k] == null)
{
continue;
}
clsLoop.Loop[workLoop].Loop[loop].concurrInst[k] = new int[clsLoop.Loop[clsLoop.tempLoop].Loop[loop].concurrInst[k].Length];
for (int l = 0; l < clsLoop.Loop[workLoop].Loop[loop].nConcurrInst[k]; l++)
{
clsLoop.Loop[workLoop].Loop[loop].concurrInst[k][l] = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].concurrInst[k][l];
}
}
}
//copy InstanceNode_DFlow to workLoop - Exclusive entries
clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst = new int[clsLoop.Loop[clsLoop.tempLoop].Loop[loop].nExclusiveInst.Length]; //tranfer all the concurrency value from tempLoop [3] to workloop [2]
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst.Length; i++)
{
clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst[i] = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].nExclusiveInst[i];
}
if (clsLoop.Loop[clsLoop.tempLoop].Loop[loop].exclusiveInst != null)
{
clsLoop.Loop[workLoop].Loop[loop].exclusiveInst = new int[clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst.Length][];
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst.Length; k++)
{
if (clsLoop.Loop[clsLoop.tempLoop].Loop[loop].exclusiveInst[k] == null)
{
continue;
}
clsLoop.Loop[workLoop].Loop[loop].exclusiveInst[k] = new int[clsLoop.Loop[clsLoop.tempLoop].Loop[loop].exclusiveInst[k].Length];
for (int l = 0; l < clsLoop.Loop[workLoop].Loop[loop].nExclusiveInst[k]; l++)
{
clsLoop.Loop[workLoop].Loop[loop].exclusiveInst[k][l] = clsLoop.Loop[clsLoop.tempLoop].Loop[loop].exclusiveInst[k][l];
}
}
}
//output is the model in Network.SUBNET
//output: Get Concurrency[] and ConcurrencyInst of DFlow().
}
public static void start_Indexing(ref GraphVariables.clsGraph graph, ref GraphVariables.clsHWLS clsHWLS, ref GraphVariables.clsHWLS clsHWLS_Untangle,
ref GraphVariables.clsLoop clsLoop, ref GraphVariables.clsSESE clsSESE, bool[] flag_Check)
{
Initialize_All();
gProAnalyzer.Functionalities.NodeSplittingType1.Run_Split_Type1(ref graph, graph.orgNet, graph.midNet);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, graph.midNet, ref clsLoop, clsLoop.orgLoop, ref clsLoop.IrreducibleError);
graph.Network[graph.finalNet] = graph.Network[graph.midNet];
gProAnalyzer.Functionalities.NodeSplittingType2.Run_Split_Type2(ref graph, graph.midNet, graph.finalNet, ref clsLoop, clsLoop.orgLoop);
gProAnalyzer.Functionalities.DominanceIdentification.find_Dom(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_Pdom(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_DomEI(ref graph, graph.finalNet, -2);
gProAnalyzer.Functionalities.DominanceIdentification.find_PdomEI(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.SESEIdentification.find_SESE_WithLoop(ref graph, graph.finalNet, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE, -2);
gProAnalyzer.Functionalities.NodeSplittingType3.Run_Split_Type3(ref graph, graph.finalNet, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE, true);
//Make nesting forest
gProAnalyzer.Ultilities.makeNestingForest.make_NestingForest(ref graph, graph.finalNet, ref clsHWLS, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE);
int workNet = graph.finalNet;
int workLoop = clsLoop.orgLoop;
int workSESE = clsSESE.finalSESE;
bool checkUntangle = false;
//Untangling of Irreducible loops ==> USING UNTANGLE NET only (new graph)
if (gProAnalyzer.Functionalities.UntanglingIL.make_UntanglingIL(ref graph, graph.finalNet, graph.untangleNet, clsHWLS, clsLoop, clsLoop.orgLoop, clsSESE, clsSESE.finalSESE))
{
//return;
//frmAnl.displayProcessModel(ref graph, graph.untangleNet, ref clsLoop, -1, ref clsSESE, -1);
//frmAnl.Show();
//return;
gProAnalyzer.Functionalities.NodeSplittingType1.Run_Split_Type1(ref graph, graph.untangleNet, graph.midNet);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, graph.midNet, ref clsLoop, clsLoop.untangleLoop, ref clsLoop.IrreducibleError);
gProAnalyzer.Functionalities.NodeSplittingType2.Run_Split_Type2(ref graph, graph.midNet, graph.untangleNet, ref clsLoop, clsLoop.untangleLoop);
gProAnalyzer.Functionalities.DominanceIdentification.find_Dom(ref graph, graph.untangleNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_Pdom(ref graph, graph.untangleNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_DomEI(ref graph, graph.untangleNet, -2);
gProAnalyzer.Functionalities.DominanceIdentification.find_PdomEI(ref graph, graph.untangleNet);
gProAnalyzer.Functionalities.SESEIdentification.find_SESE_WithLoop(ref graph, graph.untangleNet, ref clsLoop, clsLoop.untangleLoop, ref clsSESE, clsSESE.untangleSESE, -2);
gProAnalyzer.Functionalities.NodeSplittingType3.Run_Split_Type3(ref graph, graph.untangleNet, ref clsLoop, clsLoop.untangleLoop, ref clsSESE, clsSESE.untangleSESE, true);
gProAnalyzer.Ultilities.makeNestingForest.make_NestingForest(ref graph, graph.untangleNet, ref clsHWLS_Untangle, ref clsLoop, clsLoop.untangleLoop, ref clsSESE, clsSESE.untangleSESE);
workNet = graph.untangleNet;
workLoop = clsLoop.untangleLoop;
workSESE = clsSESE.untangleSESE;
checkUntangle = true;
graph.check_untangle = true;
//frmAnl.displayProcessModel(ref graph, graph.untangleNet, ref clsLoop, clsLoop.untangleLoop, ref clsSESE, clsSESE.untangleSESE);
//frmAnl.Show();
}
//== get initial behavior profile ==
graph.Network[graph.reduceNet] = graph.Network[workNet];
gProAnalyzer.Ultilities.extendGraph.full_extentNetwork(ref graph, graph.reduceNet, 0, 0);
if (checkUntangle)
{
get_InitialBehaviorProfile(ref graph, graph.reduceNet, ref clsHWLS_Untangle, ref clsLoop, workLoop, ref clsSESE, workSESE, flag_Check);
}
else
{
get_InitialBehaviorProfile(ref graph, graph.reduceNet, ref clsHWLS, ref clsLoop, workLoop, ref clsSESE, workSESE, flag_Check);
}
//Database storing
}
//Build behavior profile for each header of each decomposed acyclic structure. each matrix for each pair?
public static void get_InitialBehaviorProfile(ref GraphVariables.clsGraph graph, int currentN, ref GraphVariables.clsHWLS clsHWLS,
ref GraphVariables.clsLoop clsLoop, int workLoop, ref GraphVariables.clsSESE clsSESE, int workSESE, bool[] flag_Check)
{
//input: a decomposed DAG
//output: behavior profile of it header and its children
//makeSubNetwork of clsDASPT
//make instantFlow (AnalyseBehavior_InstF) of HEADER and its childs.
//create behaviorProfile matrix for HEADER
Initialize_All();
//bool[] flag_Check = new bool[8];
int curDepth = clsHWLS.FBLOCK.maxDepth;
//curDepth = 1;
do
{
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
if (clsHWLS.FBLOCK.FBlock[i].depth != curDepth)
{
continue;
}
int orgIndx = clsHWLS.FBLOCK.FBlock[i].refIndex;
//If SESE => Make subnetwork and find Dominator Behavior relation matrix (1 matrix)
if (clsHWLS.FBLOCK.FBlock[i].SESE)
{
//Make subnet
gProAnalyzer.Ultilities.makeSubNetwork.make_subNetwork(ref graph, currentN, graph.subNet, ref clsLoop, workSESE, orgIndx, ref clsSESE, "SESE", -1);
int nNode = graph.Network[graph.subNet].nNode;
int x = graph.Network[graph.subNet].Node[graph.Network[graph.subNet].header].Post[0];
bool[] returnBhPrfl = new bool[8];
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl = new int[9, nNode + 1];
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl[0, 0] = graph.Network[graph.subNet].Node[x].orgNum; //ENTRY SESE org index.
clsHWLS.FBLOCK.FBlock[i].nDomBh = 1;
//get behavior matrix of SESE ENTRY
for (int j = 0; j < graph.Network[graph.subNet].nNode; j++)
{
int y = j;
if (x == y || graph.Network[graph.subNet].Node[x].orgNum == -1)
{
continue; //Exclude VS, VE
}
gProAnalyzer.Ultilities.AnalyseBehavior_InstF.check_InstanceBehavior(graph, graph.subNet, x, y, ref returnBhPrfl, flag_Check);
store_BehaviorProfile(ref clsHWLS, i, graph.Network[graph.subNet].Node[x].orgNum, graph.Network[graph.subNet].Node[y].orgNum, returnBhPrfl, true);
}
//reduce current Block LASTLY (already imply by depth pick)
gProAnalyzer.Ultilities.reduceGraph.reduce_SESE(ref graph, currentN, clsSESE, workSESE, orgIndx);
}
//If NL => Make subnetwork and find Dom/ Pdom Behavior relation matrix (2 matrices)
if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndx].nEntry == 1)
{
//Make subnet
gProAnalyzer.Ultilities.makeSubNetwork.make_AcyclicSubGraph(ref graph, currentN, graph.subNet, ref clsLoop, workLoop, orgIndx, "NL");
int nNode = graph.Network[graph.subNet].nNode;
int x, y;
//get behavior matrix of HEADER ENTRY and its childs
x = graph.Network[graph.subNet].Node[graph.Network[graph.subNet].header].Post[0]; //Get NL Loop HEADER
bool[] returnBhPrfl = new bool[8];
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl = new int[9, nNode + 2]; //store itself behavior
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl[0, 0] = graph.Network[graph.subNet].Node[x].orgNum; //Header org index.
clsHWLS.FBLOCK.FBlock[i].nDomBh = 1;
for (int j = 0; j < graph.Network[graph.subNet].nNode; j++)
{
y = j;
if (x == y || graph.Network[graph.subNet].Node[x].orgNum == -1)
{
continue;
}
gProAnalyzer.Ultilities.AnalyseBehavior_InstF.check_InstanceBehavior(graph, graph.subNet, x, y, ref returnBhPrfl, flag_Check);
store_BehaviorProfile(ref clsHWLS, i, graph.Network[graph.subNet].Node[x].orgNum, graph.Network[graph.subNet].Node[y].orgNum, returnBhPrfl, true);
}
//get behavior matrix of Its childs and HEADER (Pdom)
y = get_NodeByName(graph, graph.subNet, "V_HEADER");
if (y == -1)
{
continue;
}
returnBhPrfl = new bool[8];
clsHWLS.FBLOCK.FBlock[i].Pdom_BhPrfl = new int[9, nNode + 2];
clsHWLS.FBLOCK.FBlock[i].Pdom_BhPrfl[0, 0] = graph.Network[graph.subNet].Node[y].orgNum; //Header index.
clsHWLS.FBLOCK.FBlock[i].nPdomBh = 1;
for (int j = 0; j < graph.Network[graph.subNet].nNode; j++)
{
x = j;
if (x == y || graph.Network[graph.subNet].Node[x].orgNum == -1)
{
continue;
}
gProAnalyzer.Ultilities.AnalyseBehavior_InstF.check_InstanceBehavior(graph, graph.subNet, x, y, ref returnBhPrfl, flag_Check);
store_BehaviorProfile(ref clsHWLS, i, graph.Network[graph.subNet].Node[y].orgNum, graph.Network[graph.subNet].Node[x].orgNum, returnBhPrfl, false);
}
//reduce current Block (NL)
gProAnalyzer.Ultilities.reduceGraph.reduce_Loop(ref graph, currentN, ref clsLoop, workLoop, orgIndx, "", false);
}
//if IL => Find CIPd => Make subnetwork with CIPd and find Dom/ Pdom Behavior relation matrix (2 matrices)
if (clsHWLS.FBLOCK.FBlock[i].SESE == false && clsLoop.Loop[workLoop].Loop[orgIndx].nEntry > 1)
{
//Make subnet
gProAnalyzer.Ultilities.makeSubNetwork.make_AcyclicSubGraph(ref graph, currentN, graph.subNet, ref clsLoop, workLoop, orgIndx, "IL");
int nNode = graph.Network[graph.subNet].nNode;
int x, y;
//get behavior matrix of HEADER ENTRY and its childs
x = graph.Network[graph.subNet].Node[graph.Network[graph.subNet].header].Post[0]; //Get CIPd of IL
clsHWLS.FBLOCK.FBlock[i].CIPd = graph.Network[graph.subNet].Node[x].orgNum;
bool[] returnBhPrfl = new bool[8];
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl = new int[9, nNode + 2]; //store itself behavior
clsHWLS.FBLOCK.FBlock[i].Dom_BhPrfl[0, 0] = graph.Network[graph.subNet].Node[x].orgNum; //CIPd org index.
clsHWLS.FBLOCK.FBlock[i].nDomBh = 1;
for (int j = 0; j < graph.Network[graph.subNet].nNode; j++)
{
y = j;
if (x == y || graph.Network[graph.subNet].Node[x].orgNum == -1)
{
continue;
}
gProAnalyzer.Ultilities.AnalyseBehavior_InstF.check_InstanceBehavior(graph, graph.subNet, x, y, ref returnBhPrfl, flag_Check);
store_BehaviorProfile(ref clsHWLS, i, graph.Network[graph.subNet].Node[x].orgNum, graph.Network[graph.subNet].Node[y].orgNum, returnBhPrfl, true);
}
//combine from CID(x, y) ==>> MISSING => SOLVED (no need)
//get behavior matrix of Its childs and HEADER (Pdom)
y = get_NodeByName(graph, graph.subNet, "V_CIPd");
if (y == -1)
{
continue;
}
returnBhPrfl = new bool[8];
clsHWLS.FBLOCK.FBlock[i].Pdom_BhPrfl = new int[9, nNode + 2];
clsHWLS.FBLOCK.FBlock[i].Pdom_BhPrfl[0, 0] = graph.Network[graph.subNet].Node[y].orgNum; //Header index.
clsHWLS.FBLOCK.FBlock[i].nPdomBh = 1;
for (int j = 0; j < graph.Network[graph.subNet].nNode; j++)
{
x = j;
if (x == y || graph.Network[graph.subNet].Node[x].orgNum == -1)
{
continue;
}
gProAnalyzer.Ultilities.AnalyseBehavior_InstF.check_InstanceBehavior(graph, graph.subNet, x, y, ref returnBhPrfl, flag_Check);
store_BehaviorProfile(ref clsHWLS, i, graph.Network[graph.subNet].Node[y].orgNum, graph.Network[graph.subNet].Node[x].orgNum, returnBhPrfl, false);
}
//combine from CID(x, y) ==>> MISSING => SOLVED (no need)
//reduce current Block (IL)
gProAnalyzer.Ultilities.reduceGraph.reduce_IrLoop(ref graph, currentN, clsLoop, workLoop, orgIndx);
}
}
curDepth--;
} while (curDepth > 0);
}
public static void start_Indexing_Acyclic(ref GraphVariables.clsGraph graph, ref GraphVariables.clsHWLS clsHWLS, ref GraphVariables.clsHWLS clsHWLS_Untangle,
ref GraphVariables.clsLoop clsLoop, ref GraphVariables.clsSESE clsSESE, bool[] flag_Check)
{
Initialize_All();
gProAnalyzer.Functionalities.NodeSplittingType1.Run_Split_Type1(ref graph, graph.orgNet, graph.midNet);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, graph.midNet, ref clsLoop, clsLoop.orgLoop, ref clsLoop.IrreducibleError);
graph.Network[graph.finalNet] = graph.Network[graph.midNet];
gProAnalyzer.Functionalities.NodeSplittingType2.Run_Split_Type2(ref graph, graph.midNet, graph.finalNet, ref clsLoop, clsLoop.orgLoop);
gProAnalyzer.Functionalities.DominanceIdentification.find_Dom(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_Pdom(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.DominanceIdentification.find_DomEI(ref graph, graph.finalNet, -2);
gProAnalyzer.Functionalities.DominanceIdentification.find_PdomEI(ref graph, graph.finalNet);
gProAnalyzer.Functionalities.SESEIdentification.find_SESE_WithLoop(ref graph, graph.finalNet, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE, -2);
gProAnalyzer.Functionalities.NodeSplittingType3.Run_Split_Type3(ref graph, graph.finalNet, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE, true);
//Make nesting forest
gProAnalyzer.Ultilities.makeNestingForest.make_NestingForest(ref graph, graph.finalNet, ref clsHWLS, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE);
GraphVariables.clsError clsError = new gProAnalyzer.GraphVariables.clsError();
//Fix each SOS entry for Bond and Rigid
gProAnalyzer.Functionalities.VerificationG.Initialize_Verification(ref graph, ref clsError, ref clsLoop, ref clsSESE, ref clsHWLS);
//verify bond first =>>
int workNet = graph.finalNet;
int workLoop = clsLoop.orgLoop;
int workSESE = clsSESE.finalSESE;
//== get initial behavior profile ==
graph.Network[graph.reduceNet] = graph.Network[workNet];
gProAnalyzer.Ultilities.extendGraph.full_extentNetwork(ref graph, graph.reduceNet, 0, 0);
get_InitialBehaviorProfile(ref graph, graph.reduceNet, ref clsHWLS, ref clsLoop, workLoop, ref clsSESE, workSESE, flag_Check);
//Database storing
}
public static string Bond_Check(ref GraphVariables.clsGraph graph, int currentN, ref GraphVariables.clsSESE clsSESE, int workSESE, int currentSESE, ref GraphVariables.clsHWLS clsHWLS) //should upgrade bond check ===
{
int count_gateway = 0;
//check SESE nested with Loops (2 cases) (if SESE have at least 1 directly child is loop => rigid.
int f_index = getFblockIndex(currentSESE, clsHWLS);
for (int i = 0; i < clsHWLS.FBLOCK.FBlock[f_index].nChild; i++)
{
int child = clsHWLS.FBLOCK.FBlock[f_index].child[i];
if (clsHWLS.FBLOCK.FBlock[child].SESE == false && !(clsHWLS.FBLOCK.FBlock[child].nEntry == 1 && clsHWLS.FBLOCK.FBlock[child].nExit == 1))
{
return("R");
}
}
for (int i = 0; i < clsSESE.SESE[workSESE].SESE[currentSESE].nNode; i++)
{
int node = clsSESE.SESE[workSESE].SESE[currentSESE].Node[i];
if (Node_In_SESE(clsSESE, workSESE, node, currentSESE))
{
if (graph.Network[currentN].Node[node].nPre > 1 || graph.Network[currentN].Node[node].nPost > 1)
{
count_gateway++;
if (count_gateway > 2)
{
return("R");
}
}
}
}
if (count_gateway == 0)
{
return("P");
}
return("B");
}
public static bool make_UntanglingIL(ref GraphVariables.clsGraph graph, int currentN, int untangleNet, GraphVariables.clsHWLS clsHWLS, GraphVariables.clsLoop clsLoop, int workLoop,
GraphVariables.clsSESE clsSESE, int workSESE)
{
Initialize_All();
bool existUntangle = false;
//scan for all IL and analyze at the lowest lever first.
graph.Network[untangleNet] = graph.Network[currentN];
gProAnalyzer.Ultilities.extendGraph.full_extentNetwork(ref graph, untangleNet, 0, 0); //now work in untangleNet
gProAnalyzer.Ultilities.copyLoop.copy_Loop(ref clsLoop, workLoop, clsLoop.untangleLoop);
int curDepth = clsHWLS.FBLOCK.maxDepth;
do
{
for (int i = 0; i < clsHWLS.FBLOCK.nFBlock; i++)
{
if (clsHWLS.FBLOCK.FBlock[i].depth != curDepth || clsHWLS.FBLOCK.FBlock[i].nEntry == 1)
{
continue; //only get IL
}
int orgLoopIndx = clsHWLS.FBLOCK.FBlock[i].refIndex;
int newLoopIndx = find_newLoopIndex(graph, untangleNet, clsLoop, workLoop, clsLoop.untangleLoop, orgLoopIndx);
gProAnalyzer.Ultilities.findConcurrencyEntriesIL.check_Concurrency(ref graph, untangleNet, graph.conNet, graph.subNet, clsLoop, clsLoop.untangleLoop, newLoopIndx, ref clsSESE); //concurrency[] and concurrencyInst[] were found in clsLoop.
//find CID again =>
int CID = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.orgCID;
//we can access searchNode[] in fndConcurrencyIL to get DF => then find boundaries nodes of current IL
int[] DFlow_IL_Flow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.DFlow_IL_Flow;;
int nNodeDFlow_IL = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.nNodeDFlow_IL;
int[] expand_DFlow_IL_Flow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.expand_DFlow_IL_Flow;
int expand_nNodeDFlow_IL = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.expand_nNodeDFlow_IL;
int[] DFlow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.DFlow;
int nDFlow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.nDFlow;
int[] expand_DFlow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.expand_DFlow;
int expand_nDFlow = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.expand_nDFlow;
int[] boundaryNodes = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.boundaryNodes;//get the boundaryNode of currentN graph.
int[] expand_boundaryNode = gProAnalyzer.Ultilities.findConcurrencyEntriesIL.expand_boundaryNodes;
//check whether need to untangle the IL or not? => if need -> next step (Check PdFlow? also)
if (!check_UntanglingIL(clsLoop, clsLoop.untangleLoop, newLoopIndx))
{
continue;
}
graph.Network[graph.nickNet] = graph.Network[untangleNet];
gProAnalyzer.Ultilities.extendGraph.full_extentNetwork(ref graph, graph.nickNet, 0, 0); //Using NICKNET for reference of Link
remove_DFlow_IL(ref graph, untangleNet, ref clsLoop, clsLoop.untangleLoop, newLoopIndx, expand_boundaryNode, CID, expand_DFlow_IL_Flow, expand_nNodeDFlow_IL); //must use expand version
//Next: make_subNet of new Untangling subGraph based on concurrencyInst[] of current IL
//Next: plug into original network + expand loops in DFlow (if any) - links/ edges' index should be modified also
gProAnalyzer.Ultilities.makeSubNetwork.combine_subGraph_Untangling(ref graph, graph.nickNet, untangleNet, graph.conNet, graph.subNet, graph.dummyNet, clsLoop, clsLoop.untangleLoop, newLoopIndx,
expand_boundaryNode, boundaryNodes, CID); //using subNet as referrence (also //Using NICKNET for reference of Link)
//return true;
//final step => polishing the subgraph by removing some unnecessary node (gateways only have 1 incoming/ outgoing edge?)
//remove disconnected nodes (~ mark Done = true)
removing_disconnectedNode(ref graph, untangleNet);
existUntangle = true; //At least done 1 untangle of 1 IL
//return true;;
for (int k = 0; k < graph.Network[untangleNet].nNode; k++)
{
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, untangleNet, k);
}
gProAnalyzer.Functionalities.NodeSplittingType1.Run_Split_Type1(ref graph, graph.untangleNet, graph.midNet);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, graph.midNet, ref clsLoop, clsLoop.untangleLoop, ref clsLoop.IrreducibleError);
gProAnalyzer.Functionalities.NodeSplittingType2.Run_Split_Type2(ref graph, untangleNet, graph.untangleNet, ref clsLoop, clsLoop.untangleLoop);
}
curDepth--;
} while (curDepth > 0);
//find PRE/POST DOM/ PDOM + LOOP + SESE + Node splitting again
for (int i = 0; i < graph.Network[untangleNet].nNode; i++)
{
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, untangleNet, i);
}
return(existUntangle);
}
