public static bool Node_In_Loop(gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int node, int loop) //node in loop => return true; not in loop => return false
{
bool inLoop = false;
if (node == clsLoop.Loop[workLoop].Loop[loop].header)
{
inLoop = true;
}
else
{
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nNode; i++)
{
if (node == clsLoop.Loop[workLoop].Loop[loop].Node[i])
{
inLoop = true;
break;
}
}
}
if (!inLoop)
{
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nChild; i++)
{
inLoop = Node_In_Loop(clsLoop, workLoop, node, clsLoop.Loop[workLoop].Loop[loop].child[i]);
if (inLoop)
{
break;
}
}
}
return(inLoop);
}
public static void Loop_Inform(ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int rNode, int node, int loop)
{
//포함 노드 수정
int nNew = clsLoop.Loop[workLoop].Loop[loop].nNode + 1;
int[] New = new int[nNew];
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nNode; i++)
{
New[i] = clsLoop.Loop[workLoop].Loop[loop].Node[i];
}
New[nNew - 1] = node;
clsLoop.Loop[workLoop].Loop[loop].nNode = nNew;
clsLoop.Loop[workLoop].Loop[loop].Node = New;
//entry 수정
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nEntry; i++)
{
if (clsLoop.Loop[workLoop].Loop[loop].Entry[i] == rNode)
{
clsLoop.Loop[workLoop].Loop[loop].Entry[i] = node;
}
}
//exit 수정
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[loop].nExit; i++)
{
if (clsLoop.Loop[workLoop].Loop[loop].Exit[i] == rNode)
{
clsLoop.Loop[workLoop].Loop[loop].Exit[i] = node;
}
}
}
public static bool isLoopHeader(ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workloop, int node) //check "node" is header (reduced (if any) or not
{
for (int i = 0; i < clsLoop.Loop[workloop].nLoop; i++)
{
if (clsLoop.Loop[workloop].Loop[i].header == node)
{
return(true);
}
}
return(false);
}
public frmSplitModels_Rigids()
{
InitializeComponent();
graph = new gProAnalyzer.GraphVariables.clsGraph();
clsSESE = new gProAnalyzer.GraphVariables.clsSESE();
clsLoop = new gProAnalyzer.GraphVariables.clsLoop();
clsHWLS = new gProAnalyzer.GraphVariables.clsHWLS();
clsError = new gProAnalyzer.GraphVariables.clsError();
loadGraph = new gProAnalyzer.Preprocessing.clsLoadGraph();
runSESE = new gProAnalyzer.Run_Analysis_SESE();
runVerification = new gProAnalyzer.Run_Analysis_Verification();
}
public static void find_LoopNode(ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop, int kLoop)
{
for (int i = 0; i < loop.Loop[workLoop].Loop[kLoop].nNode; i++)
{
searchNode[nSearchNode] = loop.Loop[workLoop].Loop[kLoop].Node[i];
nSearchNode++;
}
for (int k = 0; k < loop.Loop[workLoop].Loop[kLoop].nChild; k++)
{
find_LoopNode(ref loop, workLoop, loop.Loop[workLoop].Loop[kLoop].child[k]);
}
}
public frmBasicSimulation()
{
loadG = new Preprocessing.clsLoadGraph();
graph = new GraphVariables.clsGraph();
clsLoop = new GraphVariables.clsLoop();
clsSESE = new GraphVariables.clsSESE();
clsHWLS = new gProAnalyzer.GraphVariables.clsHWLS();
clsError = new gProAnalyzer.GraphVariables.clsError();
test = new gProAnalyzer.Testing();
runVerification = new gProAnalyzer.Run_Analysis_Verification();
InitializeComponent();
}
public Dashboard_Experiment()
{
InitializeComponent();
loadG = new Preprocessing.clsLoadGraph();
graph = new GraphVariables.clsGraph();
clsLoop = new GraphVariables.clsLoop();
clsSESE = new GraphVariables.clsSESE();
clsHWLS = new gProAnalyzer.GraphVariables.clsHWLS();
clsError = new gProAnalyzer.GraphVariables.clsError();
runVerification = new gProAnalyzer.Run_Analysis_Verification();
progressBar1.Visible = false;
btnRun.Visible = false;
exportExcel.Visible = false;
}
public static bool isLoopExits(ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int curNode)
{
int numLoop = clsLoop.Loop[workLoop].nLoop;
for (int i = 0; i < numLoop; i++)
{
for (int j = 0; j < clsLoop.Loop[workLoop].Loop[i].nExit; j++)
{
if (clsLoop.Loop[workLoop].Loop[i].Exit[j] == curNode)
{
return(true);
}
}
}
return(false);
}
public static bool isLoopSingleExit(ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int curNode, int workLoop) //it mean this curNode must be single loop exit
{
int numLoop = clsLoop.Loop[workLoop].nLoop;
for (int i = 0; i < numLoop; i++)
{
if (clsLoop.Loop[workLoop].Loop[i].nExit == 1)
{
if (clsLoop.Loop[workLoop].Loop[i].Exit[0] == curNode)
{
return(true);
}
}
}
return(false);
}
public static void merge_Irreducible(ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop) //Otc27_2020 This might have some bugs
{
int curDepth = loop.Loop[workLoop].maxDepth;
do
{
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
if (loop.Loop[workLoop].Loop[i].depth != curDepth)
{
continue;
}
if (!loop.Loop[workLoop].Loop[i].Irreducible)
{
continue; //if it is natural loop => not merge
}
int parent = loop.Loop[workLoop].Loop[i].parentLoop;
if (parent < 0)
{
continue;
}
if (!loop.Loop[workLoop].Loop[parent].Irreducible)
{
continue;
}
//check different loop entries set? => If 2 IL Nested not having same set of entries => get it
if (!gProAnalyzer.Ultilities.checkGraph.check_Overlap(loop.Loop[workLoop].Loop[parent].Entry, loop.Loop[workLoop].Loop[i].Entry))
{
continue; //NEW CODE
}
merge_Loop(ref loop, workLoop, parent, i);
}
curDepth--;
} while (curDepth > 0);
loop.Loop[workLoop].maxDepth = 0;
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
if (loop.Loop[workLoop].Loop[i].depth > loop.Loop[workLoop].maxDepth)
{
loop.Loop[workLoop].maxDepth = loop.Loop[workLoop].Loop[i].depth;
}
}
}
public static void Run_Split_Type2(ref gProAnalyzer.GraphVariables.clsGraph graph, int midNet, int finalNet, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int orgLoop)
{
Initialize_All();
// Network(2) 생성후 작업
int nNode = graph.Network[midNet].nNode;
int nLink = graph.Network[midNet].nLink;
// 새네트워크 생성 (복제)
graph.Network[finalNet] = graph.Network[midNet];
//Loop없으면 건너뛰기
if (clsLoop.Loop[orgLoop].nLoop == 0)
{
gProAnalyzer.Preprocessing.clsExtendNetwork.extent_Network(ref graph, finalNet, 0);
return;
}
//Extent_network with the new number of node. (because we assign the fixed number of node of model when we read the model.
//For example: nNode = 10; nLink = 14 => after extent => nNode = 10 + 10 (nNode); nLink = 14 + 10 (nNode)
gProAnalyzer.Preprocessing.clsExtendNetwork.extent_Network(ref graph, finalNet, nNode);
//Extension Type II split in Entry of Loop => (2 new node and 2 new link maybe create)
int nSplit = Type_II_Split_Entry(ref graph, finalNet, ref clsLoop, orgLoop, nNode, nLink);
nNode += nSplit;
nLink += nSplit;
//we need identify the loop after split entry (extension)
//resize_Network(finalNet, nNode, nLink);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, finalNet, ref clsLoop, orgLoop, ref clsLoop.IrreducibleError); //===> Because the extension of type_2 create nodes inside the loops => we need add it into a Loop[] structure.
//extent_Network(finalNet, nNode);
nSplit = 0;
nSplit = Type_II_Split_Exit(ref graph, finalNet, ref clsLoop, orgLoop, nNode, nLink);
nNode += nSplit;
nLink += nSplit;
//fix CIPd Exit (Direct join of exits)
add_Dummy_Task(ref graph, finalNet, ref clsLoop, orgLoop, ref nNode, ref nLink);
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, finalNet, ref clsLoop, orgLoop, ref clsLoop.IrreducibleError);
nSplit = 0;
nSplit = Type_II_Split_Back(ref graph, finalNet, nNode, nLink); //(No split backward split)
nNode += nSplit;
nLink += nSplit;
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, finalNet, ref clsLoop, orgLoop, ref clsLoop.IrreducibleError);
resize_Network(ref graph, finalNet, nNode, nLink);
//After_Type_II_Split(ref graph, finalNet, ref clsLoop, orgLoop); //Remove on Otc27_2020 (Might turn back latter)
gProAnalyzer.Functionalities.LoopIdentification.Run_FindLoop(ref graph, finalNet, ref clsLoop, orgLoop, ref clsLoop.IrreducibleError);
}
public static void merge_Loop(ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop, int parent, int child)
{
//loop포함 노드
int nNewNode = loop.Loop[workLoop].Loop[parent].nNode + loop.Loop[workLoop].Loop[child].nNode;
int[] newNode = new int[nNewNode];
nNewNode = 0;
for (int i = 0; i < loop.Loop[workLoop].Loop[parent].nNode; i++)
{
newNode[nNewNode] = loop.Loop[workLoop].Loop[parent].Node[i];
nNewNode++;
}
for (int i = 0; i < loop.Loop[workLoop].Loop[child].nNode; i++)
{
newNode[nNewNode] = loop.Loop[workLoop].Loop[child].Node[i];
nNewNode++;
}
loop.Loop[workLoop].Loop[parent].nNode = nNewNode;
loop.Loop[workLoop].Loop[parent].Node = newNode;
// loop child loop
int nNewChild = loop.Loop[workLoop].Loop[parent].nChild - 1; //PROBLEM HERE
nNewChild = loop.Loop[workLoop].Loop[child].nChild; //NEW CODE to store it child of child
int[] newChild = new int[nNewChild];
nNewChild = 0;
for (int i = 0; i < loop.Loop[workLoop].Loop[parent].nChild; i++)
{
if (loop.Loop[workLoop].Loop[parent].child[i] == child)
{
continue;
}
newChild[nNewChild] = loop.Loop[workLoop].Loop[parent].child[i];
nNewChild++;
}
//add child_loop of its child
for (int i = 0; i < loop.Loop[workLoop].Loop[child].nChild; i++)
{
newChild[nNewChild] = loop.Loop[workLoop].Loop[child].child[i];
nNewChild++;
}
loop.Loop[workLoop].Loop[parent].nChild = nNewChild;
loop.Loop[workLoop].Loop[parent].child = newChild;
//child loop 제거 (Remove child loop)
gProAnalyzer.GraphVariables.clsLoop.strLoopInform[] newLoop = new gProAnalyzer.GraphVariables.clsLoop.strLoopInform[loop.Loop[workLoop].nLoop - 1];
int nNewLoop = 0;
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
if (i == child)
{
continue;
}
newLoop[nNewLoop] = loop.Loop[workLoop].Loop[i];
nNewLoop++;
}
loop.Loop[workLoop].nLoop = nNewLoop;
loop.Loop[workLoop].Loop = newLoop;
//child reNumbering
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
for (int k = 0; k < loop.Loop[workLoop].Loop[i].nChild; k++)
{
if (loop.Loop[workLoop].Loop[i].child[k] >= child)
{
loop.Loop[workLoop].Loop[i].child[k] -= 1;
}
}
}
//parent reNumbering
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
if (loop.Loop[workLoop].Loop[i].parentLoop >= child)
{
loop.Loop[workLoop].Loop[i].parentLoop -= 1;
}
}
}
public static int Type_II_Split_Exit(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int nNode, int nLink)
{
int nSplit = 0;
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++)
{
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nExit; k++)
{
int node = clsLoop.Loop[workLoop].Loop[i].Exit[k];
int[] postF = new int[nNode];
int[] postB = new int[nNode];
int cntF = 0, cntB = 0;
for (int j = 0; j < nLink; j++)
{
if (graph.Network[currentN].Link[j].fromNode == node)
{
if (gProAnalyzer.Ultilities.findNodeInLoop.Node_In_Loop(ref clsLoop, workLoop, graph.Network[currentN].Link[j].toNode, i))
{
postB[cntB] = graph.Network[currentN].Link[j].toNode;
cntB++;
}
else
{
postF[cntF] = graph.Network[currentN].Link[j].toNode;
cntF++;
}
}
}
if (cntF > 1) // For join이 2 미만이면
{
int fsNode = nNode;
int bsNode = node;
//For Spilt Node - 추가
graph.Network[currentN].Node[fsNode].Kind = graph.Network[currentN].Node[node].Kind;
graph.Network[currentN].Node[fsNode].Name = graph.Network[currentN].Node[node].Name;// node.ToString();
graph.Network[currentN].Node[fsNode].orgNum = node;
graph.Network[currentN].Node[fsNode].parentNum = fsNode;
graph.Network[currentN].Node[fsNode].Type_I = graph.Network[currentN].Node[node].Type_I;
graph.Network[currentN].Node[fsNode].Type_II = graph.Network[currentN].Node[node].Type_II + "_xfs";
graph.Network[currentN].Node[fsNode].Special = "";
//Back Spilt Node - 변경
graph.Network[currentN].Node[bsNode].Type_II = graph.Network[currentN].Node[node].Type_II + "_xbs";
//New Link 추가
graph.Network[currentN].Link[nLink].fromNode = bsNode;
graph.Network[currentN].Link[nLink].toNode = fsNode;
nSplit++;
nNode++;
nLink++;
//기존 Link 정보 변경
for (int j = 0; j < nLink; j++)
{
for (int j2 = 0; j2 < cntF; j2++)
{
if (graph.Network[currentN].Link[j].fromNode == node && graph.Network[currentN].Link[j].toNode == postF[j2])
{
graph.Network[currentN].Link[j].fromNode = fsNode;
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, graph.Network[currentN].Link[j].toNode);
}
}
}
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, fsNode);
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, bsNode);
if (clsLoop.Loop[workLoop].Loop[i].parentLoop >= 0)
{
Loop_Inform(ref clsLoop, workLoop, node, fsNode, clsLoop.Loop[workLoop].Loop[i].parentLoop);
}
}
//Extention Type 2 Exit
//Type_II_Extension_Exit(currentN, workLoop, i, nNode, nLink, node, ref nSplit, postB, cntB);
}
}
return(nSplit);
}
public static void inspect_Irreducible(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop)
{
int curDepth = 1;
do
{
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++)
{
if (clsLoop.Loop[workLoop].Loop[i].depth != curDepth)
{
continue;
}
if (!clsLoop.Loop[workLoop].Loop[i].Irreducible)
{
continue;
}
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nEntry; k++)
{
if (clsLoop.Loop[workLoop].Loop[i].Entry[k] == clsLoop.Loop[workLoop].Loop[i].header)
{
continue;
}
gProAnalyzer.Ultilities.makeSubNetwork.make_subNetwork(ref graph, currentN, graph.subNet, ref clsLoop, workLoop, i, ref clsSESE, "II", clsLoop.Loop[workLoop].Loop[i].Entry[k]); //5는 SubNetwork
add_subNatural(ref graph, graph.subNet, currentN, ref clsLoop, clsLoop.subLoop, workLoop, i);
break; //header가 다른 한 경우만 고려하면 됨....
}
}
curDepth++;
} while (curDepth <= clsLoop.Loop[workLoop].maxDepth);
}
//Entry point of FIND LOOP
public static void search_Loop(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop)
{
//Find Backedges
make_Loop(ref graph, currentN);
loop.Loop[workLoop] = new gProAnalyzer.GraphVariables.clsLoop.strLoop();
// Loop생성
int cnt = 0;
for (int i = 0; i < Block.Length; i++)
{
if (Block[i].LoopHeader)
{
cnt++;
}
}
loop.Loop[workLoop].Loop = new gProAnalyzer.GraphVariables.clsLoop.strLoopInform[cnt];
loop.Loop[workLoop].nLoop = 0;
loop.Loop[workLoop].maxDepth = 0;
find_Loop(ref graph, currentN, ref loop, workLoop, -1, 1); //This is the KEY to find all loop-node <= from Block = nNode
//Depth Search
int depth = 1;
int count = graph.Network[currentN].nNode;
do
{
find_DepthNode(ref graph, currentN, depth);
count = count_UnDepth(ref graph, currentN);
depth++;
} while (count > 0);
// Loop별 Entry, Exit, Back SplitNode 검색
find_LoopInform(ref graph, currentN, ref loop, workLoop);
}
public static void Run_FindLoop(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int orgLoop, ref bool IrreducibleError)
{
Initialize_All();
//int orgLoop = loop.orgLoop;
//search_Loop(midNet, orgLoop); //originally, he use midNet
search_Loop(ref graph, currentN, ref clsLoop, orgLoop);
if (check_Irreducible(ref graph, currentN, ref clsLoop, orgLoop))
{
//MessageBox.Show("Irreducible Error : This network can not be handled");
IrreducibleError = true;
//return;
}
//Irreducible loop merging (if two IL directly nesting => Merge into one
merge_Irreducible(ref clsLoop, orgLoop);
//Irreducible loop내 헤드공유하는 Natural Loop 찾기 //find Natural Loop that share header with Irreducible loop
inspect_Irreducible(ref graph, currentN, ref clsLoop, orgLoop);
//find Special Node (Loop Entry: E, Loop Exit: X, Backward Split: B, BS and Exit: T)
find_SpecialNode(ref graph, currentN, ref clsLoop, orgLoop); //update all loops
}
//identify NL or IL after identify Block[i]
public static void find_Loop(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop, int header, int depth)
{
for (int i = 0; i < Block.Length; i++)
{
if (!Block[i].LoopHeader)
{
continue;
}
if (Block[i].iloop_header != header)
{
continue;
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].header = i;
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].Irreducible = Block[i].Irreducible;
//if (Loop[workLoop].Loop[Loop[workLoop].nLoop].Irreducible) Network[currentN].Node[i].Special = "hL";
//else Network[currentN].Node[i].Special = "hN";
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].depth = depth;
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].parentLoop = -1;
for (int k = 0; k < loop.Loop[workLoop].nLoop; k++)
{
if (loop.Loop[workLoop].Loop[k].depth != depth - 1)
{
continue;
}
if (loop.Loop[workLoop].Loop[k].header == Block[i].iloop_header)
{
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].parentLoop = k;
break;
}
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nBackEdge = Block[i].nBackEdge;
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].linkBack = new int[loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nBackEdge];
for (int j = 0; j < Block[i].nBackEdge; j++)
{
for (int k = 0; k < graph.Network[currentN].nLink; k++)
{
if (graph.Network[currentN].Link[k].fromNode == Block[i].fromNodeBack[j] && graph.Network[currentN].Link[k].toNode == i)
{
if (!loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].Irreducible)
{
graph.Network[currentN].Link[k].bBackJ = true; //Natural Loop[workLoop].Loop만 BackEdge;
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].linkBack[j] = k;
break;
}
}
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode = 0;
for (int j = 0; j < Block.Length; j++)
{
if (Block[j].iloop_header != loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].header)
{
continue;
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode++;
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].Node = new int[loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode];
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode = 0;
for (int j = 0; j < Block.Length; j++)
{
if (Block[j].iloop_header != loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].header)
{
continue;
}
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].Node[loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode] = j;
loop.Loop[workLoop].Loop[loop.Loop[workLoop].nLoop].nNode++;
}
loop.Loop[workLoop].nLoop++;
if (depth > loop.Loop[workLoop].maxDepth)
{
loop.Loop[workLoop].maxDepth = depth;
}
find_Loop(ref graph, currentN, ref loop, workLoop, i, depth + 1);
}
}
public static void After_Type_II_Split(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop)
{
//Loop 재탐색
gProAnalyzer.Functionalities.LoopIdentification.search_Loop(ref graph, currentN, ref clsLoop, workLoop);
gProAnalyzer.Functionalities.LoopIdentification.merge_Irreducible(ref clsLoop, workLoop);
gProAnalyzer.Functionalities.LoopIdentification.find_SpecialNode(ref graph, currentN, ref clsLoop, workLoop);
}
public static void find_LoopInform(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop)
{
int cntFind = 0;
int[] find_Node = new int[loop.Loop[workLoop].nLoop];
// Child Loop[workLoop].Loop
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
cntFind = 0;
for (int j = 0; j < loop.Loop[workLoop].nLoop; j++)
{
if (loop.Loop[workLoop].Loop[j].parentLoop == i)
{
find_Node[cntFind] = j;
cntFind++;
}
}
loop.Loop[workLoop].Loop[i].nChild = cntFind;
loop.Loop[workLoop].Loop[i].child = new int[cntFind];
for (int k = 0; k < cntFind; k++)
{
loop.Loop[workLoop].Loop[i].child[k] = find_Node[k];
}
}
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
//Loop[workLoop].Loop내 포함된 모든 노드 찾아서
nSearchNode = 0;
searchNode = new int[graph.Network[currentN].nNode];
searchNode[nSearchNode] = loop.Loop[workLoop].Loop[i].header;
nSearchNode++;
find_LoopNode(ref loop, workLoop, i);
// Entry
cntFind = 0;
find_Node = new int[graph.Network[currentN].nNode];
for (int r = 0; r < nSearchNode; r++) // Loop[workLoop].Loop내 모든 노드에 대해
{
bool isEntry = true;
for (int j = 0; j < graph.Network[currentN].Node[searchNode[r]].nPre; j++) // 노드의 모든 pre 노드에 대해
{
int nodeP = graph.Network[currentN].Node[searchNode[r]].Pre[j];
isEntry = true;
for (int k = 0; k < nSearchNode; k++)
{
if (nodeP == searchNode[k])
{
isEntry = false;
break;
}
}
if (isEntry)
{
break;
}
}
if (isEntry)
{
find_Node[cntFind] = searchNode[r];
cntFind++;
}
}
loop.Loop[workLoop].Loop[i].nEntry = cntFind;
loop.Loop[workLoop].Loop[i].Entry = new int[cntFind];
for (int k = 0; k < cntFind; k++)
{
loop.Loop[workLoop].Loop[i].Entry[k] = find_Node[k];
}
//Exit
cntFind = 0;
find_Node = new int[graph.Network[currentN].nNode];
for (int r = 0; r < nSearchNode; r++) // Loop[workLoop].Loop내 모든 노드에 대해
{
bool isExit = true;
for (int j = 0; j < graph.Network[currentN].Node[searchNode[r]].nPost; j++) // 노드의 모든 post 노드에 대해
{
int nodeP = graph.Network[currentN].Node[searchNode[r]].Post[j];
isExit = true;
for (int k = 0; k < nSearchNode; k++)
{
if (nodeP == searchNode[k])
{
isExit = false;
break;
}
}
if (isExit)
{
break;
}
}
if (isExit)
{
find_Node[cntFind] = searchNode[r];
cntFind++;
}
}
loop.Loop[workLoop].Loop[i].nExit = cntFind;
loop.Loop[workLoop].Loop[i].Exit = new int[cntFind];
for (int k = 0; k < cntFind; k++)
{
loop.Loop[workLoop].Loop[i].Exit[k] = find_Node[k];
}
//BackSplit
cntFind = 0;
find_Node = new int[graph.Network[currentN].nNode];
int depth = graph.Network[currentN].Node[loop.Loop[workLoop].Loop[i].header].depth;
for (int r = 0; r < nSearchNode; r++) // Loop[workLoop].Loop내 모든 노드에 대해
{
int node = searchNode[r];
if (graph.Network[currentN].Node[node].depth != depth)
{
continue;
}
bool isBack = false;
for (int k = 0; k < graph.Network[currentN].Node[node].nPost; k++)
{
int nodeP = graph.Network[currentN].Node[node].Post[k];
if (graph.Network[currentN].Node[nodeP].depth > depth)
{
for (int j = 0; j < graph.Network[currentN].nLink; j++)
{
if (graph.Network[currentN].Link[j].fromNode == node && graph.Network[currentN].Link[j].toNode == nodeP)
{
graph.Network[currentN].Link[j].bBackS = true;
isBack = true;
break;
}
}
}
else if (graph.Network[currentN].Node[nodeP].depth == depth) //바로 BackEdge 면
{
for (int j = 0; j < graph.Network[currentN].nLink; j++)
{
if (!graph.Network[currentN].Link[j].bBackJ)
{
continue;
}
if (graph.Network[currentN].Link[j].fromNode == node && graph.Network[currentN].Link[j].toNode == nodeP)
{
graph.Network[currentN].Link[j].bBackS = true;
isBack = true;
break;
}
}
}
}
if (isBack)
{
//if (Loop[workLoop].Loop[i].Irreducible) Network[currentN].Node[node].Special = "bL";
//else Network[currentN].Node[node].Special = "bN";
find_Node[cntFind] = node;
cntFind++;
}
}
loop.Loop[workLoop].Loop[i].nBackSplit = cntFind;
loop.Loop[workLoop].Loop[i].BackSplit = new int[cntFind];
for (int k = 0; k < cntFind; k++)
{
loop.Loop[workLoop].Loop[i].BackSplit[k] = find_Node[k];
}
}
}
public static int Type_II_Split_Entry(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int nNode, int nLink)
{
int nSplit = 0;
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++) //visit each loop in model
{
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nEntry; k++) //vist each entry of current loop.
{
int fjNode;
int bjNode;
int node = clsLoop.Loop[workLoop].Loop[i].Entry[k]; //get current entry and then split this node - if necessary
int[] preF = new int[nNode]; //store all node outside the loop
int[] preB = new int[nNode]; //store all node from inside the current loop (i)
int cntF = 0, cntB = 0;
for (int j = 0; j < nLink; j++)
{
if (graph.Network[currentN].Link[j].toNode == node) //if find a node which is go to current entry (node)
{
if (gProAnalyzer.Ultilities.findNodeInLoop.Node_In_Loop(ref clsLoop, workLoop, graph.Network[currentN].Link[j].fromNode, i)) //If the predecessor of current entry belong to this loop(i).
{
preB[cntB] = graph.Network[currentN].Link[j].fromNode; //store all node from inside the current loop (i) go to this entry (k) (node)
cntB++; //increase index - number of node inside the loop
}
else
{
preF[cntF] = graph.Network[currentN].Link[j].fromNode; //store all node which is predecessor of this entry (node)
cntF++;
}
}
}
if (cntF > 1) // For join이 2 미만이면 //it mean if all node go to entry outside the loop is just 1 or 0 => don't need to split.
{
fjNode = nNode;
bjNode = node;
//For Join Node - 추가 //Tao nut moi
graph.Network[currentN].Node[fjNode].Kind = graph.Network[currentN].Node[node].Kind;
graph.Network[currentN].Node[fjNode].Name = graph.Network[currentN].Node[node].Name;// node.ToString();
graph.Network[currentN].Node[fjNode].orgNum = node;
graph.Network[currentN].Node[fjNode].parentNum = fjNode;
graph.Network[currentN].Node[fjNode].Type_I = graph.Network[currentN].Node[node].Type_I;
graph.Network[currentN].Node[fjNode].Type_II = graph.Network[currentN].Node[node].Type_II + "_fj";
//We need focus on this node => split this node
//Back Join Node - 변경 //Thay doi info cua nut current entry
graph.Network[currentN].Node[bjNode].Type_II = graph.Network[currentN].Node[node].Type_II + "_bj"; //just add "_bj" for current entry
graph.Network[currentN].Node[fjNode].Special = ""; //What is that mean
//New Link 추가
graph.Network[currentN].Link[nLink].fromNode = fjNode;
graph.Network[currentN].Link[nLink].toNode = bjNode;
nSplit++;
nNode++; //nNode < nNode in extend_network
nLink++;
//기존 Link 정보 변경
//This code just consider the node outside the loop come to this entry. (adjust the link coming from outside the loop)
for (int j = 0; j < nLink; j++)
{
for (int j2 = 0; j2 < cntF; j2++)
{
//ajust the link from outside the loop to this entry node.
if (graph.Network[currentN].Link[j].fromNode == preF[j2] && graph.Network[currentN].Link[j].toNode == node)
{
graph.Network[currentN].Link[j].toNode = fjNode;
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, graph.Network[currentN].Link[j].fromNode);
}
}
}
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, fjNode);
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, bjNode);
if (clsLoop.Loop[workLoop].Loop[i].parentLoop > 0)
{
Loop_Inform(ref clsLoop, workLoop, node, fjNode, clsLoop.Loop[workLoop].Loop[i].parentLoop);
}
}
//========== EXTENTION ========================================================================(1 bai hoc nho doi)
#region hide
//if there are at least 2 incoming edges from inside the loop to this entry => extend type II
/*if (isInsideLoop(currentN, workLoop, i, node) == true)
* {
* //==New code===
* fjNode = nNode; //New Node
* bjNode = node; //Current Entry
* //create new node
* Network[currentN].Node[fjNode].Kind = Network[currentN].Node[node].Kind;
* Network[currentN].Node[fjNode].Name = Network[currentN].Node[node].Name;// node.ToString();
* Network[currentN].Node[fjNode].orgNum = node;
* Network[currentN].Node[fjNode].parentNum = fjNode;
* Network[currentN].Node[fjNode].Type_I = Network[currentN].Node[node].Type_I;
* Network[currentN].Node[fjNode].Type_II = Network[currentN].Node[node].Type_II + "_2";
* //create new link
* Network[currentN].Link[nLink].fromNode = fjNode;
* Network[currentN].Link[nLink].toNode = bjNode;
*
* nSplit++;
* nNode++; //nNode < nNode in extend_network
* nLink++;
*
* //Consider all incoming edges from inside the current loop to this current entry === (new move from above) crazy <===
* for (int j = 0; j < nLink; j++)
* {
* for (int j2 = 0; j2 < cntB; j2++) //consider the node inside the loop which have outgoing edges to loop entry
* {
* //ajust the link from outside the loop to this entry node. preB[] set node inside loop ; preF[] set of node outside the loop
* if (Network[currentN].Link[j].fromNode == preB[j2] && Network[currentN].Link[j].toNode == node)
* {
* Network[currentN].Link[j].toNode = fjNode; //fjNode is the new node
* find_NodeInform(currentN, Network[currentN].Link[j].fromNode);
* }
* }
* }
* find_NodeInform(currentN, fjNode); //inform for new node (after split type 2 extension)
* find_NodeInform(currentN, bjNode); //inform for this loop's entry
* if (Loop[workLoop].Loop[i].parentLoop > 0) Loop_Inform(workLoop, node, fjNode, Loop[workLoop].Loop[i].parentLoop);
* }
*/
#endregion
//========== END ==============================================================================
//Type_II_Extension_Entry(currentN, workLoop, i, nNode, nLink, node, ref nSplit, preB, cntB);
}
}
return(nSplit);
}
public static void add_Dummy_Task(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workloop, ref int nNode_org, ref int nLink_org)
{
int nNode = graph.Network[currentN].nNode;
int[,] pairingMatrix = new int[nNode, 2]; //paringMatrix[x][0] ~ the post of Exit, pairingMatrix[x][1] ~ the exit of loop.
int nPair = 0; //get all pair of [Exit -> CIPd] and then compare, add dummy!
for (int i = 0; i < clsLoop.Loop[workloop].nLoop; i++)
{
for (int j = 0; j < clsLoop.Loop[workloop].Loop[i].nExit; j++)
{
for (int p = 0; p < graph.Network[currentN].Node[clsLoop.Loop[workloop].Loop[i].Exit[j]].nPost; p++)
{
int post = graph.Network[currentN].Node[clsLoop.Loop[workloop].Loop[i].Exit[j]].Post[p];
if (Ultilities.checkGraph.Node_In_Loop(clsLoop, workloop, post, i) == false)
{
//check duplicated
if (check_Duplicated_pairMatrix(pairingMatrix, nPair, post, clsLoop.Loop[workloop].Loop[i].Exit[j]))
{
break;
}
pairingMatrix[nPair, 0] = post;
pairingMatrix[nPair, 1] = clsLoop.Loop[workloop].Loop[i].Exit[j];
nPair++;
break;
}
}
}
}
int[,] pairingMatrix_2 = new int[nNode, nNode]; //paringMatrix[0][x] ~ the direct CIPd of entries x
populate_matrix(pairingMatrix_2, nNode); //populate matrix ~ -1
int npair_row = 0;
int npair_col = 0;
int count = 1;
for (int i = 0; i < nPair; i++)
{
if (pairingMatrix[i, 0] < 0)
{
continue;
}
count = 1;
for (int j = 0; j < nPair; j++)
{
if (pairingMatrix[i, 0] == pairingMatrix[j, 0] && i != j)
{
count++;
if (count == 2)
{
pairingMatrix_2[npair_row, npair_col] = pairingMatrix[i, 0];
npair_col++;
pairingMatrix_2[npair_row, npair_col] = pairingMatrix[i, 1];
npair_col++;
//pairingMatrix[i, 0] = -1;
pairingMatrix_2[npair_row, npair_col] = pairingMatrix[j, 1];
npair_col++;
pairingMatrix[j, 0] = -1;
}
else
{
pairingMatrix_2[npair_row, npair_col] = pairingMatrix[j, 1];
npair_col++;
pairingMatrix[j, 0] = -1;
}
//marking to avoid redundancy of 2 colm matrix
}
}
if (count > 1)
{
npair_row++;
}
npair_col = 0;
}
//add more task
for (int i = 0; i < npair_row; i++)
{
int num_Task = 0;
for (int j = 0; j < nNode; j++)
{
if (pairingMatrix_2[i, j] != -1)
{
num_Task++;
}
}
//Add a task in middle of 2 node
for (int j = 1; j < num_Task - 1; j++)
{
int node_1 = pairingMatrix_2[i, 0];
int node_2 = pairingMatrix_2[i, j];
add_aTask(ref graph, currentN, ref clsLoop, workloop, node_1, node_2, ref nNode_org, ref nLink_org);
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, node_1);
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, node_2);
gProAnalyzer.Ultilities.clsFindNodeInfo.find_NodeInfo(ref graph, currentN, nNode_org - 1);
}
}
}
//check sub_Irreducible loop
public static bool check_Irreducible(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop)
{
bool bError = false;
int curDepth = 1;
do
{
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++)
{
if (clsLoop.Loop[workLoop].Loop[i].depth != curDepth)
{
continue;
}
if (!clsLoop.Loop[workLoop].Loop[i].Irreducible)
{
continue;
}
int nIrr = 0;
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nChild; k++)
{
if (clsLoop.Loop[workLoop].Loop[clsLoop.Loop[workLoop].Loop[i].child[k]].Irreducible)
{
nIrr++;
}
}
if (nIrr == 0)
{
continue;
}
gProAnalyzer.Ultilities.makeSubNetwork.make_subNetwork(ref graph, currentN, graph.subNet, ref clsLoop, workLoop, i, ref clsSESE, "CI", -1); //5는 SubNetwork
if (check_subIrreducible(ref graph, graph.subNet, ref clsLoop, clsLoop.subLoop))
{
bError = true;
break;
}
}
curDepth++;
} while (curDepth <= clsLoop.Loop[workLoop].maxDepth && !bError);
return(bError);
}
public static void add_subNatural(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, int saveN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int saveLoop, int loop)
{
//Loop[workLoop].Loop찾기
search_Loop(ref graph, currentN, ref clsLoop, workLoop);
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++)
{
if (clsLoop.Loop[workLoop].Loop[i].parentLoop == -1)
{
continue;
}
if (clsLoop.Loop[workLoop].Loop[i].Irreducible)
{
continue;
}
int orgHeader = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[i].header].parentNum;
if (orgHeader != clsLoop.Loop[saveLoop].Loop[loop].header)
{
continue; //원 loop의 헤더를 공유하는 것만 추가
}
// Loop[workLoop].Loop 추가 ----------------------
gProAnalyzer.GraphVariables.clsLoop.strLoopInform addLoop = new gProAnalyzer.GraphVariables.clsLoop.strLoopInform();
int orgNode, orgNode2;
addLoop = clsLoop.Loop[workLoop].Loop[i]; //일단 copy
addLoop.depth = clsLoop.Loop[saveLoop].Loop[loop].depth + 1;
addLoop.parentLoop = loop;
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nChild; k++)
{
orgNode = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[clsLoop.Loop[workLoop].Loop[i].child[k]].header].parentNum;
int findLoop = -1;
for (int k2 = 0; k2 < clsLoop.Loop[saveLoop].nLoop; k2++)
{
if (orgNode == clsLoop.Loop[saveLoop].Loop[k2].header)
{
findLoop = k2;
break;
}
}
addLoop.child[k] = findLoop;
clsLoop.Loop[saveLoop].Loop[findLoop].parentLoop = clsLoop.Loop[saveLoop].nLoop;
}
orgNode = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[i].header].parentNum;
addLoop.header = orgNode;
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nBackEdge; k++)
{
orgNode = graph.Network[currentN].Link[clsLoop.Loop[workLoop].Loop[i].linkBack[k]].fromNode;
orgNode = graph.Network[currentN].Node[orgNode].parentNum;
orgNode2 = graph.Network[currentN].Link[clsLoop.Loop[workLoop].Loop[i].linkBack[k]].toNode;
orgNode2 = graph.Network[currentN].Node[orgNode2].parentNum;
int orgLink = -1;
for (int k2 = 0; k2 < graph.Network[saveN].nLink; k2++)
{
if (orgNode == graph.Network[saveN].Link[k2].fromNode && orgNode2 == graph.Network[saveN].Link[k2].toNode)
{
orgLink = k2;
break;
}
}
addLoop.linkBack[k] = orgLink;
}
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nEntry; k++)
{
orgNode = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[i].Entry[k]].parentNum;
addLoop.Entry[k] = orgNode;
}
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nExit; k++)
{
orgNode = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[i].Exit[k]].parentNum;
addLoop.Exit[k] = orgNode;
}
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[i].nNode; k++)
{
orgNode = graph.Network[currentN].Node[clsLoop.Loop[workLoop].Loop[i].Node[k]].parentNum;
addLoop.Node[k] = orgNode;
}
int nNewLoop = clsLoop.Loop[saveLoop].nLoop + 1;
gProAnalyzer.GraphVariables.clsLoop.strLoop newLoop = new gProAnalyzer.GraphVariables.clsLoop.strLoop();
newLoop.Loop = new gProAnalyzer.GraphVariables.clsLoop.strLoopInform[nNewLoop];
for (int k = 0; k < clsLoop.Loop[saveLoop].nLoop; k++)
{
newLoop.Loop[k] = clsLoop.Loop[saveLoop].Loop[k];
if (k == loop) //추가Loop[workLoop].Loop의 parents면
{
//----Child 추가 및 제거
int numAdd = 0;
int[] add = new int[clsLoop.Loop[saveLoop].Loop[k].nChild + 1];
for (int k2 = 0; k2 < clsLoop.Loop[saveLoop].Loop[k].nChild; k2++)
{
bool bDel = false;
for (int k3 = 0; k3 < addLoop.nChild; k3++)
{
if (clsLoop.Loop[saveLoop].Loop[k].child[k2] == addLoop.child[k3])
{
bDel = true;
break;
}
}
if (!bDel)
{
add[numAdd] = clsLoop.Loop[saveLoop].Loop[k].child[k2];
numAdd++;
}
}
add[numAdd] = clsLoop.Loop[saveLoop].nLoop;
numAdd++;
newLoop.Loop[k].nChild = numAdd;
newLoop.Loop[k].child = add;
//-----포함 Node 제거
numAdd = 0;
add = new int[clsLoop.Loop[saveLoop].Loop[k].nNode];
for (int k2 = 0; k2 < clsLoop.Loop[saveLoop].Loop[k].nNode; k2++)
{
bool bDel = false;
for (int k3 = 0; k3 < addLoop.nNode; k3++)
{
if (clsLoop.Loop[saveLoop].Loop[k].Node[k2] == addLoop.Node[k3])
{
bDel = true;
break;
}
}
if (!bDel)
{
add[numAdd] = clsLoop.Loop[saveLoop].Loop[k].Node[k2];
numAdd++;
}
}
newLoop.Loop[k].nNode = numAdd;
newLoop.Loop[k].Node = add;
}
}
newLoop.Loop[clsLoop.Loop[saveLoop].nLoop] = addLoop;
clsLoop.Loop[saveLoop].Loop = newLoop.Loop;
clsLoop.Loop[saveLoop].nLoop = nNewLoop;
}
clsLoop.Loop[saveLoop].maxDepth = 0;
for (int i = 0; i < clsLoop.Loop[saveLoop].nLoop; i++)
{
if (clsLoop.Loop[saveLoop].Loop[i].depth > clsLoop.Loop[saveLoop].maxDepth)
{
clsLoop.Loop[saveLoop].maxDepth = clsLoop.Loop[saveLoop].Loop[i].depth;
}
}
}
public static void find_SpecialNode(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop loop, int workLoop)
{
for (int i = 0; i < loop.Loop[workLoop].nLoop; i++)
{
//Etry
for (int j = 0; j < loop.Loop[workLoop].Loop[i].nEntry; j++)
{
int k = loop.Loop[workLoop].Loop[i].Entry[j];
graph.Network[currentN].Node[k].Special = "E";
}
//Exit
for (int j = 0; j < loop.Loop[workLoop].Loop[i].nExit; j++)
{
int k = loop.Loop[workLoop].Loop[i].Exit[j];
graph.Network[currentN].Node[k].Special = "X";
}
}
for (int i = 0; i < graph.Network[currentN].nLink; i++)
{
if (!graph.Network[currentN].Link[i].bBackS)
{
continue;
}
int from = graph.Network[currentN].Link[i].fromNode;
if (graph.Network[currentN].Node[from].Special == "X")
{
graph.Network[currentN].Node[from].Special = "T";
}
else
{
if (graph.Network[currentN].Node[from].Special != "T") //New line here (We add new condition for the check Special Node for BS, in order to avoid the reassetment of node "T"
{
graph.Network[currentN].Node[from].Special = "B";
}
}
}
}
//================================================================================================================================
public static bool can_Reach(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop,
int workLoop, int loop, int fromNode, int toNode, string Type)
{
bool bReach = false;
if (graph.Network[currentN].Node[fromNode].nPost == 0)
{
return(bReach);
}
for (int i = 0; i < graph.Network[currentN].Node[fromNode].nPost; i++)
{
bool bSame = false;
for (int j = 0; j < nReachNode; j++)
{
if (graph.Network[currentN].Node[fromNode].Post[i] == reachNode[j])
{
bSame = true;
break;
}
}
if (bSame)
{
continue;
}
reachNode[nReachNode] = graph.Network[currentN].Node[fromNode].Post[i];
nReachNode++;
if (graph.Network[currentN].Node[fromNode].Post[i] == toNode)
{
bReach = true;
break;
}
else if (Type == "CC")
{
if (!gProAnalyzer.Ultilities.findNodeInLoop.Node_In_Loop(ref clsLoop, workLoop, graph.Network[currentN].Node[fromNode].Post[i], loop)) //???????????
{
if (can_Reach(ref graph, currentN, ref clsLoop, workLoop, loop, graph.Network[currentN].Node[fromNode].Post[i], toNode, Type))
{
bReach = true;
break;
}
}
}
else
{
if (can_Reach(ref graph, currentN, ref clsLoop, workLoop, loop, graph.Network[currentN].Node[fromNode].Post[i], toNode, Type))
{
bReach = true;
break;
}
}
}
return(bReach);
}
public static void find_SpecialNode_ReducedLoop(ref gProAnalyzer.GraphVariables.clsGraph graph, int reduceN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop, int curLoop)
{
int[] node_set = new int[clsLoop.Loop[workLoop].Loop[curLoop].nNode + 1];
node_set[0] = clsLoop.Loop[workLoop].Loop[curLoop].header;
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[curLoop].nNode; i++)
{
node_set[i + 1] = clsLoop.Loop[workLoop].Loop[curLoop].Node[i];
}
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[curLoop].nNode; i++)
{
int node = clsLoop.Loop[workLoop].Loop[curLoop].Node[i];
if (graph.Network[reduceN].Node[node].Special == "E")
{
for (int j = 0; j < graph.Network[reduceN].nLink; j++)
{
if (graph.Network[reduceN].Link[j].fromNode == node)
{
if (Ultilities.checkGraph.Node_In_Set(node_set, node_set.Length, graph.Network[reduceN].Link[j].toNode) == false)
{
graph.Network[reduceN].Node[node].Special = "X";
}
}
}
}
}
for (int i = 0; i < clsLoop.Loop[workLoop].Loop[curLoop].nNode; i++)
{
int node = clsLoop.Loop[workLoop].Loop[curLoop].Node[i];
for (int j = 0; j < graph.Network[reduceN].nLink; j++)
{
if (graph.Network[reduceN].Link[j].fromNode == node)
{
if (graph.Network[reduceN].Node[node].Special == "X")
{
if (graph.Network[reduceN].Link[j].bBackS == true) //backward split
{
graph.Network[reduceN].Node[node].Special = "T";
}
}
else
if (graph.Network[reduceN].Link[j].bBackS == true && graph.Network[reduceN].Node[node].Special != "T")
{
graph.Network[reduceN].Node[node].Special = "B";
}
}
}
}
}
public static void add_aTask(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workloop, int first_node, int second_node, ref int nNode, ref int nLink)
{
//int nNode = graph.Network[currentN].nNode;
//int nLink = graph.Network[currentN].nLink;
graph.Network[currentN].Node[nNode].Kind = "TASK";
graph.Network[currentN].Node[nNode].Name = "Dummy";// node.ToString();
graph.Network[currentN].Node[nNode].orgNum = nNode;
graph.Network[currentN].Node[nNode].parentNum = nNode;
graph.Network[currentN].Node[nNode].Type_I = "";
graph.Network[currentN].Node[nNode].Type_II = "";
graph.Network[currentN].Node[nNode].Special = "";
//New Link 추가
//find old link from Exit to its common Post[]
for (int i = 0; i < nLink; i++)
{
if (graph.Network[currentN].Link[i].fromNode == second_node && graph.Network[currentN].Link[i].toNode == first_node)
{
graph.Network[currentN].Link[i].fromNode = second_node; //exit
graph.Network[currentN].Link[i].toNode = nNode; //Dummy
}
}
graph.Network[currentN].Link[nLink].fromNode = nNode;
graph.Network[currentN].Link[nLink].toNode = first_node;
nLink++;
nNode++;
}
//New one for the case there are loops in the DFlow ============================================
public static void find_Reach_2(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop,
int workLoop, int loop, int sNode, int toNode, string Type, ref int[] searchNode, ref int nSearchNode) //it OK -> just change the Can_Reach_2() function
{
Initialize_All();
if (sNode == toNode)
{
return; //Start node = end path Node
}
for (int i = 0; i < graph.Network[currentN].Node[sNode].nPost; i++) //Visit all potential path from sNode (Start)
{
/////////////////////////////////
bool bEnd = false;
if (Type == "CC") //sNode for this case is Header (searchNode[0])
{
for (int k = 0; k < clsLoop.Loop[workLoop].Loop[loop].nEntry; k++) //Check nut lien ke tu sNode (header) toi entries dc hay ko (Duong di truc tiep)
{
if (graph.Network[currentN].Node[sNode].Post[i] == clsLoop.Loop[workLoop].Loop[loop].Entry[k])
{
bEnd = true;
break;
}
}
}
if (bEnd)
{
continue;
}
////////////////////////////////////////
int fromNode = graph.Network[currentN].Node[sNode].Post[i]; //begining with a single path
nReachNode = 0;
//initiate reachNode by a array with scale of nNode (it will store the node, in "sequentially" - just guess)
reachNode = new int[graph.Network[currentN].nNode];
reachNode[nReachNode] = fromNode; //Begining with the sucessor of start (sNode)
nReachNode++;
bool[] mark_reach = new bool[graph.Network[currentN].nNode * 2];
if (can_Reach_2(ref graph, currentN, ref clsLoop, workLoop, loop, fromNode, toNode, Type, ref mark_reach))
{
bool bSame = false;
for (int j = 0; j < nSearchNode; j++)
{
if (searchNode[j] == fromNode)
{
bSame = true;
break;
}
}
if (!bSame)
{
searchNode[nSearchNode] = fromNode;
nSearchNode++;
}
find_Reach_2(ref graph, currentN, ref clsLoop, workLoop, loop, fromNode, toNode, Type, ref searchNode, ref nSearchNode);
}
}
}
public int RunTest(ref gProAnalyzer.GraphVariables.clsGraph graph, ref gProAnalyzer.GraphVariables.clsHWLS clsHWLS, ref gProAnalyzer.GraphVariables.clsLoop clsLoop,
ref gProAnalyzer.GraphVariables.clsSESE clsSESE, int numRun)
{
duration = 0;
HiPerfTimer pt = new HiPerfTimer();
pt.Start();
for (int i = 0; i < numRun; i++)
{
Initialize_All();
//SplitType1.Run_Split_Type1(ref graph, graph.orgNet, graph.midNet);
//findLoop.Run_FindLoop(ref graph, graph.midNet, ref clsLoop, clsLoop.orgLoop, ref clsLoop.IrreducibleError);
graph.Network[graph.finalNet] = graph.Network[graph.orgNet];
//SplitType2.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);
//sese.find_SESE_WithLoop(ref graph, graph.finalNet, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE, -2);
gProAnalyzer.Functionalities.SESEIdentification.find_SESE_Dummy(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);
//Decompose cyclic subgraphs
//Make nesting forest?
gProAnalyzer.Ultilities.makeNestingForest.make_NestingForest(ref graph, graph.finalNet, ref clsHWLS, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE);
}
pt.Stop();
duration += pt.Duration;
duration = duration / (double)numRun;
duration = duration * 1000;
//makInst.make_InstanceFlow(ref graph, graph.finalNet, 0, "", "");
//==================================================
//== get initial behavior profile ==
//graph.Network[graph.reduceNet] = graph.Network[graph.finalNet];
//extendG.full_extentNetwork(ref graph, graph.reduceNet, 0, 0);
//indexing.get_InitialBehaviorProfile(ref graph, graph.reduceNet, ref clsHWLS, ref clsLoop, clsLoop.orgLoop, ref clsSESE, clsSESE.finalSESE);
//Database storing
return(0);
}
public static bool check_subIrreducible(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, ref gProAnalyzer.GraphVariables.clsLoop clsLoop, int workLoop)
{
//Loop[workLoop].Loop찾기
search_Loop(ref graph, currentN, ref clsLoop, workLoop);
bool bError = false;
for (int i = 0; i < clsLoop.Loop[workLoop].nLoop; i++)
{
if (clsLoop.Loop[workLoop].Loop[i].depth > 1)
{
continue;
}
if (clsLoop.Loop[workLoop].Loop[i].Irreducible)
{
bError = true;
break;
}
}
return(bError);
}
