public static bool check_Error_Num(GraphVariables.clsError clsError, int idx_error) //LoS. DL in acyclic (including Fwd and Bwd) { if (clsError.Error[idx_error].messageNum == 27 || clsError.Error[idx_error].messageNum == 28 || clsError.Error[idx_error].messageNum == 3 || clsError.Error[idx_error].messageNum == 4 || clsError.Error[idx_error].messageNum == 5 || clsError.Error[idx_error].messageNum == 6) { return(true); } return(false); }
public static bool check_DFS_real_error(GraphVariables.clsError clsError, int[] getPath, int nGetpath, int v) { bool check_real = true; for (int i = 0; i < nGetpath; i++) //remove last node as error { for (int j = 0; j < clsError.nError; j++) { if (!check_Error_Num(clsError, j)) { continue; //filtering error } if (Convert.ToInt32(clsError.Error[j].Node) == v) { continue; } if (getPath[i] == Convert.ToInt32(clsError.Error[j].Node)) { check_real = false; } } } return(check_real); }
//might not belong to this class. public static void check_InstanceFlow(ref gProAnalyzer.GraphVariables.clsGraph graph, int currentN, int loop, string errType, string strLoop, ref int[] InstantNode, ref int nInstantNode, ref GraphVariables.clsError clsError) { for (int i = 0; i < nInstantNode; i++) { //XOR Join에 여러 Instant In이면 error if (graph.Network[currentN].Node[InstantNode[i]].Kind == "XOR" && graph.Network[currentN].Node[InstantNode[i]].nPre > 1) { int numIn = 0; for (int j = 0; j < graph.Network[currentN].Node[InstantNode[i]].nPre; j++) { bool bLink = false; for (int k = 0; k < graph.Network[currentN].nLink; k++) { if (graph.Network[currentN].Link[k].fromNode == graph.Network[currentN].Node[InstantNode[i]].Pre[j] && graph.Network[currentN].Link[k].toNode == InstantNode[i]) { if (graph.Network[currentN].Link[k].bInstance) { bLink = true; } break; } } if (!bLink) { continue; } for (int k = 0; k < nInstantNode; k++) { if (graph.Network[currentN].Node[InstantNode[i]].Pre[j] == InstantNode[k]) { numIn++; } } } if (numIn > 1) //error { clsError.Error[clsError.nError].Loop = strLoop; clsError.Error[clsError.nError].Node = graph.Network[currentN].Node[InstantNode[i]].parentNum.ToString(); clsError.Error[clsError.nError].currentKind = graph.Network[currentN].Node[InstantNode[i]].Kind; if (loop == -1) { clsError.Error[clsError.nError].messageNum = 10; } else { if (errType == "SESE") { clsError.Error[clsError.nError].Loop = ""; clsError.Error[clsError.nError].SESE = strLoop; clsError.Error[clsError.nError].messageNum = 27; //SESE lack of synchronization } if (errType == "eFwd") { if (clsError.Error[clsError.nError].Node == "-1") { clsError.Error[clsError.nError].messageNum = 29; //parallel error } else { clsError.Error[clsError.nError].messageNum = 3; //rule 2.1 } } if (errType == "eBwd") { clsError.Error[clsError.nError].messageNum = 4; //rule 2.1 } if (errType == "ePdFlow") { clsError.Error[clsError.nError].messageNum = 24; //rule 6.1 } if (errType == "eFwd_IL") { clsError.Error[clsError.nError].messageNum = 25; //rule 6.2 } if (errType == "eBwd_IL") { clsError.Error[clsError.nError].messageNum = 26; //rule 6.3 } } //nError++; gProAnalyzer.Ultilities.recordData.add_Error(ref clsError); } } //AND Join에 Instant In이 부족하면 error //===========DEADLOCK============ if (graph.Network[currentN].Node[InstantNode[i]].Kind == "AND" && graph.Network[currentN].Node[InstantNode[i]].nPre > 1) { int numIn = 0; for (int j = 0; j < graph.Network[currentN].Node[InstantNode[i]].nPre; j++) { bool bLink = false; for (int k = 0; k < graph.Network[currentN].nLink; k++) { if (graph.Network[currentN].Link[k].fromNode == graph.Network[currentN].Node[InstantNode[i]].Pre[j] && graph.Network[currentN].Link[k].toNode == InstantNode[i]) { if (graph.Network[currentN].Link[k].bInstance) { bLink = true; } break; } } if (!bLink) { continue; } for (int k = 0; k < nInstantNode; k++) { if (graph.Network[currentN].Node[InstantNode[i]].Pre[j] == InstantNode[k]) { numIn++; } } } if (numIn < graph.Network[currentN].Node[InstantNode[i]].nPre) //error { clsError.Error[clsError.nError].Loop = strLoop; clsError.Error[clsError.nError].Node = graph.Network[currentN].Node[InstantNode[i]].parentNum.ToString(); clsError.Error[clsError.nError].currentKind = graph.Network[currentN].Node[InstantNode[i]].Kind; if (loop == -1) { clsError.Error[clsError.nError].messageNum = 11; } else { if (errType == "SESE") { clsError.Error[clsError.nError].Loop = ""; clsError.Error[clsError.nError].SESE = strLoop; clsError.Error[clsError.nError].messageNum = 28; //SESE deadlock } if (errType == "eFwd") { clsError.Error[clsError.nError].messageNum = 5; } if (errType == "eBwd") { clsError.Error[clsError.nError].messageNum = 6; } //same for XOR errors if (errType == "ePdFlow") { clsError.Error[clsError.nError].messageNum = 37; //rule 6.1 } if (errType == "eFwd_IL") { clsError.Error[clsError.nError].messageNum = 38; //rule 6.2 } if (errType == "eBwd_IL") { clsError.Error[clsError.nError].messageNum = 39; //rule 6.3 } //if (errType == "SESE") Error[nError].messageNum = 28; } //nError++; gProAnalyzer.Ultilities.recordData.add_Error(ref clsError); } } } }
public static void DFS_Recursive(int[][] adjList, ref bool[] Mark, int Entry, int Exit, ref int[] getPath, ref int nGetPath, GraphVariables.clsError clsError, ref bool flag) { if (flag == false) { return; //if check error is not real => exit } Stack stack = new Stack(); Mark[Entry] = true; stack.Push(Entry); getPath[nGetPath] = Entry; nGetPath++; for (int i = 1; i <= adjList[Entry][0]; i++) { int v = adjList[Entry][i]; if (!Mark[v] && v != Exit) { DFS_Recursive(adjList, ref Mark, v, Exit, ref getPath, ref nGetPath, clsError, ref flag); } else if (v == Exit) { //Get the trace from START to EXIT //getPath[nGetPath] = v; //nGetPath++; //Check real error bool check_real = check_DFS_real_error(clsError, getPath, nGetPath, v); if (check_real == false) { flag = false; } } } //remove from path Mark[Entry] = false; nGetPath--; }
public static int check_real_errors(GraphVariables.clsGraph graph, int currentN, GraphVariables.clsHWLS clsHWLS, GraphVariables.clsLoop clsLoop, int currentLoop, ref GraphVariables.clsError clsError, int errorNode) //return(1) => Real; return(2) => Potential; return(3) => Dom { int[][] adjList = null; if (true) //acyclic { int[] getPath = new int[graph.Network[currentN].nNode]; int START = graph.Network[currentN].header; int nGetPath = 0; bool[] Mark = new bool[graph.Network[currentN].nNode]; gProAnalyzer.Ultilities.mappingGraph.to_adjList_Directed(ref graph, currentN, ref adjList); //We already buil an instance subgraph based on InstanceNode !! Huaahhh~ //Check "Real error" first for (int i = 0; i < clsError.nError; i++) //filtering the DL or LoS of acyclic only { if (!check_Error_Num(clsError, i)) { continue; //filtering acylci error } bool flag_Real_error = true; //0: real; int EXIT = Convert.ToInt32(clsError.Error[i].Node); DFS_Recursive(adjList, ref Mark, START, EXIT, ref getPath, ref nGetPath, clsError, ref flag_Real_error); if (flag_Real_error == true) { clsError.Error[i].TypeOfError = "R"; } else { clsError.Error[i].TypeOfError = "P"; } } //Check "Domiance error" from "Potential error" for (int i = 0; i < clsError.nError; i++) //filtering the DL or LoS of acyclic only { if (!check_Error_Num(clsError, i)) { continue; //filtering acylci error } if (clsError.Error[i].TypeOfError != "R") { continue; //only pick REAL errors for referencing } int currError = Convert.ToInt32(clsError.Error[i].Node); //This is a real error for (int k = 0; k < clsError.nError; k++) //filtering the DL or LoS of acyclic only { if (!check_Error_Num(clsError, k)) { continue; //filtering acylci error } if (clsError.Error[k].Node == clsError.Error[i].Node) { continue; } if (Ultilities.checkGraph.Node_In_Set(graph.Network[currentN].Node[currError].DomEI, graph.Network[currentN].Node[currError].nDomEI, Convert.ToInt32(clsError.Error[k].Node))) { clsError.Error[k].TypeOfError = "D"; } } } //Check "Dominance_by_Potential error" of Potential errors (From the leftover potential errors) for (int i = 0; i < clsError.nError; i++) //filtering the DL or LoS of acyclic only { if (!check_Error_Num(clsError, i)) { continue; //filtering acyclic error } if (clsError.Error[i].TypeOfError != "P") { continue; } int currError = Convert.ToInt32(clsError.Error[i].Node); for (int k = 0; k < clsError.nError; k++) //filtering the DL or LoS of acyclic only { if (!check_Error_Num(clsError, k)) { continue; //filtering acylci error } if (clsError.Error[k].Node == clsError.Error[i].Node) { continue; } if (Ultilities.checkGraph.Node_In_Set(graph.Network[currentN].Node[currError].DomEI, graph.Network[currentN].Node[currError].nDomEI, Convert.ToInt32(clsError.Error[k].Node))) { clsError.Error[k].TypeOfError = "DP"; } } } } else //if cylic graph { //First, check Error type DL, LoS, same with above (Must reduce all loop) => Compute the dominance relations //If error from inside NL => check (IF REDUCE LOOP => MUST MARK other reducedLoop as having Error for easily check). //If current NL => Take out NL subgraph => run DFS to check "Real_Error" and "Potential_errors" -> Check "Dominance_Errors" //If current NL Header is "Real" => keep everything original //If current NL Header is "Dom" => All error wil be "Dominace_Errors" //If current NL Header is "Potential" => All error will be "Potential_Errors" #region int curDepth = clsHWLS.FBLOCK.maxDepth; do { for (int k = 0; k < clsHWLS.FBLOCK.nFBlock; k++) { if (clsHWLS.FBLOCK.FBlock[k].depth != curDepth) { continue; } int orgIndx = clsHWLS.FBLOCK.FBlock[k].refIndex; if (clsHWLS.FBLOCK.FBlock[k].SESE == false && clsLoop.Loop[currentLoop].Loop[orgIndx].nEntry == 1) { gProAnalyzer.Ultilities.makeSubNetwork.make_AcyclicSubGraph(ref graph, currentN, graph.subNet, ref clsLoop, currentLoop, orgIndx, "NL"); int[] getPath = new int[graph.Network[graph.subNet].nNode]; int START = graph.Network[graph.subNet].header; int nGetPath = 0; bool[] Mark = new bool[graph.Network[graph.subNet].nNode]; gProAnalyzer.Ultilities.mappingGraph.to_adjList_Directed(ref graph, graph.subNet, ref adjList); //We already buil an instance subgraph based on InstanceNode !! Huaahhh~ //Check "Real error" first for (int i = 0; i < clsError.nError; i++) //filtering the DL or LoS of acyclic only { if (!(clsError.Error[k].messageNum == 3 || clsError.Error[k].messageNum == 4 || clsError.Error[k].messageNum == 29 || clsError.Error[k].messageNum == 5 || clsError.Error[k].messageNum == 6)) { continue; //filtering Loop error only [3,4,5,6,29] } bool flag_Real_error = true; //0: real; int EXIT = Convert.ToInt32(clsError.Error[i].Node); DFS_Recursive(adjList, ref Mark, START, EXIT, ref getPath, ref nGetPath, clsError, ref flag_Real_error); if (flag_Real_error == true) { clsError.Error[i].TypeOfError = "R"; } else { clsError.Error[i].TypeOfError = "P"; } } } } curDepth--; } while (curDepth > 0); #endregion } return(1); }