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); }