diff --git a/src/main/java/cli/Plan.java b/src/main/java/cli/Plan.java
index cee160b068b1587c08cf167c576a891de5d431e5..6e5346aa27d0cde323ab35ef970e629b2153823e 100644
--- a/src/main/java/cli/Plan.java
+++ b/src/main/java/cli/Plan.java
@@ -37,33 +37,36 @@
*/
package cli;
-import common.ConfigurationTTool;
-import common.SpecConfigTTool;
-import launcher.RTLLauncher;
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Vector;
+import org.jgrapht.io.ExportException;
import myutil.FileUtils;
-import myutil.PluginManager;
-import myutil.TraceManager;
-import tmltranslator.*;
-import tmltranslator.dsez3engine.InputInstance;
-import tmltranslator.dsez3engine.OptimizationModel;
+import simulationtraceanalysis.DependencyGraphTranslator;
+import simulationtraceanalysis.PlanArrays;
+import tmltranslator.TMLActivity;
+import tmltranslator.TMLActivityElement;
+import tmltranslator.TMLMapping;
+import tmltranslator.TMLMappingTextSpecification;
+import tmltranslator.TMLModeling;
+import tmltranslator.TMLSyntaxChecking;
+import tmltranslator.TMLTask;
import tmltranslator.dsez3engine.OptimizationResult;
import ui.CheckableLatency;
import ui.MainGUI;
import ui.SimulationTrace;
import ui.TGComponent;
import ui.TMLArchiPanel;
-import ui.TURTLEPanel;
import ui.interactivesimulation.SimulationTransaction;
-import ui.simulationtraceanalysis.DirectedGraphTranslator;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
import ui.simulationtraceanalysis.JFrameLatencyDetailedPopup;
import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
import ui.tmlad.TMLADExecI;
import ui.tmlad.TMLActivityDiagramPanel;
-import ui.util.IconManager;
-import java.io.File;
-import java.util.*;
-import java.util.Map.Entry;
/**
* Class TML Creation: 25/03/2019 Version 2.0 25/03/2019
@@ -78,10 +81,12 @@ public class Plan extends Command {
private HashMap<String, Integer> checkedT = new HashMap<String, Integer>();
private Vector<SimulationTransaction> transFile1;
private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
- private DirectedGraphTranslator dgt;
+ private DependencyGraphTranslator dgt, dgraph;;
private String traceFile;
private Boolean taint;
private OptimizationResult result;
+ private TMLMapping<TGComponent> tmap;
+ private TMLSyntaxChecking syntax;
public Plan() {
}
@@ -125,6 +130,24 @@ public class Plan extends Command {
return generateGraph(command, interpreter);
}
};
+ Command generateGraph = new Command() {
+ public String getCommand() {
+ return "generateGraph";
+ }
+
+ public String getShortCommand() {
+ return "generate";
+ }
+
+ public String getDescription() {
+ return "Generate graph from TML mapping ";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return generateGraphFromTML(command, interpreter);
+ }
+ };
Command latency = new Command() {
public String getCommand() {
return "latency";
@@ -171,7 +194,7 @@ public class Plan extends Command {
}
public String getDescription() {
- return "Precise Latency analysis by row";
+ return "Precise latency analysis by row";
}
public String executeCommand(String command, Interpreter interpreter) {
@@ -179,10 +202,107 @@ public class Plan extends Command {
return preciseLatByRow(command, interpreter);
}
};
+ Command exportGraphGraphml = new Command() {
+ public String getCommand() {
+ return "exportGraph";
+ }
+
+ public String getShortCommand() {
+ return "exportG";
+ }
+
+ public String getDescription() {
+ return "Export graph in Graphml format";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return exportGGraphml(command, interpreter);
+ }
+ };
+ Command saveGraph = new Command() {
+ public String getCommand() {
+ return "saveGraph";
+ }
+
+ public String getShortCommand() {
+ return "saveG";
+ }
+
+ public String getDescription() {
+ return "Export graph in png format";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return exportGpng(command, interpreter);
+ }
+ };
+ // show all oppl
+ Command showAllOp = new Command() {
+ public String getCommand() {
+ return "showAllOp";
+ }
+
+ public String getShortCommand() {
+ return "showAllOp";
+ }
+
+ public String getDescription() {
+ return "Show all operators IDs";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return showAllOp(command, interpreter);
+ }
+ };
+ Command computeLatencyValues = new Command() {
+ public String getCommand() {
+ return "computeLatencyValues";
+ }
+
+ public String getShortCommand() {
+ return "computelat";
+ }
+
+ public String getDescription() {
+ return "Compute latency between two operators";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return computeLatencyValues(command, interpreter);
+ }
+ };
+ Command rowArrays = new Command() {
+ public String getCommand() {
+ return "rowArrays";
+ }
+
+ public String getShortCommand() {
+ return "rowArrays";
+ }
+
+ public String getDescription() {
+ return "Precise latency analysis by row";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return PlanByRow(command, interpreter);
+ }
+ };
addAndSortSubcommand(graph);
addAndSortSubcommand(latency);
addAndSortSubcommand(listAllOp);
addAndSortSubcommand(preciseLatByRow);
+ addAndSortSubcommand(generateGraph);
+ addAndSortSubcommand(exportGraphGraphml);
+ addAndSortSubcommand(saveGraph);
+ addAndSortSubcommand(showAllOp);
+ addAndSortSubcommand(computeLatencyValues);
+ addAndSortSubcommand(rowArrays);
}
private String generateGraph(String command, Interpreter interpreter) {
@@ -257,7 +377,6 @@ public class Plan extends Command {
}
private String computeLat(String command, Interpreter interpreter) {
- // TODO Auto-generated method stub
String[] commands = command.split(" ");
String task1 = null, task2 = null;
int operator1ID = Integer.valueOf(commands[0]);
@@ -338,4 +457,162 @@ public class Plan extends Command {
}
return null;
}
+
+ private String PlanByRow(String command, Interpreter interpreter) {
+ String[] commands = command.split(" ");
+ String i = commands[0];
+ Boolean minmax = Boolean.parseBoolean(commands[1]);
+ String filename = commands[2];
+ interpreter.print("minmax " + minmax);
+ interpreter.print("taint" + taint);
+ int row = Integer.valueOf(i);
+ if (!minmax && !taint) {
+ dgraph.getRowDetailsMinMax(row);
+ }
+ // detailedLatency = dgt.getTaskByRowDetails(id);
+ // interpreter.print("detailedLatency.length=" + detailedLatency.length);
+ // detailedLatency = dgt.getTaskHWByRowDetails(id);
+ // // interpreter.print("detailedLatency.length=" + detailedLatency.length);
+ PlanArrays arrays = new PlanArrays();
+ arrays.fillArrays(dgraph, row, !minmax, taint);
+ interpreter.print("dgraph.getOffPathBehavior=" + dgraph.getOffPath().size());
+ interpreter.print("dgraph.getOffPathBehaviorCausingDelay=" + dgraph.getOffPathDelay().size());
+ interpreter.print("dgraph.getOnPath=" + dgraph.getOnPath().size());
+ dgraph.saveDetailsToXML(filename);
+ return null;
+ }
+
+ @SuppressWarnings({ "rawtypes", "unchecked" })
+ private String generateGraphFromTML(String command, Interpreter interpreter) {
+ String[] commands = command.split(" ");
+ String tmapLocation = commands[0];
+ String[] l = commands[0].split("/");
+ String loctaion = "";
+ interpreter.print(l[l.length - 1]);
+ String fName = l[l.length - 1].replace(".tmap", "");
+ interpreter.print(fName);
+ loctaion = l[0];
+ for (int i = 1; i < l.length - 1; i++) {
+ loctaion = loctaion + "/" + l[i];
+ }
+ loctaion = loctaion + "/";
+ interpreter.print(loctaion);
+ String spec = null;
+ File f = new File(commands[0]);
+ TMLMappingTextSpecification tmts = new TMLMappingTextSpecification(fName);
+ interpreter.print(tmts.toString() + "tmts");
+ try {
+ interpreter.print(f.getPath() + "f");
+ spec = FileUtils.loadFileData(f);
+ } catch (Exception e) {
+ }
+ interpreter.print(spec.toString() + "spec");
+ boolean parsed = tmts.makeTMLMapping(spec, loctaion);
+ interpreter.print(tmts.toString() + "tmts");
+ tmap = tmts.getTMLMapping();
+ if (tmap == null) {
+ interpreter.print(tmap + "is null");
+ }
+ syntax = new TMLSyntaxChecking(tmap);
+ syntax.checkSyntax();
+ dgraph = new DependencyGraphTranslator(tmap);
+ dgraph.DrawDirectedGraph();
+ interpreter.print("Draw done");
+ return null;
+ }
+
+ private String exportGGraphml(String command, Interpreter interpreter) {
+ String f = command;
+ try {
+ dgraph.exportGraph(f);
+ interpreter.print("print done");
+ } catch (ExportException e) {
+ interpreter.print(e.getMessage());
+ } catch (IOException e) {
+ interpreter.print(e.getMessage());
+ }
+ return null;
+ }
+
+ private String exportGpng(String command, Interpreter interpreter) {
+ String f = command;
+ try {
+ dgraph.showGraph(dgraph);
+ dgraph.getFrame().setVisible(false);
+ dgraph.exportGraphAsImage(f);
+ interpreter.print("print done");
+ } catch (ExportException e) {
+ interpreter.print(e.getMessage());
+ } catch (IOException e) {
+ interpreter.print(e.getMessage());
+ }
+ return null;
+ }
+
+ private String showAllOp(String command, Interpreter interpreter) {
+ TMLActivity activity;
+ for (TMLTask tmltask : tmap.getTMLModeling().getTasks()) {
+ activity = tmltask.getActivityDiagram();
+ List<TMLActivityElement> list = activity.getElements();
+ Iterator<TMLActivityElement> iterator = list.listIterator();
+ TMLActivityElement tgc;
+ iterator = list.listIterator();
+ while (iterator.hasNext()) {
+ tgc = iterator.next();
+ String compName = "";
+ compName = tmltask.getName() + ":" + tgc.getName();
+ compName = compName.replaceAll(" ", "");
+ checkedT.put(compName + "__" + tgc.getID(), tgc.getID());
+ }
+ }
+ for (Entry<String, Integer> cT : checkedT.entrySet()) {
+ interpreter.print(cT.getValue() + "--" + cT.getKey());
+ }
+ ;
+ return null;
+ }
+
+ private String computeLatencyValues(String command, Interpreter interpreter) {
+ String[] commands = command.split(" ");
+ String task1 = null, task2 = null;
+ int operator1ID = Integer.valueOf(commands[0]);
+ int operator2ID = Integer.valueOf(commands[1]);
+ taint = Boolean.parseBoolean(commands[2]);
+ String filename = commands[3];
+ traceFile = commands[4];
+ interpreter.print("transFile1=" + traceFile);
+ for (Entry<String, Integer> cT : checkedT.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == operator1ID) {
+ task1 = taskName;
+ } else if (id == operator2ID) {
+ task2 = taskName;
+ }
+ }
+ interpreter.print("task1=" + task1);
+ interpreter.print("task2=" + task2);
+ interpreter.print("taint=" + taint);
+ transFile1 = dgraph.parseFile(new File(traceFile));
+ interpreter.print("transFile1=" + transFile1.size());
+ if (task1 != null && task2 != null && transFile1 != null && taint != null) {
+ allLatencies = dgraph.latencyDetailedAnalysis(task1, task2, transFile1, taint, false);
+ interpreter.print("lat=" + allLatencies.length);
+ if (taint) {
+ minMaxArray = dgraph.latencyMinMaxAnalysisTaintedData(task1, task2, transFile1);
+ } else {
+ minMaxArray = dgraph.latencyMinMaxAnalysis(task1, task2, transFile1);
+ }
+ // dgt.getRowDetailsMinMax(1);
+ // taskHWByRowDetails = dgt.getTasksByRowMinMax(1);
+ interpreter.print("minMaxArray.length=" + minMaxArray.length);
+ // interpreter.print("taskHWByRowDetails.length=" + taskHWByRowDetails.length);
+ // taskHWByRowDetails = dgt.getTaskHWByRowDetailsMinMax(1);
+ // interpreter.print("taskHWByRowDetails.length=" + taskHWByRowDetails.length);
+ dgraph.saveLAtencyValuesToXML(filename);
+ } else {
+ interpreter.print("one of the inputs is empty");
+ }
+ return null;
+ }
}
diff --git a/src/main/java/simulationtraceanalysis/CompareSimulationTrace.java b/src/main/java/simulationtraceanalysis/CompareSimulationTrace.java
new file mode 100644
index 0000000000000000000000000000000000000000..00f959a7f830d17e43c4277fc06e3b0cd3ead209
--- /dev/null
+++ b/src/main/java/simulationtraceanalysis/CompareSimulationTrace.java
@@ -0,0 +1,178 @@
+/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+ *
+ * ludovic.apvrille AT enst.fr
+ *
+ * This software is a computer program whose purpose is to allow the
+ * edition of TURTLE analysis, design and deployment diagrams, to
+ * allow the generation of RT-LOTOS or Java code from this diagram,
+ * and at last to allow the analysis of formal validation traces
+ * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+ * from INRIA Rhone-Alpes.
+ *
+ * This software is governed by the CeCILL license under French law and
+ * abiding by the rules of distribution of free software. You can use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ *
+ * As a counterpart to the access to the source code and rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty and the software's author, the holder of the
+ * economic rights, and the successive licensors have only limited
+ * liability.
+ *
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading, using, modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean that it is complicated to manipulate, and that also
+ * therefore means that it is reserved for developers and experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and, more generally, to use and operate it in the
+ * same conditions as regards security.
+ *
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ */
+package simulationtraceanalysis;
+
+import java.util.Vector;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.event.TableModelEvent;
+import javax.swing.event.TableModelListener;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+import javax.swing.table.TableModel;
+import ui.interactivesimulation.SimulationTransaction;
+import ui.simulationtraceanalysis.SimulationTraceTableRenderer;
+
+/**
+ * Class JPanelCompareXmlGraph : arranges the two simulation traces in a table
+ * and load the table to the compare pop up . It includes functionality to show
+ * the difference in the simulation traces and to load the drop down for latency
+ * compare later
+ *
+ * Creation: 19/07/2019
+ *
+ * @author Maysam ZOOR
+ */
+public class CompareSimulationTrace extends JPanel implements TableModelListener {
+ private static JTable table;
+ private String[] columnNames;
+ private Object[][] data;
+
+ public TableModel JPanelCompareXmlGraph(Vector<SimulationTransaction> transFile1, Vector<SimulationTransaction> transFile2) {
+ // super(new GridLayout(1, 0));
+ if (!transFile1.isEmpty() || !transFile2.isEmpty()) {
+ int maxTime = -1;
+ Vector<String> deviceNames1 = new Vector<String>();
+ Vector<String> deviceNames2 = new Vector<String>();
+ for (SimulationTransaction st : transFile1) {
+ if (Integer.parseInt(st.endTime) > maxTime) {
+ maxTime = Integer.parseInt(st.endTime);
+ }
+ if (!deviceNames1.contains(st.deviceName)) {
+ deviceNames1.add(st.deviceName);
+ }
+ }
+ for (SimulationTransaction st : transFile2) {
+ if (Integer.parseInt(st.endTime) > maxTime) {
+ maxTime = Integer.parseInt(st.endTime);
+ }
+ if (!deviceNames2.contains(st.deviceName)) {
+ deviceNames2.add(st.deviceName);
+ }
+ }
+ Vector<String> allDevices = new Vector<String>();
+ for (String device : deviceNames1) {
+ if (!deviceNames2.contains(device)) {
+ allDevices.add(device.concat("1"));
+ } else {
+ allDevices.add(device.concat("1"));
+ allDevices.add(device.concat("2"));
+ }
+ }
+ for (String device : deviceNames2) {
+ if (!deviceNames1.contains(device)) {
+ allDevices.add(device.concat("2"));
+ }
+ }
+ columnNames = new String[maxTime + 2];
+ data = new Object[deviceNames1.size() + deviceNames2.size()][maxTime + 2];
+ columnNames[0] = "Device Name";
+ columnNames[1] = "Trace Name";
+ for (SimulationTransaction st : transFile1) {
+ for (String dName : deviceNames1) {
+ if (st.deviceName.equals(dName)) {
+ for (int i = 0; i < Integer.parseInt(st.length); i++) {
+ String[] sentences2 = null;
+ sentences2 = st.command.split("__");
+ if (sentences2[0].contains(",") && sentences2.length > 1) {
+ String[] writeCommand = sentences2[0].split(",");
+ st.command = writeCommand[0] + " " + sentences2[1];
+ } else if (sentences2[0].contains(" ") && sentences2.length > 1) {
+ String[] writeCommand = sentences2[0].split(" ");
+ st.command = writeCommand[0] + " " + sentences2[1];
+ }
+ data[allDevices.indexOf(dName.concat("1"))][Integer.parseInt(st.startTime) + i + 2] = st.command;
+ ;
+ data[allDevices.indexOf(dName.concat("1"))][1] = "transFile 1";
+ }
+ }
+ }
+ }
+ for (SimulationTransaction st : transFile2) {
+ for (String dName : deviceNames2) {
+ if (st.deviceName.equals(dName)) {
+ for (int i = 0; i < Integer.parseInt(st.length); i++) {
+ String[] sentences2 = null;
+ sentences2 = st.command.split("__");
+ if (sentences2[0].contains(",") && sentences2.length > 1) {
+ String[] writeCommand = sentences2[0].split(",");
+ st.command = writeCommand[0] + " " + sentences2[1];
+ } else if (sentences2[0].contains(" ") && sentences2.length > 1) {
+ String[] writeCommand = sentences2[0].split(" ");
+ st.command = writeCommand[0] + " " + sentences2[1];
+ }
+ data[allDevices.indexOf(dName.concat("2"))][Integer.parseInt(st.startTime) + i + 2] = st.command;
+ data[allDevices.indexOf(dName.concat("2"))][1] = "transFile 2";
+ }
+ }
+ }
+ }
+ for (String dName : allDevices) {
+ data[allDevices.indexOf(dName)][0] = dName.substring(0, dName.length() - 1);
+ ;
+ }
+ for (int i = 2; i < maxTime + 2; i++) {
+ columnNames[i] = Integer.toString(i - 2);
+ }
+ table = new JTable(data, columnNames);
+ table.setFillsViewportHeight(true);
+ table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
+ SimulationTraceTableRenderer tr = new SimulationTraceTableRenderer();
+ int ncols = table.getColumnCount();
+ table.getModel().addTableModelListener(this);
+ TableColumnModel tcm = table.getColumnModel();
+ for (int c = 0; c < ncols; c++) {
+ TableColumn tc = tcm.getColumn(c);
+ tc.setCellRenderer(tr);
+ }
+ }
+ return table.getModel();
+ }
+
+ @Override
+ public void tableChanged(TableModelEvent e) {
+ }
+
+ public JTable getTable() {
+ return table;
+ }
+
+ public static void setTable(TableModel tableModel) {
+ table.setModel(tableModel);
+ }
+}
diff --git a/src/main/java/simulationtraceanalysis/DependencyGraphRelations.java b/src/main/java/simulationtraceanalysis/DependencyGraphRelations.java
new file mode 100644
index 0000000000000000000000000000000000000000..af3a9e69bb1f6a1ac19aa887489c4664af7d8331
--- /dev/null
+++ b/src/main/java/simulationtraceanalysis/DependencyGraphRelations.java
@@ -0,0 +1,203 @@
+package simulationtraceanalysis;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Vector;
+
+public class DependencyGraphRelations {
+ private final HashMap<String, HashSet<String>> sendEventWaitEventEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> readWriteChannelEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> writeReadChannelEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> forkreadEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> forkwriteEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> joinreadEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> joinwriteEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, HashSet<String>> sequenceEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, ArrayList<String>> orderedSequenceList = new HashMap<String, ArrayList<String>>();
+ private final HashMap<String, HashSet<String>> unOrderedSequenceEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, ArrayList<String>> unOrderedSequenceList = new HashMap<String, ArrayList<String>>();
+ private HashMap<String, ArrayList<ArrayList<Integer>>> runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
+ private HashMap<String, List<String>> allForLoopNextValues = new HashMap<String, List<String>>();
+ private HashMap<Vertex, List<Vertex>> allChoiceValues = new HashMap<Vertex, List<Vertex>>();
+ private HashMap<Vertex, List<Vertex>> allSelectEvtValues = new HashMap<Vertex, List<Vertex>>();
+ private HashMap<Vertex, List<Vertex>> allSeqValues = new HashMap<Vertex, List<Vertex>>();
+ private HashMap<Vertex, List<Vertex>> allRandomSeqValues = new HashMap<Vertex, List<Vertex>>();
+ private final List<String> forEverLoopList = new ArrayList<String>();
+ private final HashMap<String, HashSet<String>> requestEdges = new HashMap<String, HashSet<String>>();
+ private final HashMap<String, List<String>> requestsOriginDestination = new HashMap<String, List<String>>();
+ private final HashMap<String, List<String>> requestsPorts = new HashMap<String, List<String>>();
+ private final HashMap<String, List<String>> requestsDestination = new HashMap<String, List<String>>();
+ private HashMap<String, List<String>> forLoopNextValues = new HashMap<String, List<String>>();
+ private HashMap<String, List<String>> sendEvt = new HashMap<String, List<String>>();
+ private HashMap<String, List<String>> waitEvt = new HashMap<String, List<String>>();
+ private HashMap<String, String> sendData = new HashMap<String, String>();
+ private HashMap<String, String> receiveData = new HashMap<String, String>();
+ private Vector<String> readChannelTransactions = new Vector<String>();
+ private Vector<String> writeChannelTransactions = new Vector<String>();
+ private HashMap<Vertex, List<Vertex>> ruleAddedEdges = new HashMap<Vertex, List<Vertex>>();
+ private HashMap<Vertex, List<Vertex>> ruleAddedEdgesChannels = new HashMap<Vertex, List<Vertex>>();
+
+ public void setRuleAddedEdgesChannels(HashMap<Vertex, List<Vertex>> ruleAddedEdgesChannels) {
+ this.ruleAddedEdgesChannels = ruleAddedEdgesChannels;
+ }
+
+ private HashMap<String, Integer> cpuIDs = new HashMap<String, Integer>();
+
+ public void setForLoopNextValues(HashMap<String, List<String>> forLoopNextValues) {
+ this.forLoopNextValues = forLoopNextValues;
+ }
+
+ public void setSendEvt(HashMap<String, List<String>> sendEvt) {
+ this.sendEvt = sendEvt;
+ }
+
+ public void setWaitEvt(HashMap<String, List<String>> waitEvt) {
+ this.waitEvt = waitEvt;
+ }
+
+ public void setSendData(HashMap<String, String> sendData) {
+ this.sendData = sendData;
+ }
+
+ public void setReceiveData(HashMap<String, String> receiveData) {
+ this.receiveData = receiveData;
+ }
+
+ public List<String> getForEverLoopList() {
+ return forEverLoopList;
+ }
+
+ public HashMap<String, HashSet<String>> getRequestEdges() {
+ return requestEdges;
+ }
+
+ public HashMap<String, List<String>> getRequestsOriginDestination() {
+ return requestsOriginDestination;
+ }
+
+ public HashMap<String, List<String>> getRequestsPorts() {
+ return requestsPorts;
+ }
+
+ public HashMap<String, List<String>> getRequestsDestination() {
+ return requestsDestination;
+ }
+
+ public HashMap<String, List<String>> getForLoopNextValues() {
+ return forLoopNextValues;
+ }
+
+ public HashMap<String, List<String>> getSendEvt() {
+ return sendEvt;
+ }
+
+ public HashMap<String, List<String>> getWaitEvt() {
+ return waitEvt;
+ }
+
+ public HashMap<String, String> getSendData() {
+ return sendData;
+ }
+
+ public HashMap<String, String> getReceiveData() {
+ return receiveData;
+ }
+
+ public HashMap<String, HashSet<String>> getSendEventWaitEventEdges() {
+ return sendEventWaitEventEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getReadWriteChannelEdges() {
+ return readWriteChannelEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getWriteReadChannelEdges() {
+ return writeReadChannelEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getForkreadEdges() {
+ return forkreadEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getForkwriteEdges() {
+ return forkwriteEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getJoinreadEdges() {
+ return joinreadEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getJoinwriteEdges() {
+ return joinwriteEdges;
+ }
+
+ public HashMap<String, HashSet<String>> getSequenceEdges() {
+ return sequenceEdges;
+ }
+
+ public HashMap<String, ArrayList<String>> getOrderedSequenceList() {
+ return orderedSequenceList;
+ }
+
+ public HashMap<String, HashSet<String>> getUnOrderedSequenceEdges() {
+ return unOrderedSequenceEdges;
+ }
+
+ public HashMap<String, ArrayList<String>> getUnOrderedSequenceList() {
+ return unOrderedSequenceList;
+ }
+
+ public HashMap<String, ArrayList<ArrayList<Integer>>> getRunnableTimePerDevice() {
+ return runnableTimePerDevice;
+ }
+
+ public HashMap<String, List<String>> getAllForLoopNextValues() {
+ return allForLoopNextValues;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getAllChoiceValues() {
+ return allChoiceValues;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getAllSelectEvtValues() {
+ return allSelectEvtValues;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getAllSeqValues() {
+ return allSeqValues;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getAllRandomSeqValues() {
+ return allRandomSeqValues;
+ }
+
+ public void setRunnableTimePerDevice(HashMap<String, ArrayList<ArrayList<Integer>>> runnableTimePerDevice) {
+ this.runnableTimePerDevice = runnableTimePerDevice;
+ }
+
+ public Vector<String> getReadChannelTransactions() {
+ return readChannelTransactions;
+ }
+
+ public Vector<String> getWriteChannelTransactions() {
+ return writeChannelTransactions;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getRuleAddedEdges() {
+ return ruleAddedEdges;
+ }
+
+ public HashMap<Vertex, List<Vertex>> getRuleAddedEdgesChannels() {
+ return ruleAddedEdgesChannels;
+ }
+
+ public HashMap<String, Integer> getCpuIDs() {
+ return cpuIDs;
+ }
+
+ public void setRuleAddedEdges(HashMap<Vertex, List<Vertex>> ruleAddedEdges) {
+ this.ruleAddedEdges = ruleAddedEdges;
+ }
+}
diff --git a/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java b/src/main/java/simulationtraceanalysis/DependencyGraphTranslator.java
similarity index 76%
rename from src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java
rename to src/main/java/simulationtraceanalysis/DependencyGraphTranslator.java
index 33492b3d6d3ae4fade5508a44bff171d9438ecb1..0992fec333c39ea59a993737cf23695bef857bac 100644
--- a/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java
+++ b/src/main/java/simulationtraceanalysis/DependencyGraphTranslator.java
@@ -35,11 +35,43 @@
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*/
-package ui.simulationtraceanalysis;
+package simulationtraceanalysis;
-import com.mxgraph.layout.hierarchical.mxHierarchicalLayout;
-import com.mxgraph.swing.mxGraphComponent;
-import avatartranslator.AvatarStateMachineElement;
+import java.awt.Container;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.Vector;
+import javax.imageio.ImageIO;
+import javax.swing.JFrame;
+import javax.swing.JScrollPane;
+import javax.swing.SwingWorker;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.parsers.SAXParser;
+import javax.xml.parsers.SAXParserFactory;
+import javax.xml.transform.OutputKeys;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerConfigurationException;
+import javax.xml.transform.TransformerException;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.TransformerFactoryConfigurationError;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
import org.jgrapht.Graph;
import org.jgrapht.GraphPath;
import org.jgrapht.Graphs;
@@ -48,44 +80,58 @@ import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
import org.jgrapht.ext.JGraphXAdapter;
import org.jgrapht.graph.DefaultDirectedGraph;
import org.jgrapht.graph.DefaultEdge;
-import org.jgrapht.io.*;
+import org.jgrapht.io.ComponentNameProvider;
+import org.jgrapht.io.EdgeProvider;
+import org.jgrapht.io.ExportException;
+import org.jgrapht.io.GraphMLExporter;
+import org.jgrapht.io.GraphMLImporter;
+import org.jgrapht.io.ImportException;
+import org.jgrapht.io.VertexProvider;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
-import tmltranslator.*;
+import org.xml.sax.SAXException;
+import com.mxgraph.layout.hierarchical.mxHierarchicalLayout;
+import com.mxgraph.swing.mxGraphComponent;
+import tmltranslator.DIPLOElement;
+import tmltranslator.HwA;
+import tmltranslator.HwCommunicationNode;
+import tmltranslator.HwLink;
+import tmltranslator.HwNode;
+import tmltranslator.TMLActionState;
+import tmltranslator.TMLActivity;
+import tmltranslator.TMLActivityElement;
+import tmltranslator.TMLAttribute;
+import tmltranslator.TMLChannel;
+import tmltranslator.TMLChoice;
+import tmltranslator.TMLDelay;
+import tmltranslator.TMLElement;
+import tmltranslator.TMLEvent;
+import tmltranslator.TMLExecC;
+import tmltranslator.TMLExecCInterval;
+import tmltranslator.TMLExecI;
+import tmltranslator.TMLExecIInterval;
+import tmltranslator.TMLForLoop;
+import tmltranslator.TMLMapping;
+import tmltranslator.TMLNotifiedEvent;
+import tmltranslator.TMLRandom;
+import tmltranslator.TMLRandomSequence;
+import tmltranslator.TMLReadChannel;
+import tmltranslator.TMLRequest;
+import tmltranslator.TMLSelectEvt;
+import tmltranslator.TMLSendEvent;
+import tmltranslator.TMLSendRequest;
+import tmltranslator.TMLSequence;
+import tmltranslator.TMLStartState;
+import tmltranslator.TMLStopState;
+import tmltranslator.TMLTask;
+import tmltranslator.TMLWaitEvent;
+import tmltranslator.TMLWriteChannel;
import tmltranslator.tomappingsystemc2.DiploSimulatorCodeGenerator;
import ui.TGComponent;
-import ui.TGConnectingPoint;
-import ui.TGConnector;
-import ui.TMLComponentDesignPanel;
-import ui.ad.TADComponentWithSubcomponents;
-import ui.ad.TADComponentWithoutSubcomponents;
import ui.interactivesimulation.SimulationTransaction;
-import ui.tmlad.*;
+import ui.interactivesimulation.SimulationTransactionParser;
import ui.tmlcompd.TMLCPrimitivePort;
-import javax.imageio.ImageIO;
-import javax.swing.*;
-import javax.xml.bind.JAXBContext;
-import javax.xml.bind.JAXBException;
-import javax.xml.bind.Marshaller;
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.parsers.ParserConfigurationException;
-import javax.xml.transform.OutputKeys;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerConfigurationException;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.TransformerFactoryConfigurationError;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.io.*;
-import java.math.BigDecimal;
-import java.util.*;
-import java.util.List;
-import java.util.Map.Entry;
/**
* Class DirectedGraphTranslator: this class generate the directed graph
@@ -95,52 +141,25 @@ import java.util.Map.Entry;
*
* @author Maysam Zoor
*/
-public class DirectedGraphTranslator extends JApplet {
- private TMLTask taskAc, task1, task2;
+public class DependencyGraphTranslator extends SwingWorker {
+ private TMLTask taskAc;
private TMLActivity activity;
private int nodeNbProgressBar = 0;
- private int nodeNb = 0;
private TMLActivityElement currentElement;
- private TMLActivityElement backwardElement;
- private ArrayList<String> SummaryCommMapping;
- private Graph<vertex, DefaultEdge> g;
- private static final Dimension DEFAULT_SIZE = new Dimension(530, 320);
- private List<TMLComponentDesignPanel> cpanels;
+ private Graph<Vertex, DefaultEdge> g;
private final List<HwLink> links;
private final TMLMapping<TGComponent> tmap;
private final HashMap<String, String> addedEdges = new HashMap<String, String>();
- private final HashMap<String, HashSet<String>> sendEventWaitEventEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> readWriteChannelEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> writeReadChannelEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> forkreadEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> forkwriteEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> joinreadEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> joinwriteEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, HashSet<String>> sequenceEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, ArrayList<String>> orderedSequenceList = new HashMap<String, ArrayList<String>>();
- private final HashMap<String, HashSet<String>> unOrderedSequenceEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, ArrayList<String>> unOrderedSequenceList = new HashMap<String, ArrayList<String>>();
- private final List<String> forEverLoopList = new ArrayList<String>();
- private final HashMap<String, List<TMLTask>> requests = new HashMap<String, List<TMLTask>>();
- private final HashMap<String, HashSet<String>> requestEdges = new HashMap<String, HashSet<String>>();
- private final HashMap<String, List<String>> requestsOriginDestination = new HashMap<String, List<String>>();
- private final HashMap<String, List<String>> requestsPorts = new HashMap<String, List<String>>();
- private final HashMap<String, List<String>> requestsDestination = new HashMap<String, List<String>>();
private final Vector<String> allLatencyTasks = new Vector<String>();
private static JScrollPane scrollPane = new JScrollPane();
private final HashMap<String, String> nameIDTaskList = new HashMap<String, String>();
private final HashMap<String, ArrayList<String>> channelPaths = new HashMap<String, ArrayList<String>>();
private Object[][] dataByTask = null;
private Object[][] dataByTaskMinMax = null;
- private Object[][] dataByTaskBYRow;
- private Object[][] dataByTaskHWBYRow;
private HashMap<Integer, Vector<SimulationTransaction>> dataByTaskR = new HashMap<Integer, Vector<SimulationTransaction>>();
private HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
private HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRow = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
private HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRowMinMax = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
- private HashMap<Integer, List<String>> detailsOfMinMaxRow = new HashMap<Integer, List<String>>();
- private HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasksOfMinMAx = new HashMap<Integer, List<SimulationTransaction>>();
- private final JFrame frame = new JFrame("The SysML Model As Directed Graph");
private List<Integer> times1 = new ArrayList<Integer>();
private List<Integer> times2 = new ArrayList<Integer>();
private Vector<SimulationTransaction> transFile;
@@ -154,40 +173,19 @@ public class DirectedGraphTranslator extends JApplet {
private Vector<SimulationTransaction> relatedsimTraces = new Vector<SimulationTransaction>();
private Vector<SimulationTransaction> delayDueTosimTraces = new Vector<SimulationTransaction>();
private HashMap<String, ArrayList<SimulationTransaction>> relatedsimTraceswithTaint = new HashMap<String, ArrayList<SimulationTransaction>>();
- private JFrameLatencyDetailedAnalysis frameLatencyDetailedAnalysis;
- private JFrameCompareLatencyDetail frameCompareLatencyDetail;
- private int callingFrame;
private int nbOfNodes = 0;
private List<String> usedLabels = new ArrayList<String>();
private List<String> warnings = new ArrayList<String>();
+ private List<String> errors = new ArrayList<String>();
private static Random random = new Random();
- private static final String CHAR_LOWER = "abcdefghijklmnopqrstuvwxyz";
- private static final String CHAR_UPPER = CHAR_LOWER.toUpperCase();
- private static final String DATA = CHAR_LOWER + CHAR_UPPER;
- private HashMap<String, ArrayList<ArrayList<Integer>>> runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
- private HashMap<String, List<String>> allForLoopNextValues = new HashMap<String, List<String>>();
- private HashMap<vertex, List<vertex>> allChoiceValues = new HashMap<vertex, List<vertex>>();
- private HashMap<vertex, List<vertex>> allSelectEvtValues = new HashMap<vertex, List<vertex>>();
- private HashMap<vertex, List<vertex>> allSeqValues = new HashMap<vertex, List<vertex>>();
- private HashMap<vertex, List<vertex>> allRandomSeqValues = new HashMap<vertex, List<vertex>>();
private String taintLabel = "";
- private Vector<String> readChannelTransactions = new Vector<String>();
- private Vector<String> writeChannelTransactions = new Vector<String>();
- private HashMap<vertex, List<vertex>> ruleAddedEdges = new HashMap<vertex, List<vertex>>();
- private HashMap<vertex, List<vertex>> ruleAddedEdgesChannels = new HashMap<vertex, List<vertex>>();
- private HashMap<String, Integer> cpuIDs = new HashMap<String, Integer>();
- private HashMap<String, Integer> fpgaIDs = new HashMap<String, Integer>();
- private HashMap<String, List<String>> forLoopNextValues = new HashMap<String, List<String>>();
private int opCount;
- private HashMap<String, List<String>> sendEvt = new HashMap<String, List<String>>();
- private HashMap<String, List<String>> waitEvt = new HashMap<String, List<String>>();
- private HashMap<String, String> sendData = new HashMap<String, String>();
- private HashMap<String, String> receiveData = new HashMap<String, String>();
private String taskStartName = "";
private List<SimulationTransaction> onPath = new ArrayList<SimulationTransaction>();
private List<SimulationTransaction> offPath = new ArrayList<SimulationTransaction>();
private List<SimulationTransaction> offPathDelay = new ArrayList<SimulationTransaction>();
private final HashMap<String, Integer> allChannels = new HashMap<String, Integer>();
+ private static final String MODEL_AS_GRAPH = "The SysML Model As Dependency Graph";
private static final String SELECT_EVENT_PARAM = "SelectEvent params:";
private static final String SELECT_EVENT = "SelectEvent";
private static final String TRANSACTIONS = "Transactions";
@@ -211,7 +209,7 @@ public class DirectedGraphTranslator extends JApplet {
private static final String WAIT_REQ_LABEL = "Wait reqChannel_";
private static final String GET_REQ_ARG_LABEL = "getReqArg";
private static final String WAIT_ST = "Wait: ";
- private static final String WAIT_EVENT = "wait event: ";
+ private static final String WAIT_EVENT = "Wait event: ";
private static final String STOP_AFTER_INFINITE_LOOP = "Stop after infinite loop";
private static final String START_OF_FORK = "startOfFork";
private static final String START_OF_JOIN = "startOfJoin";
@@ -250,41 +248,30 @@ public class DirectedGraphTranslator extends JApplet {
private static final String START = "start";
private static final String WAITEVENT = "waitevent:";
private static final String SENDEVENT = "sendevent:";
+ private static final String CHAR_LOWER = "abcdefghijklmnopqrstuvwxyz";
+ private static final String CHAR_UPPER = CHAR_LOWER.toUpperCase();
+ private static final String DATA = CHAR_LOWER + CHAR_UPPER;
+ private final JFrame frame = new JFrame(MODEL_AS_GRAPH);
+ private DependencyGraphRelations dependencyGraphRelations = new DependencyGraphRelations();
@SuppressWarnings("deprecation")
- public DirectedGraphTranslator(JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis, JFrameCompareLatencyDetail jframeCompareLatencyDetail,
- TMLMapping<TGComponent> tmap1, List<TMLComponentDesignPanel> cpanels1, int i) {
+ public DependencyGraphTranslator(TMLMapping<TGComponent> tmap1) {
tmap = tmap1;
- setCpanels(cpanels1);
links = tmap.getTMLArchitecture().getHwLinks();
- callingFrame = i;
- if (callingFrame == 0) {
- frameLatencyDetailedAnalysis = jFrameLatencyDetailedAnalysis;
- } else if (callingFrame == 1) {
- frameCompareLatencyDetail = jframeCompareLatencyDetail;
- }
- DrawDirectedGraph();
+ nodeNbProgressBar = 0;
+ nodeNbProgressBar = tmap.getArch().getBUSs().size() + tmap.getArch().getHwBridge().size() + tmap.getArch().getHwA().size()
+ + tmap.getArch().getMemories().size() + tmap.getArch().getCPUs().size();
+ expectedNumberofVertex();
+ // DrawDirectedGraph();
}
// The main function to add the vertices and edges according to the model
- public vertex vertex(String name, int id) {
- vertex v = new vertex(name, id);
+ public Vertex Vertex(String name, int id) {
+ Vertex v = new Vertex(name, id);
return v;
}
- private void DrawDirectedGraph() {
- nodeNbProgressBar = 0;
- nodeNbProgressBar = tmap.getArch().getBUSs().size() + tmap.getArch().getHwBridge().size() + tmap.getArch().getHwA().size()
- + tmap.getArch().getMemories().size() + tmap.getArch().getCPUs().size();
- expectedNumberofVertex();
- if (callingFrame == 0) {
- frameLatencyDetailedAnalysis.getPbar().setMaximum(nodeNbProgressBar);
- frameLatencyDetailedAnalysis.getPbar().setMinimum(0);
- }
- if (callingFrame == 1) {
- frameCompareLatencyDetail.getPbar().setMaximum(nodeNbProgressBar);
- frameCompareLatencyDetail.getPbar().setMinimum(0);
- }
+ public void DrawDirectedGraph() {
nbOfNodes = 0;
// HashMap<String, HashSet<String>> cpuTasks;
HashMap<String, HashSet<TMLElement>> buschannel = new HashMap<String, HashSet<TMLElement>>();
@@ -313,6 +300,7 @@ public class DirectedGraphTranslator extends JApplet {
addSeqEdges();
addunOrderedSeqEdges();
addRequestEdges();
+ return;
}
private void addUnmappedchannel() {
@@ -322,12 +310,12 @@ public class DirectedGraphTranslator extends JApplet {
tmap.getHwNodeOf(ch.getDestinationTask()), ch);
String channelName = ch.getName() + "__" + ch.getID();
if (!g.vertexSet().contains(getvertex(channelName))) {
- g.addVertex(vertex(channelName, ch.getID()));
+ g.addVertex(Vertex(channelName, ch.getID()));
allChannels.put(ch.getName(), ch.getID());
- vertex v = getvertex(channelName);
+ Vertex v = getvertex(channelName);
updateMainBar();
// gVertecies.add(vertex(ch.getName()));
- v.setType(vertex.TYPE_CHANNEL);
+ v.setType(Vertex.getTypeChannel());
v.setTaintFixedNumber(0);
updateMainBar();
}
@@ -343,10 +331,10 @@ public class DirectedGraphTranslator extends JApplet {
channelPaths.put(channelName, pathNodeNames);
}
if (!g.vertexSet().contains(getvertex(node.getName()))) {
- g.addVertex(vertex(node.getName(), node.getID()));
+ g.addVertex(Vertex(node.getName(), node.getID()));
}
if (!g.vertexSet().contains(getvertex(channelName))) {
- g.addVertex(vertex(channelName, ch.getID()));
+ g.addVertex(Vertex(channelName, ch.getID()));
allChannels.put(ch.getName(), ch.getID());
}
if (!g.containsEdge(getvertex(node.getName()), getvertex(channelName))) {
@@ -355,14 +343,14 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- SummaryCommMapping = tmap.getSummaryCommMapping();
+ // SummaryCommMapping = tmap.getSummaryCommMapping();
}
private void addCPUs() {
HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
for (HwNode node : tmap.getArch().getCPUs()) {
cpuTask = new HashMap<String, HashSet<TMLTask>>();
- cpuIDs.put(node.getName(), node.getID());
+ dependencyGraphRelations.getCpuIDs().put(node.getName(), node.getID());
if (tmap.getLisMappedTasks(node).size() > 0) {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
@@ -376,7 +364,7 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
for (HwNode node : tmap.getArch().getFPGAs()) {
cpuTask = new HashMap<String, HashSet<TMLTask>>();
- cpuIDs.put(node.getName(), node.getID());
+ dependencyGraphRelations.getCpuIDs().put(node.getName(), node.getID());
if (tmap.getLisMappedTasks(node).size() > 0) {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
@@ -393,10 +381,10 @@ public class DirectedGraphTranslator extends JApplet {
for (TMLElement busCh : busChList) {
String channelName = busCh.getName() + "__" + busCh.getID();
if (!g.containsVertex(getvertex(channelName))) {
- g.addVertex(vertex(channelName, busCh.getID()));
+ g.addVertex(Vertex(channelName, busCh.getID()));
allChannels.put(busCh.getName(), busCh.getID());
updateMainBar();
- getvertex(channelName).setType(vertex.TYPE_CHANNEL);
+ getvertex(channelName).setType(Vertex.getTypeChannel());
// gVertecies.add(vertex(ChannelName));
getvertex(channelName).setTaintFixedNumber(0);
updateMainBar();
@@ -413,10 +401,10 @@ public class DirectedGraphTranslator extends JApplet {
for (TMLElement busCh : busChList) {
String ChannelName = busCh.getName() + "__" + busCh.getID();
if (!g.containsVertex(getvertex(ChannelName))) {
- g.addVertex(vertex(ChannelName, busCh.getID()));
+ g.addVertex(Vertex(ChannelName, busCh.getID()));
allChannels.put(busCh.getName(), busCh.getID());
updateMainBar();
- getvertex(ChannelName).setType(vertex.TYPE_CHANNEL);
+ getvertex(ChannelName).setType(Vertex.getTypeChannel());
// gVertecies.add(vertex(ChannelName));
getvertex(ChannelName).setTaintFixedNumber(0);
updateMainBar();
@@ -433,10 +421,10 @@ public class DirectedGraphTranslator extends JApplet {
for (TMLElement busCh : busChList) {
String ChannelName = busCh.getName() + "__" + busCh.getID();
if (!g.containsVertex(getvertex(ChannelName))) {
- g.addVertex(vertex(ChannelName, busCh.getID()));
+ g.addVertex(Vertex(ChannelName, busCh.getID()));
allChannels.put(busCh.getName(), busCh.getID());
updateMainBar();
- getvertex(ChannelName).setType(vertex.TYPE_CHANNEL);
+ getvertex(ChannelName).setType(Vertex.getTypeChannel());
// gVertecies.add(vertex(ChannelName));
getvertex(ChannelName).setTaintFixedNumber(0);
updateMainBar();
@@ -450,7 +438,7 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, HashSet<TMLElement>> memorychannel = new HashMap<String, HashSet<TMLElement>>();
for (HwNode node : tmap.getArch().getMemories()) {
if (!g.containsVertex(getvertex(node.getName()))) {
- g.addVertex(vertex(node.getName(), node.getID()));
+ g.addVertex(Vertex(node.getName(), node.getID()));
updateMainBar();
}
if (tmap.getLisMappedChannels(node).size() > 0) {
@@ -464,7 +452,7 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
for (HwA node : tmap.getArch().getHwA()) {
cpuTask = new HashMap<String, HashSet<TMLTask>>();
- cpuIDs.put(node.getName(), node.getID());
+ dependencyGraphRelations.getCpuIDs().put(node.getName(), node.getID());
if (tmap.getLisMappedTasks(node).size() > 0) {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
@@ -478,7 +466,7 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, HashSet<TMLElement>> bridgechannel = new HashMap<String, HashSet<TMLElement>>();
for (HwNode node : tmap.getArch().getHwBridge()) {
if (!g.containsVertex(getvertex(node.getName()))) {
- g.addVertex(vertex(node.getName(), node.getID()));
+ g.addVertex(Vertex(node.getName(), node.getID()));
updateMainBar();
}
if (tmap.getLisMappedChannels(node).size() > 0) {
@@ -492,7 +480,7 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, HashSet<TMLElement>> buschannel = new HashMap<String, HashSet<TMLElement>>();
for (HwNode node : tmap.getArch().getBUSs()) {
if (!g.containsVertex(getvertex(node.getName()))) {
- g.addVertex(vertex(node.getName(), node.getID()));
+ g.addVertex(Vertex(node.getName(), node.getID()));
updateMainBar();
}
if (tmap.getLisMappedChannels(node).size() > 0) {
@@ -504,8 +492,8 @@ public class DirectedGraphTranslator extends JApplet {
private void addLinkEdges() {
for (HwLink link : links) {
- vertex vlink1 = vertex(link.hwnode.getName(), link.hwnode.getID());
- vertex vlink2 = vertex(link.bus.getName(), link.bus.getID());
+ Vertex vlink1 = Vertex(link.hwnode.getName(), link.hwnode.getID());
+ Vertex vlink2 = Vertex(link.bus.getName(), link.bus.getID());
if (g.containsVertex(getvertex(link.hwnode.getName())) && g.containsVertex(getvertex(link.bus.getName()))) {
g.addEdge(vlink1, vlink2);
g.addEdge(vlink2, vlink1);
@@ -516,8 +504,8 @@ public class DirectedGraphTranslator extends JApplet {
private void addFlowEdges() {
if (addedEdges.size() > 0) {
for (Entry<String, String> edge : addedEdges.entrySet()) {
- vertex v = getvertex(edge.getKey());
- vertex v2 = getvertex(edge.getValue());
+ Vertex v = getvertex(edge.getKey());
+ Vertex v2 = getvertex(edge.getValue());
if (v != null && v2 != null) {
g.addEdge(v, v2);
}
@@ -526,11 +514,11 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addSendEventWaitEventEdges() {
- if (sendEventWaitEventEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : sendEventWaitEventEdges.entrySet()) {
- vertex v = getvertex(edge.getKey());
+ if (dependencyGraphRelations.getSendEventWaitEventEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getSendEventWaitEventEdges().entrySet()) {
+ Vertex v = getvertex(edge.getKey());
for (String waitEventEdge : edge.getValue()) {
- vertex v2 = getvertex(waitEventEdge);
+ Vertex v2 = getvertex(waitEventEdge);
if (v != null && v2 != null) {
g.addEdge(v, v2);
}
@@ -540,12 +528,12 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addReadWriteChannelEdges() {
- if (readWriteChannelEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : readWriteChannelEdges.entrySet()) {
+ if (dependencyGraphRelations.getReadWriteChannelEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getReadWriteChannelEdges().entrySet()) {
Integer id = allChannels.get(edge.getKey());
- vertex v = getvertex(edge.getKey() + "__" + id);
+ Vertex v = getvertex(edge.getKey() + "__" + id);
for (String readChannelEdge : edge.getValue()) {
- vertex v2 = getvertex(readChannelEdge);
+ Vertex v2 = getvertex(readChannelEdge);
if (v != null && v2 != null) {
g.addEdge(v, v2);
v.setTaintFixedNumber(v.getTaintFixedNumber() + 1);
@@ -556,14 +544,14 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addForkreadEdges() {
- if (forkreadEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : forkreadEdges.entrySet()) {
- HashSet<String> writech = forkwriteEdges.get(edge.getKey());
+ if (dependencyGraphRelations.getForkreadEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getForkreadEdges().entrySet()) {
+ HashSet<String> writech = dependencyGraphRelations.getForkwriteEdges().get(edge.getKey());
for (String readChannelEdge : edge.getValue()) {
- vertex v = getvertex(readChannelEdge);
+ Vertex v = getvertex(readChannelEdge);
if (v != null) {
for (String wch : writech) {
- vertex v2 = getvertex(wch);
+ Vertex v2 = getvertex(wch);
if (v2 != null) {
g.addEdge(v, v2);
}
@@ -576,14 +564,14 @@ public class DirectedGraphTranslator extends JApplet {
// draw the vertices and edges for the tasks mapped to the CPUs
private void addJoinreadEdges() {
- if (joinreadEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : joinreadEdges.entrySet()) {
- HashSet<String> writech = joinwriteEdges.get(edge.getKey());
+ if (dependencyGraphRelations.getJoinreadEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getJoinreadEdges().entrySet()) {
+ HashSet<String> writech = dependencyGraphRelations.getJoinwriteEdges().get(edge.getKey());
for (String readChannelEdge : edge.getValue()) {
- vertex v = getvertex(readChannelEdge);
+ Vertex v = getvertex(readChannelEdge);
if (v != null) {
for (String wch : writech) {
- vertex v2 = getvertex(wch);
+ Vertex v2 = getvertex(wch);
if (v2 != null) {
g.addEdge(v, v2);
}
@@ -595,12 +583,12 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addWriteReadChannelEdges() {
- if (writeReadChannelEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : writeReadChannelEdges.entrySet()) {
+ if (dependencyGraphRelations.getWriteReadChannelEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getWriteReadChannelEdges().entrySet()) {
for (String readChannelEdge : edge.getValue()) {
Integer id = allChannels.get(readChannelEdge);
- vertex v = getvertex(edge.getKey());
- vertex v2 = getvertex(readChannelEdge + "__" + id);
+ Vertex v = getvertex(edge.getKey());
+ Vertex v2 = getvertex(readChannelEdge + "__" + id);
if (v != null && v2 != null) {
g.addEdge(v, v2);
v2.setTaintFixedNumber(v2.getTaintFixedNumber() + 1);
@@ -611,11 +599,11 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addRequestEdges() {
- if (requestEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : requestEdges.entrySet()) {
- vertex v = getvertex(edge.getKey());
+ if (dependencyGraphRelations.getRequestEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getRequestEdges().entrySet()) {
+ Vertex v = getvertex(edge.getKey());
for (String requestsingleEdges : edge.getValue()) {
- vertex v2 = getvertex(requestsingleEdges);
+ Vertex v2 = getvertex(requestsingleEdges);
if (v != null && v2 != null) {
g.addEdge(v, v2);
}
@@ -625,11 +613,11 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addunOrderedSeqEdges() {
- if (unOrderedSequenceEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : unOrderedSequenceEdges.entrySet()) {
- vertex v = getvertex(edge.getKey());
+ if (dependencyGraphRelations.getUnOrderedSequenceEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getUnOrderedSequenceEdges().entrySet()) {
+ Vertex v = getvertex(edge.getKey());
for (String sequenceEdge : edge.getValue()) {
- vertex v2 = getvertex(sequenceEdge);
+ Vertex v2 = getvertex(sequenceEdge);
if (v != null && v2 != null) {
g.addEdge(v, v2);
}
@@ -639,11 +627,11 @@ public class DirectedGraphTranslator extends JApplet {
}
private void addSeqEdges() {
- if (sequenceEdges.size() > 0) {
- for (Entry<String, HashSet<String>> edge : sequenceEdges.entrySet()) {
- vertex v = getvertex(edge.getKey());
+ if (dependencyGraphRelations.getSequenceEdges().size() > 0) {
+ for (Entry<String, HashSet<String>> edge : dependencyGraphRelations.getSequenceEdges().entrySet()) {
+ Vertex v = getvertex(edge.getKey());
for (String sequenceEdge : edge.getValue()) {
- vertex v2 = getvertex(sequenceEdge);
+ Vertex v2 = getvertex(sequenceEdge);
if (v != null && v2 != null) {
g.addEdge(v, v2);
}
@@ -720,11 +708,7 @@ public class DirectedGraphTranslator extends JApplet {
private void updateMainBar() {
nbOfNodes++;
- if (callingFrame == 0) {
- frameLatencyDetailedAnalysis.updateBar(nbOfNodes);
- } else if (callingFrame == 1) {
- frameCompareLatencyDetail.updateBar(nbOfNodes);
- }
+ firePropertyChange("progress", nbOfNodes - 1, nbOfNodes);
}
public void getCPUTaskMap(HashMap<String, HashSet<TMLTask>> cpuTask) {
@@ -734,15 +718,16 @@ public class DirectedGraphTranslator extends JApplet {
}
for (Entry<String, HashSet<TMLTask>> entry : cpuTask.entrySet()) {
String key = entry.getKey();
- int keyID = cpuIDs.get(key);
+ int keyID = dependencyGraphRelations.getCpuIDs().get(key);
HashSet<TMLTask> value = entry.getValue();
Vector<TMLActivityElement> multiNexts = new Vector<TMLActivityElement>();
- // Map <String, String> sendEvt;
- sendEvt = new HashMap<String, List<String>>();
- waitEvt = new HashMap<String, List<String>>();
- sendData = new HashMap<String, String>();
- receiveData = new HashMap<String, String>();
- // HashMap<String, List<String>> sendEvt = new HashMap<String, List<String>>();
+ // Map <String, String> dependencyGraphRelations.getSendEvt();
+ dependencyGraphRelations.setSendEvt(new HashMap<String, List<String>>());
+ dependencyGraphRelations.setWaitEvt(new HashMap<String, List<String>>());
+ dependencyGraphRelations.setSendData(new HashMap<String, String>());
+ dependencyGraphRelations.setReceiveData(new HashMap<String, String>());
+ // HashMap<String, List<String>> dependencyGraphRelations.getSendEvt() = new
+ // HashMap<String, List<String>>();
// GEt List of all requests
requestedTask(value);
for (TMLTask task : value) {
@@ -763,11 +748,11 @@ public class DirectedGraphTranslator extends JApplet {
waitEventNames();
// add the name of the task as a vertex
if (!g.vertexSet().contains(getvertex(key))) {
- g.addVertex(vertex(key, keyID));
+ g.addVertex(Vertex(key, keyID));
updateMainBar();
}
if (!g.vertexSet().contains(getvertex(taskName))) {
- g.addVertex(vertex(taskName, taskID));
+ g.addVertex(Vertex(taskName, taskID));
updateMainBar();
}
g.addEdge(getvertex(key), getvertex(taskName));
@@ -776,7 +761,7 @@ public class DirectedGraphTranslator extends JApplet {
currentElement = activity.getFirst();
taskStartName = "";
// int taskStartid;
- forLoopNextValues = new HashMap<String, List<String>>();
+ dependencyGraphRelations.setForLoopNextValues(new HashMap<String, List<String>>());
// loop over all the activites corresponding to a task
while (opCount <= activity.nElements()) {
String eventName = null;
@@ -806,18 +791,18 @@ public class DirectedGraphTranslator extends JApplet {
int id = ((TMLReadChannel) (currentElement)).getChannel(0).getID();
name = name + "__" + id;
if (!g.containsVertex(getvertex(name))) {
- g.addVertex(vertex(name, id));
+ g.addVertex(Vertex(name, id));
updateMainBar();
}
g.addEdge(getvertex(taskName), getvertex(name));
HashSet<String> readForkVertex = new HashSet<String>();
readForkVertex.add(name);
- if (forkreadEdges.containsKey(taskName)) {
- if (!forkreadEdges.get(taskName).contains(name)) {
- forkreadEdges.get(taskName).add(name);
+ if (dependencyGraphRelations.getForkreadEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getForkreadEdges().get(taskName).contains(name)) {
+ dependencyGraphRelations.getForkreadEdges().get(taskName).add(name);
}
} else {
- forkreadEdges.put(taskName, readForkVertex);
+ dependencyGraphRelations.getForkreadEdges().put(taskName, readForkVertex);
}
opCount++;
updateMainBar();
@@ -827,19 +812,19 @@ public class DirectedGraphTranslator extends JApplet {
String vName = ((TMLWriteChannel) (currentElement)).getChannel(0).getName();
int vid = ((TMLWriteChannel) (currentElement)).getChannel(0).getID();
vName = vName + "__" + vid;
- vertex v = getvertex(vName);
+ Vertex v = getvertex(vName);
if (!g.containsVertex(v)) {
- g.addVertex(vertex(vName, vid));
+ g.addVertex(Vertex(vName, vid));
updateMainBar();
}
HashSet<String> writeForkVertex = new HashSet<String>();
writeForkVertex.add(vName);
- if (forkwriteEdges.containsKey(taskName)) {
- if (!forkwriteEdges.get(taskName).contains(vName)) {
- forkwriteEdges.get(taskName).add(vName);
+ if (dependencyGraphRelations.getForkwriteEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getForkwriteEdges().get(taskName).contains(vName)) {
+ dependencyGraphRelations.getForkwriteEdges().get(taskName).add(vName);
}
} else {
- forkwriteEdges.put(taskName, writeForkVertex);
+ dependencyGraphRelations.getForkwriteEdges().put(taskName, writeForkVertex);
}
// g.addEdge(getvertex(taskName),getvertex(((TMLWriteChannel)(currentElement)).getChannel(0).getName()));
opCount++;
@@ -857,17 +842,17 @@ public class DirectedGraphTranslator extends JApplet {
int vid = ((TMLReadChannel) (currentElement)).getChannel(0).getID();
vName = vName + "__" + vid;
if (!g.containsVertex(getvertex(vName))) {
- g.addVertex(vertex(vName, vid));
+ g.addVertex(Vertex(vName, vid));
updateMainBar();
}
HashSet<String> writeForkVertex = new HashSet<String>();
writeForkVertex.add(vName);
- if (joinreadEdges.containsKey(taskName)) {
- if (!joinreadEdges.get(taskName).contains(vName)) {
- joinreadEdges.get(task.getName()).add(vName);
+ if (dependencyGraphRelations.getJoinreadEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getJoinreadEdges().get(taskName).contains(vName)) {
+ dependencyGraphRelations.getJoinreadEdges().get(task.getName()).add(vName);
}
} else {
- joinreadEdges.put(taskName, writeForkVertex);
+ dependencyGraphRelations.getJoinreadEdges().put(taskName, writeForkVertex);
}
// g.addEdge(getvertex(task.getName()),getvertex(((TMLWriteChannel)(currentElement)).getChannel(0).getName()));
opCount++;
@@ -879,18 +864,18 @@ public class DirectedGraphTranslator extends JApplet {
int vid = ((TMLWriteChannel) (currentElement)).getChannel(0).getID();
vName = vName + "__" + vid;
if (!g.containsVertex(getvertex(vName))) {
- g.addVertex(vertex(vName, vid));
+ g.addVertex(Vertex(vName, vid));
updateMainBar();
}
g.addEdge(getvertex(taskName), getvertex(vName));
HashSet<String> readForkVertex = new HashSet<String>();
readForkVertex.add(vName);
- if (joinwriteEdges.containsKey(taskName)) {
- if (!joinwriteEdges.get(taskName).contains(vName)) {
- joinwriteEdges.get(taskName).add(vName);
+ if (dependencyGraphRelations.getJoinwriteEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getJoinwriteEdges().get(taskName).contains(vName)) {
+ dependencyGraphRelations.getJoinwriteEdges().get(taskName).add(vName);
}
} else {
- joinwriteEdges.put(taskName, readForkVertex);
+ dependencyGraphRelations.getJoinwriteEdges().put(taskName, readForkVertex);
}
opCount++;
updateMainBar();
@@ -900,19 +885,19 @@ public class DirectedGraphTranslator extends JApplet {
String vName = ((TMLSendEvent) (currentElement)).getEvent().getName();
int vid = ((TMLSendEvent) (currentElement)).getEvent().getID();
vName = vName + "__" + vid;
- vertex v = getvertex(vName);
+ Vertex v = getvertex(vName);
if (!g.containsVertex(v)) {
- g.addVertex(vertex(vName, vid));
+ g.addVertex(Vertex(vName, vid));
updateMainBar();
}
HashSet<String> writeForkVertex = new HashSet<String>();
writeForkVertex.add(vName);
- if (forkwriteEdges.containsKey(taskName)) {
- if (!forkwriteEdges.get(taskName).contains(vName)) {
- forkwriteEdges.get(taskName).add(vName);
+ if (dependencyGraphRelations.getForkwriteEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getForkwriteEdges().get(taskName).contains(vName)) {
+ dependencyGraphRelations.getForkwriteEdges().get(taskName).add(vName);
}
} else {
- forkwriteEdges.put(taskName, writeForkVertex);
+ dependencyGraphRelations.getForkwriteEdges().put(taskName, writeForkVertex);
}
// g.addEdge(getvertex(taskName),getvertex(((TMLWriteChannel)(currentElement)).getChannel(0).getName()));
opCount++;
@@ -924,24 +909,24 @@ public class DirectedGraphTranslator extends JApplet {
int id = ((TMLWaitEvent) (currentElement)).getEvent().getID();
name = name + "__" + id;
if (!g.containsVertex(getvertex(name))) {
- g.addVertex(vertex(name, id));
+ g.addVertex(Vertex(name, id));
updateMainBar();
}
g.addEdge(getvertex(taskName), getvertex(name));
HashSet<String> readForkVertex = new HashSet<String>();
readForkVertex.add(name);
- if (forkreadEdges.containsKey(taskName)) {
- if (!forkreadEdges.get(taskName).contains(name)) {
- forkreadEdges.get(taskName).add(name);
+ if (dependencyGraphRelations.getForkreadEdges().containsKey(taskName)) {
+ if (!dependencyGraphRelations.getForkreadEdges().get(taskName).contains(name)) {
+ dependencyGraphRelations.getForkreadEdges().get(taskName).add(name);
}
} else {
- forkreadEdges.put(taskName, readForkVertex);
+ dependencyGraphRelations.getForkreadEdges().put(taskName, readForkVertex);
}
opCount++;
updateMainBar();
currentElement = currentElement.getNexts().firstElement();
continue;
- } else if (currentElement.getReferenceObject() == null) {
+ } else if (currentElement == null) {
opCount++;
updateMainBar();
if (currentElement.getNexts().size() > 0) {
@@ -958,25 +943,22 @@ public class DirectedGraphTranslator extends JApplet {
// in case an end was encountered , the previous activities should be checked:
// in
// case it is an end for a loop or sequence speavial edges should be added
- if (currentElement.getReferenceObject() != null && currentElement.getReferenceObject() instanceof TMLADStopState) {
+ if (currentElement != null && currentElement instanceof TMLStopState) {
addStopVertex(taskName);
}
// start activity is added as a vertex
- else if (currentElement.getReferenceObject() != null && currentElement.getReferenceObject() instanceof TMLADStartState) {
+ else if (currentElement != null && currentElement instanceof TMLStartState) {
addStartVertex(taskName);
}
// the below activities are added as vertex with the required edges
// these activities can be used to check later for latency
- else if (currentElement.getReferenceObject() != null
- && (currentElement.getReferenceObject() instanceof TADComponentWithoutSubcomponents
- || currentElement.getReferenceObject() instanceof TADComponentWithSubcomponents
- || currentElement.getReferenceObject() instanceof TMLADActionState)) {
+ else if (currentElement != null && currentElement instanceof DIPLOElement) {
addcurrentElementVertex(taskName, taskStartName);
}
// check if the next activity :add to an array:
// in case of for loop : the first element of inside/outside branches of loop
// in case of sequence: add first element of all branches
- if (currentElement.getReferenceObject() != null) {
+ if (currentElement != null) {
if (currentElement.getNexts().size() == 1) {
currentElement = currentElement.getNexts().firstElement();
} else if (!multiNexts.isEmpty()) {
@@ -984,7 +966,7 @@ public class DirectedGraphTranslator extends JApplet {
currentElement = multiNexts.get(0);
multiNexts.remove(0);
}
- allForLoopNextValues.putAll(forLoopNextValues);
+ dependencyGraphRelations.getAllForLoopNextValues().putAll(dependencyGraphRelations.getForLoopNextValues());
}
}
}
@@ -993,16 +975,14 @@ public class DirectedGraphTranslator extends JApplet {
}
private void trackMultiNexts(String taskName, String eventName) {
- if (currentElement.getReferenceObject() != null && currentElement.getReferenceObject() instanceof TMLADForStaticLoop
- || currentElement.getReferenceObject() instanceof TMLADForLoop) {
+ if (currentElement != null && currentElement instanceof TMLForLoop && !((TMLForLoop) currentElement).isInfinite()) {
if (currentElement.getNexts().size() > 1) {
- List<TGConnectingPoint> points = new ArrayList<TGConnectingPoint>();
- List<TGConnector> getOutputConnectors = new ArrayList<TGConnector>();
- if (currentElement.getReferenceObject() instanceof TMLADForStaticLoop) {
- points = Arrays.asList(((TMLADForStaticLoop) (currentElement.getReferenceObject())).getConnectingPoints());
- getOutputConnectors = ((TMLADForStaticLoop) (currentElement.getReferenceObject())).getOutputConnectors();
- String loopValue = ((TMLADForStaticLoop) (currentElement.getReferenceObject())).getValue();
- getvertex(eventName).setType(vertex.TYPE_STATIC_FOR_LOOP);
+ getvertex(eventName).setType(Vertex.TYPE_FOR_LOOP);
+ String cond = ((TMLForLoop) (currentElement)).getCondition();
+ if (cond.contains("<=")) {
+ String[] val = cond.split("<=");
+ String loopValue = val[2].toString();
+ // int loopVal = Integer.valueOf(loopValue);
if ((loopValue != null) && (loopValue.length() > 0)) {
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
@@ -1015,143 +995,79 @@ public class DirectedGraphTranslator extends JApplet {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
}
}
- } else if (currentElement.getReferenceObject() instanceof TMLADForLoop) {
- points = Arrays.asList(((TMLADForLoop) (currentElement.getReferenceObject())).getConnectingPoints());
- getOutputConnectors = ((TMLADForLoop) (currentElement.getReferenceObject())).getOutputConnectors();
- // String loopValue = ((TMLADForLoop)
- // (currentElement.getReferenceObject())).getValue();
- getvertex(eventName).setType(vertex.TYPE_FOR_LOOP);
- String cond = ((TMLADForLoop) (currentElement.getReferenceObject())).getCondition();
- if (cond.contains("<=")) {
- String[] val = cond.split("<=");
- String loopValue = val[2].toString();
- // int loopVal = Integer.valueOf(loopValue);
- if ((loopValue != null) && (loopValue.length() > 0)) {
- if ((loopValue.matches("\\d*"))) {
- getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
- } else {
- for (TMLAttribute att : taskAc.getAttributes()) {
- if (loopValue.contains(att.getName())) {
- loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
- }
+ } else if (cond.contains("<")) {
+ String[] val = cond.split("<");
+ String loopValue = val[1].toString();
+ // int loopVal = Integer.valueOf(loopValue);
+ if ((loopValue != null) && (loopValue.length() > 0)) {
+ if ((loopValue.matches("\\d*"))) {
+ getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
+ } else {
+ for (TMLAttribute att : taskAc.getAttributes()) {
+ if (loopValue.contains(att.getName())) {
+ loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
}
- getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
}
- }
- } else if (cond.contains("<")) {
- String[] val = cond.split("<");
- String loopValue = val[1].toString();
- // int loopVal = Integer.valueOf(loopValue);
- if ((loopValue != null) && (loopValue.length() > 0)) {
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
} else {
- for (TMLAttribute att : taskAc.getAttributes()) {
- if (loopValue.contains(att.getName())) {
- loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
- }
- }
- if ((loopValue.matches("\\d*"))) {
- getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
- } else {
- frameLatencyDetailedAnalysis.error(loopValue + EXPRESSION_NOT_SUPPORTED);
- }
+ this.getErrors().add(loopValue + EXPRESSION_NOT_SUPPORTED);
}
}
}
}
- TGConnector inputConnector = null, outputConnector = null;
- for (TGConnector connector : getOutputConnectors) {
- if (connector.getTGConnectingPointP1() == points.get(1)) {
- inputConnector = connector;
- } else if (connector.getTGConnectingPointP1() == points.get(2)) {
- outputConnector = connector;
- }
- }
List<String> afterloopActivity = new ArrayList<String>(2);
String insideLoop = "", outsideLoop = "";
- for (TMLActivityElement ae : currentElement.getNexts()) {
- List<TGConnector> cg = (((TGComponent) ae.getReferenceObject()).getInputConnectors());
- for (TGConnector afterloopcg : cg) {
- if (afterloopcg == inputConnector) {
- if (ae.getReferenceObject() instanceof TMLADRandom) {
- insideLoop = taskName + "__" + ae.getName() + "__" + ae.getID();
- } else if (ae.getReferenceObject() instanceof TMLADUnorderedSequence) {
- insideLoop = taskName + "__" + UNORDERED_SEQUENCE + "__" + ae.getID();
- } else {
- insideLoop = taskName + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
- }
- } else if (afterloopcg == outputConnector) {
- if (ae.getReferenceObject() instanceof TMLADRandom) {
- outsideLoop = taskName + "__" + ae.getName() + "__" + ae.getID();
- } else if (ae.getReferenceObject() instanceof TMLADUnorderedSequence) {
- outsideLoop = taskName + "__" + UNORDERED_SEQUENCE + "__" + ae.getID();
- } else {
- outsideLoop = taskName + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
- }
- }
- }
- }
+ TMLActivityElement insideLoopElement = currentElement.getNexts().get(0);
+ TMLActivityElement outsideLoopElement = currentElement.getNexts().get(1);
+ insideLoop = getEventName(taskName, insideLoopElement);
+ outsideLoop = getEventName(taskName, outsideLoopElement);
afterloopActivity.add(0, insideLoop);
afterloopActivity.add(1, outsideLoop);
- forLoopNextValues.put(eventName, afterloopActivity);
+ dependencyGraphRelations.getForLoopNextValues().put(eventName, afterloopActivity);
}
- } else if (currentElement.getReferenceObject() != null && currentElement.getReferenceObject() instanceof TMLADSequence) {
- getvertex(eventName).setType(vertex.TYPE_SEQ);
+ } else if (currentElement != null && currentElement instanceof TMLSequence) {
+ getvertex(eventName).setType(Vertex.TYPE_SEQ);
getvertex(eventName).setTaintFixedNumber(1);
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
- if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
- nextEventName = taskName + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
- } else if (seqListnextElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
- nextEventName = taskName + "__" + UNORDERED_SEQUENCE + "__" + seqListnextElement.getID();
- } else {
- nextEventName = taskName + "__" + seqListnextElement.getReferenceObject().toString() + "__" + seqListnextElement.getID();
- }
- if (orderedSequenceList.containsKey(eventName)) {
- if (!orderedSequenceList.get(eventName).contains(nextEventName)) {
- orderedSequenceList.get(eventName).add(nextEventName);
+ nextEventName = getEventName(taskName, seqListnextElement);
+ if (dependencyGraphRelations.getOrderedSequenceList().containsKey(eventName)) {
+ if (!dependencyGraphRelations.getOrderedSequenceList().get(eventName).contains(nextEventName)) {
+ dependencyGraphRelations.getOrderedSequenceList().get(eventName).add(nextEventName);
}
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
- orderedSequenceList.put(eventName, seqListNextValues);
+ dependencyGraphRelations.getOrderedSequenceList().put(eventName, seqListNextValues);
}
}
- } else if (currentElement.getReferenceObject() != null && currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
- getvertex(eventName).setType(vertex.TYPE_UNORDER_SEQ);
+ } else if (currentElement != null && currentElement instanceof TMLRandomSequence) {
+ getvertex(eventName).setType(Vertex.TYPE_UNORDER_SEQ);
getvertex(eventName).setTaintFixedNumber(1);
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
- if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
- nextEventName = taskName + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
- } else if (seqListnextElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
- nextEventName = taskName + "__" + UNORDERED_SEQUENCE + "__" + seqListnextElement.getID();
- } else {
- nextEventName = taskName + "__" + seqListnextElement.getReferenceObject().toString() + "__" + seqListnextElement.getID();
- }
- if (unOrderedSequenceList.containsKey(eventName)) {
- if (!unOrderedSequenceList.get(eventName).contains(nextEventName)) {
- unOrderedSequenceList.get(eventName).add(nextEventName);
+ nextEventName = getEventName(taskName, seqListnextElement);
+ if (dependencyGraphRelations.getUnOrderedSequenceList().containsKey(eventName)) {
+ if (!dependencyGraphRelations.getUnOrderedSequenceList().get(eventName).contains(nextEventName)) {
+ dependencyGraphRelations.getUnOrderedSequenceList().get(eventName).add(nextEventName);
}
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
- unOrderedSequenceList.put(eventName, seqListNextValues);
+ dependencyGraphRelations.getUnOrderedSequenceList().put(eventName, seqListNextValues);
}
}
}
- // List<TGConnector> cg = (((TGComponent)
- // currentElement.getReferenceObject()).getInputConnectors());
}
private void addStartVertex(String taskName) {
- taskStartName = taskName + "__" + currentElement.getName() + "__" + currentElement.getID();
- vertex startv = vertex(taskStartName, currentElement.getID());
+ taskStartName = taskName + "__" + currentElement.getName().replace(" ", "") + "__" + currentElement.getID();
+ Vertex startv = Vertex(taskStartName, currentElement.getID());
g.addVertex(startv);
updateMainBar();
// gVertecies.add(vertex(taskStartName));
- getvertex(taskStartName).setType(vertex.TYPE_START);
+ getvertex(taskStartName).setType(Vertex.TYPE_START);
getvertex(taskStartName).setTaintFixedNumber(1);
g.addEdge(getvertex(taskName), getvertex(taskStartName));
opCount++;
@@ -1177,12 +1093,14 @@ public class DirectedGraphTranslator extends JApplet {
String sendingDataPortdetails = "";
String receiveDataPortdetails = "";
if (sendingPortdetails != null && receivePortdetails != null) {
- waitEvt.put(WAITEVENT + receivePortdetails.getPortName() + "(" + receivePortparams + ")", new ArrayList<String>());
+ TMLEvent event = waitEvent.getEvent();
+ String nameW = taskAc.getName() + "__" + "Wait event: " + event.getName();
+ dependencyGraphRelations.getWaitEvt().put(nameW, new ArrayList<String>());
TMLTask originTasks = waitEvent.getEvent().getOriginTask();
for (TMLSendEvent wait_sendEvent : originTasks.getSendEvents()) {
- String sendingPortparams = wait_sendEvent.getAllParams();
- waitEvt.get(WAITEVENT + receivePortdetails.getPortName() + "(" + receivePortparams + ")")
- .add(SENDEVENT + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")");
+ event = wait_sendEvent.getEvent();
+ String nameS = originTasks.getName() + "__" + "Send event: " + event.getName();
+ dependencyGraphRelations.getWaitEvt().get(nameW).add(nameS);
}
} else {
String sendingPortparams = null;
@@ -1239,10 +1157,22 @@ public class DirectedGraphTranslator extends JApplet {
receivePortparams = waitEvent.getEvent().getParams().toString();
}
}
- if (sendingDataPortdetails != null && receiveDataPortdetails != null) {
- waitEvt.put(WAITEVENT + receiveDataPortdetails + "(" + receivePortparams + ")", new ArrayList<String>());
- waitEvt.get(WAITEVENT + receiveDataPortdetails + "(" + receivePortparams + ")")
+ if (sendingDataPortdetails != null && receiveDataPortdetails != null && sendingDataPortdetails != ""
+ && receiveDataPortdetails != "") {
+ dependencyGraphRelations.getWaitEvt().put(WAITEVENT + receiveDataPortdetails + "(" + receivePortparams + ")",
+ new ArrayList<String>());
+ dependencyGraphRelations.getWaitEvt().get(WAITEVENT + receiveDataPortdetails + "(" + receivePortparams + ")")
.add(SENDEVENT + sendingDataPortdetails + "(" + sendingPortparams + ")");
+ } else {
+ TMLEvent event = waitEvent.getEvent();
+ String nameW = taskAc.getName() + "__" + "Wait event: " + event.getName();
+ dependencyGraphRelations.getWaitEvt().put(nameW, new ArrayList<String>());
+ TMLTask originTasks = waitEvent.getEvent().getOriginTask();
+ for (TMLSendEvent wait_sendEvent : originTasks.getSendEvents()) {
+ event = wait_sendEvent.getEvent();
+ String nameS = originTasks.getName() + "__" + "Send event: " + event.getName();
+ dependencyGraphRelations.getWaitEvt().get(nameW).add(nameS);
+ }
}
}
}
@@ -1301,11 +1231,13 @@ public class DirectedGraphTranslator extends JApplet {
}
} else {
// writeChannel.getChannel(j);
- sendingDataPortdetails = writeChannel.getChannel(j).getOriginPort().getName();
- receiveDataPortdetails = writeChannel.getChannel(j).getDestinationPort().getName();
+ if (writeChannel.getChannel(j).getOriginPort() != null && writeChannel.getChannel(j).getDestinationPort() != null) {
+ sendingDataPortdetails = writeChannel.getChannel(j).getOriginPort().getName();
+ receiveDataPortdetails = writeChannel.getChannel(j).getDestinationPort().getName();
+ }
}
- if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
- sendData.put(sendingDataPortdetails, receiveDataPortdetails);
+ if (!sendingDataPortdetails.equals(receiveDataPortdetails) && sendingDataPortdetails != null && receiveDataPortdetails != null) {
+ dependencyGraphRelations.getSendData().put(sendingDataPortdetails, receiveDataPortdetails);
}
}
}
@@ -1363,24 +1295,19 @@ public class DirectedGraphTranslator extends JApplet {
receiveDataPortdetails = readChannel.getChannel(j).getDestinationPort().getName();
}
} else {
- sendingDataPortdetails = readChannel.getChannel(j).getOriginPort().getName();
- receiveDataPortdetails = readChannel.getChannel(j).getDestinationPort().getName();
- }
- if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
- receiveData.put(receiveDataPortdetails, sendingDataPortdetails);
- }
- TMLCPrimitivePort sp = null, rp = null;
- if (readChannel.getChannel(j).getOriginPort().getReferenceObject() instanceof TMLCPrimitivePort) {
- rp = (TMLCPrimitivePort) readChannel.getChannel(j).getOriginPort().getReferenceObject();
+ if (readChannel.getChannel(j).getOriginPort() != null && readChannel.getChannel(j).getDestinationPort() != null) {
+ sendingDataPortdetails = readChannel.getChannel(j).getOriginPort().getName();
+ receiveDataPortdetails = readChannel.getChannel(j).getDestinationPort().getName();
+ }
}
- if (readChannel.getChannel(j).getDestinationPort().getReferenceObject() instanceof TMLCPrimitivePort) {
- sp = (TMLCPrimitivePort) readChannel.getChannel(j).getDestinationPort().getReferenceObject();
+ if (!sendingDataPortdetails.equals(receiveDataPortdetails) && sendingDataPortdetails != null && receiveDataPortdetails != null) {
+ dependencyGraphRelations.getReceiveData().put(receiveDataPortdetails, sendingDataPortdetails);
}
- if (sp != null && rp != null) {
- if (!sp.isBlocking() && !rp.isBlocking()) {
- warnings.add("Analysis may fail because the model contains non blocking sending port: " + sp.getPortName()
- + " and non blocking read data port:" + rp.getPortName() + ". Use tainting analysis instead");
- }
+ if (readChannel.getChannel(j).getType() == 2 && readChannel.getChannel(j).getOriginPort() != null
+ && readChannel.getChannel(j).getDestinationPort() != null) {
+ warnings.add("Analysis may fail because the model contains non blocking sending port: "
+ + readChannel.getChannel(j).getDestinationPort().getName().toString() + " and non blocking read data port:"
+ + readChannel.getChannel(j).getOriginPort().getName().toString() + ". Use tainting analysis instead");
}
}
}
@@ -1388,18 +1315,14 @@ public class DirectedGraphTranslator extends JApplet {
private void sendEventsNames() {
for (TMLSendEvent sendEvent : taskAc.getSendEvents()) {
- // int i = sendEvent.getEvents().size();
- TMLCPrimitivePort sendingPortdetails = sendEvent.getEvent().port;
- TMLCPrimitivePort receivePortdetails = sendEvent.getEvent().port2;
- String sendingPortparams = sendEvent.getAllParams();
TMLTask destinationTasks = sendEvent.getEvent().getDestinationTask();
- if (sendingPortdetails != null && receivePortdetails != null) {
- sendEvt.put(SENDEVENT + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")", new ArrayList<String>());
- for (TMLWaitEvent wait_sendEvent : destinationTasks.getWaitEvents()) {
- String receivePortparams = wait_sendEvent.getAllParams();
- sendEvt.get(SENDEVENT + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")")
- .add(WAITEVENT + receivePortdetails.getPortName() + "(" + receivePortparams + ")");
- }
+ TMLEvent event = sendEvent.getEvent();
+ String nameS = taskAc.getName() + "__" + "Send event: " + event.getName();
+ dependencyGraphRelations.getSendEvt().put(nameS, new ArrayList<String>());
+ for (TMLWaitEvent wait_sendEvent : destinationTasks.getWaitEvents()) {
+ event = wait_sendEvent.getEvent();
+ String nameW = destinationTasks.getName() + "__" + "Wait event: " + event.getName();
+ dependencyGraphRelations.getSendEvt().get(nameS).add(nameW);
}
}
}
@@ -1408,47 +1331,42 @@ public class DirectedGraphTranslator extends JApplet {
for (TMLTask task : value) {
if (task.isRequested()) {
TMLRequest requestToTask = task.getRequest();
- requestToTask.getReferenceObject();
- requestToTask.getDestinationTask();
- requestToTask.getOriginTasks().get(0);
- requestToTask.ports.get(0).getName();
- requestToTask.getExtendedName();
String destinationRequest = requestToTask.getDestinationTask().getName() + "__"
+ requestToTask.getDestinationTask().getActivityDiagram().get(0).getName() + "__"
+ requestToTask.getDestinationTask().getActivityDiagram().get(0).getID();
String destinationRequestName = requestToTask.getDestinationTask().getName();
for (TMLTask originTask : requestToTask.getOriginTasks()) {
String requestOriginTaskName = originTask.getName();
- if (requestsOriginDestination.containsKey(requestOriginTaskName)) {
- if (!requestsOriginDestination.get(requestOriginTaskName).contains(destinationRequestName)) {
- requestsOriginDestination.get(requestOriginTaskName).add(destinationRequestName);
+ if (dependencyGraphRelations.getRequestsOriginDestination().containsKey(requestOriginTaskName)) {
+ if (!dependencyGraphRelations.getRequestsOriginDestination().get(requestOriginTaskName).contains(destinationRequestName)) {
+ dependencyGraphRelations.getRequestsOriginDestination().get(requestOriginTaskName).add(destinationRequestName);
}
} else {
ArrayList<String> destinationRequestNames = new ArrayList<String>();
destinationRequestNames.add(destinationRequestName);
- requestsOriginDestination.put(requestOriginTaskName, destinationRequestNames);
+ dependencyGraphRelations.getRequestsOriginDestination().put(requestOriginTaskName, destinationRequestNames);
}
}
for (TMLCPrimitivePort requestsPort : requestToTask.ports) {
String requestsPortName = requestsPort.getPortName();
- if (requestsPorts.containsKey(task.getName())) {
- if (!requestsPorts.get(task.getName()).contains(requestsPortName)) {
- requestsPorts.get(task.getName()).add(requestsPortName);
+ if (dependencyGraphRelations.getRequestsPorts().containsKey(task.getName())) {
+ if (!dependencyGraphRelations.getRequestsPorts().get(task.getName()).contains(requestsPortName)) {
+ dependencyGraphRelations.getRequestsPorts().get(task.getName()).add(requestsPortName);
}
} else {
ArrayList<String> requestsPortNames = new ArrayList<String>();
requestsPortNames.add(requestsPortName);
- requestsPorts.put(task.getName(), requestsPortNames);
+ dependencyGraphRelations.getRequestsPorts().put(task.getName(), requestsPortNames);
}
}
- if (requestsDestination.containsKey(destinationRequestName)) {
- if (!requestsDestination.get(destinationRequestName).contains(destinationRequest)) {
- requestsDestination.get(destinationRequestName).add(destinationRequest);
+ if (dependencyGraphRelations.getRequestsDestination().containsKey(destinationRequestName)) {
+ if (!dependencyGraphRelations.getRequestsDestination().get(destinationRequestName).contains(destinationRequest)) {
+ dependencyGraphRelations.getRequestsDestination().get(destinationRequestName).add(destinationRequest);
}
} else {
ArrayList<String> destinationRequestNames = new ArrayList<String>();
destinationRequestNames.add(destinationRequest);
- requestsDestination.put(destinationRequestName, destinationRequestNames);
+ dependencyGraphRelations.getRequestsDestination().put(destinationRequestName, destinationRequestNames);
}
}
}
@@ -1459,84 +1377,70 @@ public class DirectedGraphTranslator extends JApplet {
int preEventid;
String eventName = getEventName(taskName, currentElement);
int eventid = currentElement.getID();
- if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADRandom) {
- preEventName = taskName + "__" + activity.getPrevious(currentElement).getName() + "__" + activity.getPrevious(currentElement).getID();
- preEventid = activity.getPrevious(currentElement).getID();
- } else if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADUnorderedSequence) {
- preEventName = taskName + "__" + UNORDERED_SEQUENCE + "__" + activity.getPrevious(currentElement).getID();
- preEventid = activity.getPrevious(currentElement).getID();
- } else {
- preEventName = taskName + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__"
- + activity.getPrevious(currentElement).getID();
- preEventid = activity.getPrevious(currentElement).getID();
- }
+ preEventName = getEventName(taskName, activity.getPrevious(currentElement));
+ preEventid = activity.getPrevious(currentElement).getID();
if (!nameIDTaskList.containsKey(currentElement.getID())) {
nameIDTaskList.put(String.valueOf(currentElement.getID()), eventName);
}
if (g.containsVertex(getvertex(preEventName))) {
- vertex v = vertex(eventName, eventid);
- vertex preV = vertex(preEventName, preEventid);
+ Vertex v = Vertex(eventName, eventid);
+ Vertex preV = Vertex(preEventName, preEventid);
g.addVertex(v);
updateMainBar();
g.addEdge(preV, v);
opCount++;
} else if ((activity.getPrevious(currentElement).getName().equals(START)) && g.containsVertex(getvertex(taskStartName))) {
- vertex v = vertex(eventName, eventid);
+ Vertex v = Vertex(eventName, eventid);
g.addVertex(v);
updateMainBar();
// gVertecies.add(vertex(eventName));
g.addEdge(getvertex(taskStartName), getvertex(eventName));
opCount++;
}
- if (currentElement.getReferenceObject() instanceof TMLADSendEvent || currentElement.getReferenceObject() instanceof TMLADWaitEvent
- || currentElement.getReferenceObject() instanceof TMLADSendRequest
- || currentElement.getReferenceObject() instanceof TMLADNotifiedEvent
- || currentElement.getReferenceObject() instanceof TMLADReadChannel || currentElement.getReferenceObject() instanceof TMLADWriteChannel
- || (currentElement.getReferenceObject() instanceof TMLADExecI) || (currentElement.getReferenceObject() instanceof TMLADExecC)
- || (currentElement.getReferenceObject() instanceof TMLADDelay) || (currentElement.getReferenceObject() instanceof TMLADDelayInterval)
- || (currentElement.getReferenceObject() instanceof TMLADExecCInterval)
- || (currentElement.getReferenceObject() instanceof TMLADExecIInterval) || currentElement.getReferenceObject() instanceof TMLADEncrypt
- || currentElement.getReferenceObject() instanceof TMLADDecrypt
- || currentElement.getReferenceObject() instanceof TMLADReadRequestArg) {
+ if (currentElement instanceof TMLSendEvent || currentElement instanceof TMLWaitEvent || currentElement instanceof TMLSendRequest
+ || currentElement instanceof TMLNotifiedEvent || currentElement instanceof TMLReadChannel || currentElement instanceof TMLWriteChannel
+ || currentElement instanceof TMLExecI || (currentElement instanceof TMLExecC) || currentElement instanceof TMLDelay
+ || (currentElement instanceof TMLExecCInterval) || (currentElement instanceof TMLExecIInterval)) {
allLatencyTasks.add(eventName);
- getvertex(eventName).setType(vertex.TYPE_TRANSACTION);
+ getvertex(eventName).setType(Vertex.TYPE_TRANSACTION);
getvertex(eventName).setTaintFixedNumber(1);
- } else if (currentElement.getReferenceObject() instanceof TMLADRandom) {
- getvertex(eventName).setType(vertex.TYPE_CTRL);
+ } else if (currentElement instanceof TMLRandom) {
+ getvertex(eventName).setType(Vertex.TYPE_CTRL);
getvertex(eventName).setTaintFixedNumber(1);
- } else if (currentElement.getReferenceObject() instanceof TMLADSelectEvt) {
- getvertex(eventName).setType(vertex.TYPE_SELECT_EVT);
+ } else if (currentElement instanceof TMLSelectEvt) {
+ getvertex(eventName).setType(Vertex.TYPE_SELECT_EVT);
getvertex(eventName).setTaintFixedNumber(1);
- } else if (currentElement.getReferenceObject() instanceof TMLADActionState) {
- getvertex(eventName).setType(vertex.TYPE_CTRL);
+ } else if (currentElement instanceof TMLActionState) {
+ getvertex(eventName).setType(Vertex.TYPE_CTRL);
getvertex(eventName).setTaintFixedNumber(1);
}
- if (currentElement.getReferenceObject() instanceof TMLADForEverLoop) {
- forEverLoopList.add(eventName);
- getvertex(eventName).setType(vertex.TYPE_FOR_EVER_LOOP);
+ if (currentElement != null && currentElement instanceof TMLForLoop && ((TMLForLoop) currentElement).isInfinite()) {
+ dependencyGraphRelations.getForEverLoopList().add(eventName);
+ getvertex(eventName).setType(Vertex.TYPE_FOR_EVER_LOOP);
getvertex(eventName).setTaintFixedNumber(Integer.MAX_VALUE);
}
- if (currentElement.getReferenceObject() instanceof TMLADChoice) {
- getvertex(eventName).setType(vertex.TYPE_CHOICE);
+ if (currentElement instanceof TMLChoice) {
+ getvertex(eventName).setType(Vertex.TYPE_CHOICE);
getvertex(eventName).setTaintFixedNumber(1);
}
- if (currentElement.getReferenceObject() instanceof TMLADSendRequest) {
- if (requestsOriginDestination.containsKey(taskName)) {
- for (String destinationTask : requestsOriginDestination.get(taskName)) {
- if (requestsPorts.containsKey(destinationTask)) {
- for (String portNames : requestsPorts.get(destinationTask)) {
- String[] requestName = currentElement.getReferenceObject().toString().split(":");
+ if (currentElement instanceof TMLSendRequest) {
+ if (dependencyGraphRelations.getRequestsOriginDestination().containsKey(taskName)) {
+ for (String destinationTask : dependencyGraphRelations.getRequestsOriginDestination().get(taskName)) {
+ if (dependencyGraphRelations.getRequestsPorts().containsKey(destinationTask)) {
+ for (String portNames : dependencyGraphRelations.getRequestsPorts().get(destinationTask)) {
+ String[] requestName = ((TMLSendRequest) currentElement).toString().split(":");
String[] portname = requestName[1].split("[(]");
- if (portname[0].replaceAll(" ", "").equals(portNames.replaceAll(" ", ""))) {
- for (String destinationTaskstartname : requestsDestination.get(destinationTask)) {
- if (requestEdges.containsKey(eventName)) {
- if (!requestEdges.get(eventName).contains(destinationTaskstartname)) {
- requestEdges.get(eventName).add(destinationTaskstartname);
+ String[] pName = portname[0].split("__");
+ if (portNames.replaceAll(" ", "").equals(pName[1].replaceAll(" ", ""))) {
+ for (String destinationTaskstartname : dependencyGraphRelations.getRequestsDestination().get(destinationTask)) {
+ if (dependencyGraphRelations.getRequestEdges().containsKey(eventName)) {
+ if (!dependencyGraphRelations.getRequestEdges().get(eventName).contains(destinationTaskstartname)) {
+ dependencyGraphRelations.getRequestEdges().get(eventName).add(destinationTaskstartname);
}
} else {
HashSet<String> destinationTaskoriginstart = new HashSet<String>();
destinationTaskoriginstart.add(destinationTaskstartname);
- requestEdges.put(eventName, destinationTaskoriginstart);
+ dependencyGraphRelations.getRequestEdges().put(eventName, destinationTaskoriginstart);
}
}
}
@@ -1545,138 +1449,170 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (currentElement.getReferenceObject() instanceof TMLADSendEvent) {
- if (sendEvt.containsKey(currentElement.getReferenceObject().toString().replaceAll(" ", ""))) {
- List<String> recieveEvt = sendEvt.get(currentElement.getReferenceObject().toString().replaceAll(" ", ""));
- for (vertex vertex : g.vertexSet()) {
- String[] vertexName = vertex.toString().split("__");
+ if (currentElement instanceof TMLSendEvent) {
+ String name = getEventName(taskName, currentElement);
+ String[] name1 = name.split("__");
+ int i = name1[name1.length - 1].length();
+ String pattern = "[0-9]{" + i + "}";
+ if (name.substring(name.length() - i, name.length()).matches(pattern)) {
+ name = name.substring(0, name.length() - (i + 2));
+ }
+ if (dependencyGraphRelations.getSendEvt().containsKey(name)) {
+ List<String> recieveEvt = dependencyGraphRelations.getSendEvt().get(name);
+ for (Vertex Vertex : g.vertexSet()) {
+ String vertexName = Vertex.toString();
for (String n : recieveEvt) {
- if (vertexName.length >= 3) {
- if ((n.replaceAll(" ", "").equals((vertexName[2].toString().replaceAll(" ", ""))))) {
- HashSet<String> waitEventVertex = new HashSet<String>();
- waitEventVertex.add(vertex.toString());
- if (sendEventWaitEventEdges.containsKey(eventName)) {
- if (!sendEventWaitEventEdges.get(eventName).contains(vertex.toString())) {
- sendEventWaitEventEdges.get(eventName).add(vertex.toString());
- }
- } else {
- sendEventWaitEventEdges.put(eventName, waitEventVertex);
+ String[] vertexName1 = vertexName.split("__");
+ int j = vertexName1[vertexName1.length - 1].length();
+ pattern = "[0-9]{" + j + "}";
+ if (vertexName.substring(vertexName.length() - j, vertexName.length()).matches(pattern)) {
+ vertexName = vertexName.substring(0, vertexName.length() - (j + 2));
+ }
+ if (n.equals(vertexName)) {
+ HashSet<String> waitEventVertex = new HashSet<String>();
+ waitEventVertex.add(Vertex.toString());
+ if (dependencyGraphRelations.getSendEventWaitEventEdges().containsKey(eventName)) {
+ if (!dependencyGraphRelations.getSendEventWaitEventEdges().get(eventName).contains(Vertex.toString())) {
+ dependencyGraphRelations.getSendEventWaitEventEdges().get(eventName).add(Vertex.toString());
}
+ } else {
+ dependencyGraphRelations.getSendEventWaitEventEdges().put(eventName, waitEventVertex);
}
}
}
}
}
}
- if (currentElement.getReferenceObject() instanceof TMLADWaitEvent) {
- if (waitEvt.containsKey(currentElement.getReferenceObject().toString().replaceAll(" ", ""))) {
- List<String> sendevent = waitEvt.get(currentElement.getReferenceObject().toString().replaceAll(" ", ""));
- for (vertex vertex : g.vertexSet()) {
- String[] vertexName = vertex.toString().split("__");
+ if (currentElement instanceof TMLWaitEvent) {
+ String name = getEventName(taskName, currentElement);
+ String[] name1 = name.split("__");
+ int i = name1[name1.length - 1].length();
+ String pattern = "[0-9]{" + i + "}";
+ if (name.substring(name.length() - i, name.length()).matches(pattern)) {
+ name = name.substring(0, name.length() - (i + 2));
+ }
+ if (dependencyGraphRelations.getWaitEvt().containsKey(name)) {
+ List<String> sendevent = dependencyGraphRelations.getWaitEvt().get(name);
+ for (Vertex Vertex : g.vertexSet()) {
+ String vertexName = Vertex.toString();
for (String n : sendevent) {
- if (vertexName.length >= 3) {
- if ((n.replaceAll(" ", "").equals((vertexName[2].toString().replaceAll(" ", ""))))) {
- HashSet<String> waitEventVertex = new HashSet<String>();
- waitEventVertex.add(eventName);
- if (sendEventWaitEventEdges.containsKey(vertex.toString())) {
- if (!sendEventWaitEventEdges.get(vertex.toString()).contains(eventName)) {
- sendEventWaitEventEdges.get(vertex.toString()).add(eventName);
- }
- } else {
- sendEventWaitEventEdges.put(vertex.toString(), waitEventVertex);
+ String[] vertexName1 = vertexName.split("__");
+ int j = vertexName1[vertexName1.length - 1].length();
+ pattern = "[0-9]{" + j + "}";
+ if (vertexName.substring(vertexName.length() - j, vertexName.length()).matches(pattern)) {
+ vertexName = vertexName.substring(0, vertexName.length() - (j + 2));
+ }
+ if (n.equals(vertexName)) {
+ HashSet<String> waitEventVertex = new HashSet<String>();
+ waitEventVertex.add(eventName);
+ if (dependencyGraphRelations.getSendEventWaitEventEdges().containsKey(Vertex.toString())) {
+ if (!dependencyGraphRelations.getSendEventWaitEventEdges().get(Vertex.toString()).contains(eventName)) {
+ dependencyGraphRelations.getSendEventWaitEventEdges().get(Vertex.toString()).add(eventName);
}
+ } else {
+ dependencyGraphRelations.getSendEventWaitEventEdges().put(Vertex.toString(), waitEventVertex);
}
}
}
}
}
}
- if (currentElement.getReferenceObject() instanceof TMLADWriteChannel && currentElement instanceof TMLWriteChannel) {
- writeChannelTransactions.add(eventName);
- String[] name = eventName.split("__");
- String[] removewrite = name[2].split(":");
- String[] portname = removewrite[1].split("[(]");
- String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
- String portNameNoSpaces = portname[0].replaceAll(" ", "");
- if (sendData.containsKey(portNameNoSpaces)) {
- String sendDatachannels;
- if (((TMLWriteChannel) currentElement).getChannel(0).getName().contains(FORK_CHANNEL)
- || ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith(FORK_TASK)
- || ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith(FORK_TASK)
- || ((TMLWriteChannel) currentElement).getChannel(0).getName().contains(JOIN_CHANNEL)
- || ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith(JOIN_TASK)
- || ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith(JOIN_TASK)) {
- sendDatachannels = sendData.get(portNameNoSpaces);
- } else {
- // sendDatachannels = name[0] + "__" + sendData.get(portNameNoSpaces) + "__" +
- // name[0] + "__" + portNameNoSpaces;
- sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces);
- }
- HashSet<String> writeChVertex = new HashSet<String>();
- writeChVertex.add(sendDatachannels);
- if (writeReadChannelEdges.containsKey(eventName)) {
- if (!writeReadChannelEdges.get(eventName).contains(sendDatachannels)) {
- writeReadChannelEdges.get(eventName).add(sendDatachannels);
- }
- } else {
- writeReadChannelEdges.put(eventName, writeChVertex);
+ if (currentElement instanceof TMLWriteChannel) {
+ dependencyGraphRelations.getWriteChannelTransactions().add(eventName);
+ String chanel = ((TMLWriteChannel) currentElement).getChannel(0).getName();
+ HashSet<String> writeChVertex = new HashSet<String>();
+ writeChVertex.add(chanel);
+ if (dependencyGraphRelations.getWriteReadChannelEdges().containsKey(eventName)) {
+ if (!dependencyGraphRelations.getWriteReadChannelEdges().get(eventName).contains(chanel)) {
+ dependencyGraphRelations.getWriteReadChannelEdges().get(eventName).add(chanel);
}
- // getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).getTaintFixedNumber()
- // + 1);
} else {
- HashSet<String> writeChVertex = new HashSet<String>();
- writeChVertex.add(chwriteName);
- if (writeReadChannelEdges.containsKey(eventName)) {
- if (!writeReadChannelEdges.get(eventName).contains(chwriteName)) {
- writeReadChannelEdges.get(eventName).add(chwriteName);
- }
- } else {
- writeReadChannelEdges.put(eventName, writeChVertex);
- }
- // getvertex(chwriteName).setTaintFixedNumber(getvertex(chwriteName).getTaintFixedNumber()
- // + 1);
+ dependencyGraphRelations.getWriteReadChannelEdges().put(eventName, writeChVertex);
}
+ /*
+ * String[] name = eventName.split("__"); String[] removewrite =
+ * name[2].split(":"); String[] portname = removewrite[1].split("[(]"); String
+ * chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", ""); String
+ * portNameNoSpaces = portname[0].replaceAll(" ", ""); if
+ * (sendData.containsKey(portNameNoSpaces)) { String sendDatachannels; if
+ * (((TMLWriteChannel)
+ * currentElement).getChannel(0).getName().contains(FORK_CHANNEL) ||
+ * ((TMLWriteChannel)
+ * currentElement).getChannel(0).getDestinationTask().getName().startsWith(
+ * FORK_TASK) || ((TMLWriteChannel)
+ * currentElement).getChannel(0).getOriginTask().getName().startsWith(FORK_TASK)
+ * || ((TMLWriteChannel)
+ * currentElement).getChannel(0).getName().contains(JOIN_CHANNEL) ||
+ * ((TMLWriteChannel)
+ * currentElement).getChannel(0).getDestinationTask().getName().startsWith(
+ * JOIN_TASK) || ((TMLWriteChannel)
+ * currentElement).getChannel(0).getOriginTask().getName().startsWith(JOIN_TASK)
+ * ) { sendDatachannels = sendData.get(portNameNoSpaces); } else { //
+ * sendDatachannels = name[0] + "__" + sendData.get(portNameNoSpaces) + "__" +
+ * // name[0] + "__" + portNameNoSpaces; sendDatachannels = name[0] + "__" +
+ * portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces); }
+ * HashSet<String> writeChVertex = new HashSet<String>();
+ * writeChVertex.add(sendDatachannels); if
+ * (dependencyGraphRelations.getWriteReadChannelEdges().containsKey(eventName))
+ * { if (!writeReadChannelEdges.get(eventName).contains(sendDatachannels)) {
+ * writeReadChannelEdges.get(eventName).add(sendDatachannels); } } else {
+ * writeReadChannelEdges.put(eventName, writeChVertex); } //
+ * getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).
+ * getTaintFixedNumber() // + 1); } else { HashSet<String> writeChVertex = new
+ * HashSet<String>(); writeChVertex.add(chwriteName); if
+ * (writeReadChannelEdges.containsKey(eventName)) { if
+ * (!writeReadChannelEdges.get(eventName).contains(chwriteName)) {
+ * writeReadChannelEdges.get(eventName).add(chwriteName); } } else {
+ * writeReadChannelEdges.put(eventName, writeChVertex); } //
+ * getvertex(chwriteName).setTaintFixedNumber(getvertex(chwriteName).
+ * getTaintFixedNumber() // + 1); }
+ */
}
- if (currentElement.getReferenceObject() instanceof TMLADReadChannel) {
- readChannelTransactions.add(eventName);
- String[] name = eventName.split("__");
- String[] removewrite = name[2].split(":");
- String[] portname = removewrite[1].split("[(]");
- String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
- String portNameNoSpaces = portname[0].replaceAll(" ", "");
- if (receiveData.containsKey(portNameNoSpaces)) {
- String sendDatachannels;
- if (((TMLReadChannel) currentElement).getChannel(0).getName().contains(FORK_CHANNEL)
- || ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith(FORK_TASK)
- || ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith(FORK_TASK)
- || ((TMLReadChannel) currentElement).getChannel(0).getName().contains(JOIN_CHANNEL)
- || ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith(JOIN_TASK)
- || ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith(JOIN_TASK)) {
- sendDatachannels = receiveData.get(portNameNoSpaces);
- } else {
- sendDatachannels = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__" + name[0] + "__" + portNameNoSpaces;
- }
- HashSet<String> readChVertex = new HashSet<String>();
- readChVertex.add(eventName);
- if (readWriteChannelEdges.containsKey(sendDatachannels)) {
- if (!readWriteChannelEdges.get(sendDatachannels).contains(eventName)) {
- readWriteChannelEdges.get(sendDatachannels).add(eventName);
- }
- } else {
- readWriteChannelEdges.put(sendDatachannels, readChVertex);
+ if (currentElement instanceof TMLReadChannel) {
+ dependencyGraphRelations.getReadChannelTransactions().add(eventName);
+ String chanel = ((TMLReadChannel) currentElement).getChannel(0).getName();
+ HashSet<String> readChVertex = new HashSet<String>();
+ readChVertex.add(eventName);
+ if (dependencyGraphRelations.getReadWriteChannelEdges().containsKey(chanel)) {
+ if (!dependencyGraphRelations.getReadWriteChannelEdges().get(chanel).contains(eventName)) {
+ dependencyGraphRelations.getReadWriteChannelEdges().get(chanel).add(eventName);
}
} else {
- HashSet<String> readChVertex = new HashSet<String>();
- readChVertex.add(eventName);
- if (readWriteChannelEdges.containsKey(chwriteName)) {
- if (!readWriteChannelEdges.get(chwriteName).contains(eventName)) {
- readWriteChannelEdges.get(chwriteName).add(eventName);
- }
- } else {
- readWriteChannelEdges.put(chwriteName, readChVertex);
- }
- //
+ dependencyGraphRelations.getReadWriteChannelEdges().put(chanel, readChVertex);
}
+ /*
+ * String[] name = eventName.split("__"); String[] removewrite =
+ * name[2].split(":"); String[] portname = removewrite[1].split("[(]"); String
+ * chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", ""); String
+ * portNameNoSpaces = portname[0].replaceAll(" ", ""); if
+ * (receiveData.containsKey(portNameNoSpaces)) { String sendDatachannels; if
+ * (((TMLReadChannel)
+ * currentElement).getChannel(0).getName().contains(FORK_CHANNEL) ||
+ * ((TMLReadChannel)
+ * currentElement).getChannel(0).getDestinationTask().getName().startsWith(
+ * FORK_TASK) || ((TMLReadChannel)
+ * currentElement).getChannel(0).getOriginTask().getName().startsWith(FORK_TASK)
+ * || ((TMLReadChannel)
+ * currentElement).getChannel(0).getName().contains(JOIN_CHANNEL) ||
+ * ((TMLReadChannel)
+ * currentElement).getChannel(0).getDestinationTask().getName().startsWith(
+ * JOIN_TASK) || ((TMLReadChannel)
+ * currentElement).getChannel(0).getOriginTask().getName().startsWith(JOIN_TASK)
+ * ) { sendDatachannels = receiveData.get(portNameNoSpaces); } else {
+ * sendDatachannels = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__"
+ * + name[0] + "__" + portNameNoSpaces; } HashSet<String> readChVertex = new
+ * HashSet<String>(); readChVertex.add(eventName); if
+ * (readWriteChannelEdges.containsKey(sendDatachannels)) { if
+ * (!readWriteChannelEdges.get(sendDatachannels).contains(eventName)) {
+ * readWriteChannelEdges.get(sendDatachannels).add(eventName); } } else {
+ * readWriteChannelEdges.put(sendDatachannels, readChVertex); } } else {
+ * HashSet<String> readChVertex = new HashSet<String>();
+ * readChVertex.add(eventName); if
+ * (readWriteChannelEdges.containsKey(chwriteName)) { if
+ * (!readWriteChannelEdges.get(chwriteName).contains(eventName)) {
+ * readWriteChannelEdges.get(chwriteName).add(eventName); } } else {
+ * readWriteChannelEdges.put(chwriteName, readChVertex); } // }
+ */
}
}
@@ -1688,36 +1624,31 @@ public class DirectedGraphTranslator extends JApplet {
String eventName = null;
eventName = getEventName(taskName, currentElement);
taskEndid = currentElement.getID();
- taskEndName = taskName + "__" + currentElement.getName() + "__" + taskEndid;
+ taskEndName = taskName + "__" + currentElement.getName().replace(" ", "") + "__" + taskEndid;
preEventid = activity.getPrevious(currentElement).getID();
- if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADRandom) {
- preEventName = taskName + "__" + activity.getPrevious(currentElement).getName() + "__" + preEventid;
- } else if (currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
- preEventName = taskName + "__" + UNORDERED_SEQUENCE + "__" + preEventid;
- } else {
- preEventName = taskName + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__" + preEventid;
- }
- vertex taskEndVertex = vertex(taskEndName, taskEndid);
+ preEventName = getEventName(taskName, activity.getPrevious(currentElement));
+ Vertex taskEndVertex = Vertex(taskEndName, taskEndid);
g.addVertex(taskEndVertex);
updateMainBar();
// gVertecies.add(vertex(taskEndName));
- getvertex(eventName).setType(vertex.TYPE_END);
+ getvertex(eventName).setType(Vertex.TYPE_END);
getvertex(eventName).setTaintFixedNumber(1);
// allTasks.add(taskEndName);
- if (!(activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADSequence)) {
+ if (!(activity.getPrevious(currentElement) instanceof TMLSequence)) {
g.addEdge(getvertex(preEventName), getvertex(taskEndName));
}
@SuppressWarnings({ "unchecked", "rawtypes" })
- AllDirectedPaths<vertex, DefaultEdge> allPaths = new AllDirectedPaths<vertex, DefaultEdge>(g);
- if (orderedSequenceList.size() > 0) {
+ AllDirectedPaths<Vertex, DefaultEdge> allPaths = new AllDirectedPaths<Vertex, DefaultEdge>(g);
+ if (dependencyGraphRelations.getOrderedSequenceList().size() > 0) {
int noForLoop = 0;
// get path from sequence to end
- for (Entry<String, ArrayList<String>> sequenceListEntry : orderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> sequenceListEntry : dependencyGraphRelations.getOrderedSequenceList().entrySet()) {
int directlyConnectedSeq = 0;
if (g.containsVertex(getvertex(sequenceListEntry.getKey()))) {
- List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
+ List<GraphPath<Vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
false, g.vertexSet().size());
- for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> othersequenceListEntryValue : dependencyGraphRelations.getOrderedSequenceList()
+ .entrySet()) {
for (int i = 0; i < path.size(); i++) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
if (path.get(i).getVertexList().contains(getvertex(othersequenceListEntryValue.getKey()))) {
@@ -1731,8 +1662,9 @@ public class DirectedGraphTranslator extends JApplet {
for (String sequenceListEntryValue : sequenceListEntry.getValue()) {
if (g.containsVertex(getvertex(sequenceListEntryValue))) {
if (path.get(i).getVertexList().contains(getvertex(sequenceListEntryValue))) {
- if (forLoopNextValues.size() > 0) {
- for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
+ if (dependencyGraphRelations.getForLoopNextValues().size() > 0) {
+ for (Entry<String, List<String>> forloopListEntry : dependencyGraphRelations.getForLoopNextValues()
+ .entrySet()) {
if ((path.get(i).getVertexList().contains(getvertex(forloopListEntry.getValue().get(0)))
&& getvertex(forloopListEntry.getValue().get(0)).getName() != sequenceListEntry.getKey())
|| path.get(i).getVertexList().contains(getvertex(
@@ -1741,8 +1673,8 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (forEverLoopList.size() > 0) {
- for (String forloopListEntry : forEverLoopList) {
+ if (dependencyGraphRelations.getForEverLoopList().size() > 0) {
+ for (String forloopListEntry : dependencyGraphRelations.getForEverLoopList()) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry))) {
noForLoop++;
}
@@ -1753,23 +1685,27 @@ public class DirectedGraphTranslator extends JApplet {
if (nextIndex < sequenceListEntry.getValue().size()) {
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(sequenceListEntry.getValue().get(nextIndex));
- if (sequenceEdges.containsKey(taskEndName)) {
- if (!sequenceEdges.get(taskEndName).contains(sequenceListEntry.getValue().get(nextIndex))) {
- sequenceEdges.get(taskEndName).add(sequenceListEntry.getValue().get(nextIndex));
+ if (dependencyGraphRelations.getSequenceEdges().containsKey(taskEndName)) {
+ if (!dependencyGraphRelations.getSequenceEdges().get(taskEndName)
+ .contains(sequenceListEntry.getValue().get(nextIndex))) {
+ dependencyGraphRelations.getSequenceEdges().get(taskEndName)
+ .add(sequenceListEntry.getValue().get(nextIndex));
}
} else {
- sequenceEdges.put(eventName, endSequenceVertex);
+ dependencyGraphRelations.getSequenceEdges().put(eventName, endSequenceVertex);
}
- } else if (nextIndex == sequenceListEntry.getValue().size() && orderedSequenceList.size() > 1) {
- for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
+ } else if (nextIndex == sequenceListEntry.getValue().size()
+ && dependencyGraphRelations.getOrderedSequenceList().size() > 1) {
+ for (Entry<String, ArrayList<String>> othersequenceListEntryValue : dependencyGraphRelations
+ .getOrderedSequenceList().entrySet()) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
int connectedSeq = 0;
- List<GraphPath<vertex, DefaultEdge>> pathBetweenSeq = allPaths.getAllPaths(
+ List<GraphPath<Vertex, DefaultEdge>> pathBetweenSeq = allPaths.getAllPaths(
getvertex(othersequenceListEntryValue.getKey()), getvertex(taskEndName), false,
g.vertexSet().size());
for (int j = 0; j < pathBetweenSeq.size(); j++) {
- for (Entry<String, ArrayList<String>> adjacentsequenceListEntryValue : orderedSequenceList
- .entrySet()) {
+ for (Entry<String, ArrayList<String>> adjacentsequenceListEntryValue : dependencyGraphRelations
+ .getOrderedSequenceList().entrySet()) {
if (!adjacentsequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())
&& !adjacentsequenceListEntryValue.getKey()
.equals(othersequenceListEntryValue.getKey())) {
@@ -1782,7 +1718,7 @@ public class DirectedGraphTranslator extends JApplet {
}
if (connectedSeq == 0 && pathBetweenSeq.size() > 0) {
for (String othersequenceListValue : othersequenceListEntryValue.getValue()) {
- List<GraphPath<vertex, DefaultEdge>> pathToNextValue = allPaths.getAllPaths(
+ List<GraphPath<Vertex, DefaultEdge>> pathToNextValue = allPaths.getAllPaths(
getvertex(othersequenceListValue), getvertex(taskEndName), false,
g.vertexSet().size());
if (pathToNextValue.size() > 0) {
@@ -1792,14 +1728,16 @@ public class DirectedGraphTranslator extends JApplet {
HashSet<String> nextSequenceVertex = new HashSet<String>();
nextSequenceVertex
.add(othersequenceListEntryValue.getValue().get(nextAdjIndex));
- if (sequenceEdges.containsKey(taskEndName)) {
- if (!sequenceEdges.get(taskEndName).contains(
- othersequenceListEntryValue.getValue().get(nextAdjIndex))) {
- sequenceEdges.get(taskEndName).add(
+ if (dependencyGraphRelations.getSequenceEdges().containsKey(taskEndName)) {
+ if (!dependencyGraphRelations.getSequenceEdges().get(taskEndName)
+ .contains(othersequenceListEntryValue.getValue()
+ .get(nextAdjIndex))) {
+ dependencyGraphRelations.getSequenceEdges().get(taskEndName).add(
othersequenceListEntryValue.getValue().get(nextAdjIndex));
}
} else {
- sequenceEdges.put(eventName, nextSequenceVertex);
+ dependencyGraphRelations.getSequenceEdges().put(eventName,
+ nextSequenceVertex);
}
}
}
@@ -1817,17 +1755,17 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (unOrderedSequenceList.size() > 0) {
+ if (dependencyGraphRelations.getUnOrderedSequenceList().size() > 0) {
// get path from sequence to end
- for (Entry<String, ArrayList<String>> sequenceListEntry : unOrderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> sequenceListEntry : dependencyGraphRelations.getUnOrderedSequenceList().entrySet()) {
if (g.containsVertex(getvertex(sequenceListEntry.getKey()))) {
int noForLoop = 0;
- List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
+ List<GraphPath<Vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
false, g.vertexSet().size());
for (int i = 0; i < path.size(); i++) {
if (path.size() > 0 && sequenceListEntry.getValue().size() > 0) {
- if (forLoopNextValues.size() > 0) {
- for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
+ if (dependencyGraphRelations.getForLoopNextValues().size() > 0) {
+ for (Entry<String, List<String>> forloopListEntry : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry.getValue().get(0)))) {
noForLoop++;
@@ -1835,14 +1773,14 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (forEverLoopList.size() > 0) {
- for (String forloopListEntry : forEverLoopList) {
+ if (dependencyGraphRelations.getForEverLoopList().size() > 0) {
+ for (String forloopListEntry : dependencyGraphRelations.getForEverLoopList()) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry))) {
noForLoop++;
}
}
}
- for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> seqEntry : dependencyGraphRelations.getOrderedSequenceList().entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))) {
} else {
@@ -1852,19 +1790,20 @@ public class DirectedGraphTranslator extends JApplet {
}
if (noForLoop == 0) {
for (String seqEntry : sequenceListEntry.getValue()) {
- GraphPath<vertex, DefaultEdge> pathToEnd = null;
+ GraphPath<Vertex, DefaultEdge> pathToEnd = null;
if (g.containsVertex(getvertex(seqEntry))) {
pathToEnd = DijkstraShortestPath.findPathBetween(g, getvertex(seqEntry), getvertex(eventName));
}
if (pathToEnd == null) {
- if (unOrderedSequenceEdges.containsKey(taskEndName)) {
- if (!unOrderedSequenceEdges.get(taskEndName).contains(sequenceListEntry.getKey())) {
- unOrderedSequenceEdges.get(taskEndName).add(seqEntry);
+ if (dependencyGraphRelations.getUnOrderedSequenceEdges().containsKey(taskEndName)) {
+ if (!dependencyGraphRelations.getUnOrderedSequenceEdges().get(taskEndName)
+ .contains(sequenceListEntry.getKey())) {
+ dependencyGraphRelations.getUnOrderedSequenceEdges().get(taskEndName).add(seqEntry);
}
} else {
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(seqEntry);
- unOrderedSequenceEdges.put(eventName, endSequenceVertex);
+ dependencyGraphRelations.getUnOrderedSequenceEdges().put(eventName, endSequenceVertex);
}
}
}
@@ -1876,21 +1815,21 @@ public class DirectedGraphTranslator extends JApplet {
}
}
// add if sequence on path of multiple for
- if (forLoopNextValues.size() > 0) {
- for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
+ if (dependencyGraphRelations.getForLoopNextValues().size() > 0) {
+ for (Entry<String, List<String>> forloopListEntry : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (g.containsVertex(getvertex(forloopListEntry.getValue().get(0)))) {
- List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(0)),
+ List<GraphPath<Vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(0)),
getvertex(taskEndName), false, g.vertexSet().size());
for (int i = 0; i < path.size(); i++) {
int forloopCount = 0;
- for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
+ for (Entry<String, List<String>> forEntry : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (!forloopListEntry.getKey().equals(forEntry.getKey())) {
if (path.get(i).getVertexList().contains(getvertex(forEntry.getKey()))) {
forloopCount++;
}
}
}
- for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> seqEntry : dependencyGraphRelations.getOrderedSequenceList().entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))) {
} else {
@@ -1904,18 +1843,18 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (g.containsVertex(getvertex(forloopListEntry.getValue().get(1))) && forLoopNextValues.size() > 1) {
- List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(1)),
+ if (g.containsVertex(getvertex(forloopListEntry.getValue().get(1))) && dependencyGraphRelations.getForLoopNextValues().size() > 1) {
+ List<GraphPath<Vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(1)),
getvertex(taskEndName), false, g.vertexSet().size());
if (path.size() > 0) {
- for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
+ for (Entry<String, List<String>> previousForLoop : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (g.containsVertex(getvertex(previousForLoop.getValue().get(0)))
&& !previousForLoop.getKey().equals(forloopListEntry.getKey())) {
- List<GraphPath<vertex, DefaultEdge>> previousForpath = allPaths.getAllPaths(
+ List<GraphPath<Vertex, DefaultEdge>> previousForpath = allPaths.getAllPaths(
getvertex(previousForLoop.getValue().get(0)), getvertex(taskEndName), false, g.vertexSet().size());
for (int i = 0; i < previousForpath.size(); i++) {
int forloopCount = 0;
- for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
+ for (Entry<String, List<String>> forEntry : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (previousForpath.get(i).getVertexList().contains(getvertex(forEntry.getKey()))
&& !forloopListEntry.getKey().equals(forEntry.getKey())) {
forloopCount++;
@@ -1932,19 +1871,19 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (!forEverLoopList.isEmpty()) {
- for (String loopforEver : forEverLoopList) {
- List<GraphPath<vertex, DefaultEdge>> pathforloopforever = allPaths.getAllPaths(getvertex(loopforEver), getvertex(taskEndName), false,
+ if (!dependencyGraphRelations.getForEverLoopList().isEmpty()) {
+ for (String loopforEver : dependencyGraphRelations.getForEverLoopList()) {
+ List<GraphPath<Vertex, DefaultEdge>> pathforloopforever = allPaths.getAllPaths(getvertex(loopforEver), getvertex(taskEndName), false,
g.vertexSet().size());
if (pathforloopforever.size() > 0) {
for (int i = 0; i < pathforloopforever.size(); i++) {
int forloopCount = 0;
- for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
+ for (Entry<String, List<String>> previousForLoop : dependencyGraphRelations.getForLoopNextValues().entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(getvertex(previousForLoop.getValue().get(0)))) {
forloopCount++;
}
}
- for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
+ for (Entry<String, ArrayList<String>> seqEntry : dependencyGraphRelations.getOrderedSequenceList().entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (pathforloopforever.get(i).getVertexList()
.contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))) {
@@ -1964,17 +1903,17 @@ public class DirectedGraphTranslator extends JApplet {
}
private String getEventName(String taskName, TMLActivityElement currentElement2) {
- String eventName = null;
- if (currentElement2.getReferenceObject() instanceof TMLADRandom) {
- eventName = taskName + "__" + currentElement2.getName() + "__" + currentElement2.getID();
- } else if (currentElement2.getReferenceObject() instanceof TMLADUnorderedSequence) {
- eventName = taskName + "__" + UNORDERED_SEQUENCE + "__" + currentElement2.getID();
- } else if (currentElement2.getReferenceObject() != null) {
- eventName = taskName + "__" + currentElement2.getReferenceObject().toString() + "__" + currentElement2.getID();
+ String name = "";
+ if (currentElement2 instanceof TMLWaitEvent) {
+ TMLEvent event = ((TMLWaitEvent) currentElement2).getEvent();
+ name = taskName + "__" + "Wait event: " + event.getName() + "__" + currentElement2.getID();
+ } else if (currentElement2 instanceof TMLSendEvent) {
+ TMLEvent event = ((TMLSendEvent) currentElement2).getEvent();
+ name = taskName + "__" + "Send event: " + event.getName() + "__" + currentElement2.getID();
} else {
- eventName = taskName + "__" + currentElement2.getName() + "__" + currentElement2.getID();
+ name = taskName + "__" + currentElement2.getName().replace(" ", "") + "__" + currentElement2.getID();
}
- return eventName;
+ return name;
}
// get graph size
@@ -1988,8 +1927,8 @@ public class DirectedGraphTranslator extends JApplet {
}
// open graph in a frame
- public void showGraph(DirectedGraphTranslator dgraph) {
- JGraphXAdapter<vertex, DefaultEdge> graphAdapter = new JGraphXAdapter<vertex, DefaultEdge>(dgraph.getG());
+ public void showGraph(DependencyGraphTranslator dgraph) {
+ JGraphXAdapter<Vertex, DefaultEdge> graphAdapter = new JGraphXAdapter<Vertex, DefaultEdge>(dgraph.getG());
mxHierarchicalLayout layout = new mxHierarchicalLayout(graphAdapter);
layout.setInterHierarchySpacing(100);
layout.setInterRankCellSpacing(100);
@@ -2013,25 +1952,25 @@ public class DirectedGraphTranslator extends JApplet {
public void exportGraph(String filename) throws ExportException, IOException {
@SuppressWarnings({ "rawtypes", "unchecked" })
GraphMLExporter<String, DefaultEdge> gmlExporter = new GraphMLExporter();
- ComponentNameProvider<vertex> vertexIDProvider = new ComponentNameProvider<vertex>() {
+ ComponentNameProvider<Vertex> vertexIDProvider = new ComponentNameProvider<Vertex>() {
@Override
- public String getName(vertex vertex) {
+ public String getName(Vertex Vertex) {
String name;
- for (vertex v : g.vertexSet()) {
- if (v.getName().equals(vertex.getName())) {
- name = vertex.getName().toString().replaceAll("\\s+", "");
- name = vertex.getName().replaceAll("\\(", "\\u0028");
- name = vertex.getName().replaceAll("\\)", "\\u0029");
+ for (Vertex v : g.vertexSet()) {
+ if (v.getName().equals(Vertex.getName())) {
+ name = Vertex.getName().toString().replaceAll("\\s+", "");
+ name = Vertex.getName().replaceAll("\\(", "\\u0028");
+ name = Vertex.getName().replaceAll("\\)", "\\u0029");
return name;
}
}
return null;
}
};
- ComponentNameProvider<vertex> vertexNameProvider = new ComponentNameProvider<vertex>() {
+ ComponentNameProvider<Vertex> vertexNameProvider = new ComponentNameProvider<Vertex>() {
@Override
- public String getName(vertex arg0) {
- for (vertex v : g.vertexSet()) {
+ public String getName(Vertex arg0) {
+ for (Vertex v : g.vertexSet()) {
if (v.getName().equals(arg0.getName())) {
return arg0.getName();
}
@@ -2057,7 +1996,7 @@ public class DirectedGraphTranslator extends JApplet {
return Double.toString(g.getEdgeWeight(edge));
}
};
- GraphMLExporter<vertex, DefaultEdge> exporter = new GraphMLExporter<vertex, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
+ GraphMLExporter<Vertex, DefaultEdge> exporter = new GraphMLExporter<Vertex, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
edgeLabelProvider);
Writer fileWriter;
FileWriter PS = new FileWriter(filename + ".graphml");
@@ -2094,7 +2033,7 @@ public class DirectedGraphTranslator extends JApplet {
public Object[][] latencyDetailedAnalysis(String task12ID, String task22ID, Vector<SimulationTransaction> transFile1, Boolean taint,
Boolean considerAddedRules) {
try {
- for (vertex v : g.vertexSet()) {
+ for (Vertex v : g.vertexSet()) {
v.setLabel(new ArrayList<String>());
v.setMaxTaintFixedNumber(new HashMap<String, Integer>());
v.setTaintConsideredNumber(new HashMap<String, Integer>());
@@ -2109,22 +2048,28 @@ public class DirectedGraphTranslator extends JApplet {
String[] task2 = task22ID.split("__");
int task2index = task2.length;
idTask2 = task2[task2index - 1];
- String task12 = nameIDTaskList.get(idTask1);
- String task22 = nameIDTaskList.get(idTask2);
- vertex v1 = getvertex(task12);
+ String task12 = getvertexFromID(Integer.valueOf(idTask1)).toString();
+ String task22 = getvertexFromID(Integer.valueOf(idTask2)).toString();
+ Vertex v1 = getvertex(task12);
Vector<SimulationTransaction> Task1Traces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> Task2Traces = new Vector<SimulationTransaction>();
HashMap<String, Vector<String>> Task1TaintedTraces = new LinkedHashMap<String, Vector<String>>();
HashMap<String, Vector<String>> Task2TaintedTraces = new LinkedHashMap<String, Vector<String>>();
- GraphPath<vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(task22));
+ GraphPath<Vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(task22));
times1.clear();
times2.clear();
+ Vector<SimulationTransaction> delayDueTosimTracesTaint = new Vector<SimulationTransaction>();
+ dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
+ dataByTask = null;
+ relatedsimTraces = new Vector<SimulationTransaction>();
+ delayDueTosimTraces = new Vector<SimulationTransaction>();
+ dependencyGraphRelations.setRunnableTimePerDevice(new HashMap<String, ArrayList<ArrayList<Integer>>>());
if (path2 != null && path2.getLength() > 0) {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
- GraphPath<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
- GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName),
+ GraphPath<Vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
+ GraphPath<Vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName),
getvertex(task22));
if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
@@ -2134,8 +2079,8 @@ public class DirectedGraphTranslator extends JApplet {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
- GraphPath<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
- GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName),
+ GraphPath<Vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
+ GraphPath<Vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName),
getvertex(task22));
if ((pathTochannel != null && pathTochannel.getLength() > 0) || (pathFromChannel != null && pathFromChannel.getLength() > 0)) {
devicesToBeConsidered.addAll(busChList);
@@ -2186,11 +2131,11 @@ public class DirectedGraphTranslator extends JApplet {
}
// ADD rules as edges
if (considerAddedRules) {
- if (ruleAddedEdges.size() > 0) {
- for (Entry<vertex, List<vertex>> rulevertex : ruleAddedEdges.entrySet()) {
- vertex fromVertex = rulevertex.getKey();
- List<vertex> listOfToV = rulevertex.getValue();
- for (vertex toVertex : listOfToV) {
+ if (dependencyGraphRelations.getRuleAddedEdges().size() > 0) {
+ for (Entry<Vertex, List<Vertex>> rulevertex : dependencyGraphRelations.getRuleAddedEdges().entrySet()) {
+ Vertex fromVertex = rulevertex.getKey();
+ List<Vertex> listOfToV = rulevertex.getValue();
+ for (Vertex toVertex : listOfToV) {
if (g.containsVertex(toVertex) && g.containsVertex(fromVertex)) {
g.addEdge(fromVertex, toVertex);
}
@@ -2207,21 +2152,21 @@ public class DirectedGraphTranslator extends JApplet {
st.command = st.command.replace(SELECT_EVENT, WAIT_ST + st.channelName);
String[] chN = st.channelName.split("__");
String eventN = chN[chN.length - 1];
- vertex v = getvertexFromID(id);
+ Vertex v = getvertexFromID(id);
String vName = v.getName();
if (Graphs.vertexHasSuccessors(g, v)) {
- for (vertex vsec : Graphs.successorListOf(g, v)) {
- if (vsec.getName().contains(WAIT_EVENT + eventN + "(")) {
+ for (Vertex vsec : Graphs.successorListOf(g, v)) {
+ if (vsec.getName().contains("__" + eventN + "__")) {
st.id = String.valueOf(vsec.getId());
id = vsec.getId();
}
}
}
} else if (st.command.contains(WAIT_REQ_LABEL)) {
- vertex v = getvertexFromID(id);
- if (v.getType() == vertex.TYPE_START) {
+ Vertex v = getvertexFromID(id);
+ if (v.getType() == Vertex.TYPE_START) {
if (Graphs.vertexHasSuccessors(g, v)) {
- for (vertex vbefore : Graphs.successorListOf(g, v)) {
+ for (Vertex vbefore : Graphs.successorListOf(g, v)) {
if (vbefore.getName().contains(GET_REQ_ARG_LABEL)) {
st.id = String.valueOf(vbefore.getId());
id = vbefore.getId();
@@ -2259,7 +2204,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
if (tasknameCheckID.isEmpty()) {
- for (vertex tasknameCheck : g.vertexSet()) {
+ for (Vertex tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.toString().replaceAll(" ", "").split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
@@ -2284,9 +2229,9 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- vertex taskVertex = getvertex(tasknameCheckID);
+ Vertex taskVertex = getvertex(tasknameCheckID);
if (taskVertex != null && Graphs.vertexHasSuccessors(g, taskVertex) && !taskVertex.getLabel().isEmpty()) {
- for (vertex v : Graphs.successorListOf(g, taskVertex)) {
+ for (Vertex v : Graphs.successorListOf(g, taskVertex)) {
String labelToaAddtoV = getfirstCommonLabel(v, taskVertex);
// removed after testing in for loop/ action/choice
/*
@@ -2327,7 +2272,7 @@ public class DirectedGraphTranslator extends JApplet {
*
* } } }
*/
- if (v.getType() == vertex.TYPE_CHANNEL || v.getType() == vertex.TYPE_TRANSACTION) {
+ if (v.getType() == Vertex.getTypeChannel() || v.getType() == Vertex.TYPE_TRANSACTION) {
if (v.getLabel().contains(labelToaAddtoV)) {
if (v.getMaxTaintFixedNumber().containsKey(labelToaAddtoV)) {
if (v.getMaxTaintFixedNumber().get(labelToaAddtoV) != v.getTaintFixedNumber()) {
@@ -2339,18 +2284,18 @@ public class DirectedGraphTranslator extends JApplet {
v.addLabel(labelToaAddtoV);
v.getMaxTaintFixedNumber().put(labelToaAddtoV, v.getTaintFixedNumber());
}
- for (vertex subV : Graphs.successorListOf(g, v)) {
+ for (Vertex subV : Graphs.successorListOf(g, v)) {
if (!subV.equals(v1)) {
- if (!(subV.getType() == vertex.TYPE_TRANSACTION || subV.getType() == vertex.TYPE_CHANNEL)) {
- HashMap<vertex, List<vertex>> NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
- HashMap<vertex, List<vertex>> NonTransVertexes2 = new LinkedHashMap<vertex, List<vertex>>();
- HashMap<vertex, List<vertex>> NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
+ if (!(subV.getType() == Vertex.TYPE_TRANSACTION || subV.getType() == Vertex.getTypeChannel())) {
+ HashMap<Vertex, List<Vertex>> NonTransVertexes = new LinkedHashMap<Vertex, List<Vertex>>();
+ HashMap<Vertex, List<Vertex>> NonTransVertexes2 = new LinkedHashMap<Vertex, List<Vertex>>();
+ HashMap<Vertex, List<Vertex>> NonTransVertexesAdded = new LinkedHashMap<Vertex, List<Vertex>>();
NonTransVertexes.putAll(taintingNonTransVertexes(v, taskVertex, v1));
int addeditems = 0;
- for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
- vertex vet = e.getKey();
- List<vertex> vl = e.getValue();
- for (vertex ver : vl) {
+ for (Entry<Vertex, List<Vertex>> e : NonTransVertexes.entrySet()) {
+ Vertex vet = e.getKey();
+ List<Vertex> vl = e.getValue();
+ for (Vertex ver : vl) {
NonTransVertexes2 = taintingNonTransVertexes(ver, vet, v1);
NonTransVertexesAdded.putAll(NonTransVertexes2);
// NonTransVertexes.putAll(taintingNonTransVertexes(ver, vet, v1));
@@ -2358,13 +2303,13 @@ public class DirectedGraphTranslator extends JApplet {
}
}
while (addeditems > 0) {
- NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
+ NonTransVertexes = new LinkedHashMap<Vertex, List<Vertex>>();
NonTransVertexes.putAll(NonTransVertexesAdded);
- NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
- for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
- vertex vet = e.getKey();
- List<vertex> vl = e.getValue();
- for (vertex ver : vl) {
+ NonTransVertexesAdded = new LinkedHashMap<Vertex, List<Vertex>>();
+ for (Entry<Vertex, List<Vertex>> e : NonTransVertexes.entrySet()) {
+ Vertex vet = e.getKey();
+ List<Vertex> vl = e.getValue();
+ for (Vertex ver : vl) {
NonTransVertexesAdded.putAll(taintingNonTransVertexes(ver, vet, v1));
// NonTransVertexes.putAll(taintingNonTransVertexes(ver, vet, v1));
addeditems--;
@@ -2376,15 +2321,15 @@ public class DirectedGraphTranslator extends JApplet {
}
}
} else {
- HashMap<vertex, List<vertex>> NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
- HashMap<vertex, List<vertex>> NonTransVertexes2 = new LinkedHashMap<vertex, List<vertex>>();
- HashMap<vertex, List<vertex>> NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
+ HashMap<Vertex, List<Vertex>> NonTransVertexes = new LinkedHashMap<Vertex, List<Vertex>>();
+ HashMap<Vertex, List<Vertex>> NonTransVertexes2 = new LinkedHashMap<Vertex, List<Vertex>>();
+ HashMap<Vertex, List<Vertex>> NonTransVertexesAdded = new LinkedHashMap<Vertex, List<Vertex>>();
NonTransVertexes.putAll(taintingNonTransVertexes(v, taskVertex, v1));
int addeditems = 0;
- for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
- vertex vet = e.getKey();
- List<vertex> vl = e.getValue();
- for (vertex ver : vl) {
+ for (Entry<Vertex, List<Vertex>> e : NonTransVertexes.entrySet()) {
+ Vertex vet = e.getKey();
+ List<Vertex> vl = e.getValue();
+ for (Vertex ver : vl) {
NonTransVertexes2 = taintingNonTransVertexes(ver, vet, v1);
NonTransVertexesAdded.putAll(NonTransVertexes2);
// NonTransVertexes.putAll(taintingNonTransVertexes(ver, vet, v1));
@@ -2392,13 +2337,13 @@ public class DirectedGraphTranslator extends JApplet {
}
}
while (addeditems > 0) {
- NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
+ NonTransVertexes = new LinkedHashMap<Vertex, List<Vertex>>();
NonTransVertexes.putAll(NonTransVertexesAdded);
- NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
- for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
- vertex vet = e.getKey();
- List<vertex> vl = e.getValue();
- for (vertex ver : vl) {
+ NonTransVertexesAdded = new LinkedHashMap<Vertex, List<Vertex>>();
+ for (Entry<Vertex, List<Vertex>> e : NonTransVertexes.entrySet()) {
+ Vertex vet = e.getKey();
+ List<Vertex> vl = e.getValue();
+ for (Vertex ver : vl) {
NonTransVertexesAdded.putAll(taintingNonTransVertexes(ver, vet, v1));
// NonTransVertexes.putAll(taintingNonTransVertexes(ver, vet, v1));
addeditems--;
@@ -2418,11 +2363,11 @@ public class DirectedGraphTranslator extends JApplet {
}
// remove rules edges
if (considerAddedRules) {
- if (ruleAddedEdges.size() > 0) {
- for (Entry<vertex, List<vertex>> rulevertex : ruleAddedEdges.entrySet()) {
- vertex fromVertex = rulevertex.getKey();
- List<vertex> listOfToV = rulevertex.getValue();
- for (vertex toVertex : listOfToV) {
+ if (dependencyGraphRelations.getRuleAddedEdges().size() > 0) {
+ for (Entry<Vertex, List<Vertex>> rulevertex : dependencyGraphRelations.getRuleAddedEdges().entrySet()) {
+ Vertex fromVertex = rulevertex.getKey();
+ List<Vertex> listOfToV = rulevertex.getValue();
+ for (Vertex toVertex : listOfToV) {
if (g.containsVertex(fromVertex) && g.containsVertex(toVertex) && g.containsEdge(fromVertex, toVertex)) {
g.removeEdge(fromVertex, toVertex);
}
@@ -2436,8 +2381,8 @@ public class DirectedGraphTranslator extends JApplet {
// if (path2 != null && path2.getLength() > 0) {
j++;
if (path2 != null && path2.getLength() > 0 && taskname != "") {
- GraphPath<vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
+ GraphPath<Vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
+ GraphPath<Vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
getvertex(task22));
if (taskname.equals(task12) || (hasLabelAstask12 && taskname.equals(task22)) || (hasLabelAstask12 && (pathToOrigin != null
&& pathToOrigin.getLength() > 0 && pathToDestination != null && pathToDestination.getLength() > 0))) {
@@ -2466,14 +2411,14 @@ public class DirectedGraphTranslator extends JApplet {
timeValues.add(1, startTime);
if (!(st.runnableTime).equals(st.startTime)) {
String dName = st.deviceName + "_" + st.coreNumber;
- if (runnableTimePerDevice.containsKey(dName)) {
- if (!runnableTimePerDevice.get(dName).contains(timeValues)) {
- runnableTimePerDevice.get(dName).add(timeValues);
+ if (dependencyGraphRelations.getRunnableTimePerDevice().containsKey(dName)) {
+ if (!dependencyGraphRelations.getRunnableTimePerDevice().get(dName).contains(timeValues)) {
+ dependencyGraphRelations.getRunnableTimePerDevice().get(dName).add(timeValues);
}
} else {
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
- runnableTimePerDevice.put(dName, timeValuesList);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
@@ -2483,8 +2428,8 @@ public class DirectedGraphTranslator extends JApplet {
}
} else {
if (!taskname.equals(null) && !taskname.equals("")) {
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
getvertex(task22));
if (taskname.equals(task12) || (hasLabelAstask12 && taskname.equals(task22))
|| (hasLabelAstask12 && (pathExistsTestwithTask1 != null && pathExistsTestwithTask1.getLength() > 0
@@ -2514,14 +2459,14 @@ public class DirectedGraphTranslator extends JApplet {
timeValues.add(1, startTime);
if (!(st.runnableTime).equals(st.startTime)) {
String dName = st.deviceName + "_" + st.coreNumber;
- if (runnableTimePerDevice.containsKey(dName)) {
- if (!runnableTimePerDevice.get(dName).contains(timeValues)) {
- runnableTimePerDevice.get(dName).add(timeValues);
+ if (dependencyGraphRelations.getRunnableTimePerDevice().containsKey(dName)) {
+ if (!dependencyGraphRelations.getRunnableTimePerDevice().get(dName).contains(timeValues)) {
+ dependencyGraphRelations.getRunnableTimePerDevice().get(dName).add(timeValues);
}
} else {
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
- runnableTimePerDevice.put(dName, timeValuesList);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
@@ -2595,11 +2540,10 @@ public class DirectedGraphTranslator extends JApplet {
}
}
dataByTaskR.put(i, relatedSTTaint);
- timeDelayedPerRow.put(i, runnableTimePerDevice);
+ timeDelayedPerRow.put(i, dependencyGraphRelations.getRunnableTimePerDevice());
i++;
}
for (int row = 0; row < dataByTask.length; row++) {
- Vector<SimulationTransaction> delayDueTosimTracesTaint = new Vector<SimulationTransaction>();
for (SimulationTransaction st : delayDueTosimTraces) {
int startTime = Integer.valueOf(st.startTime);
int endTime = Integer.valueOf(st.endTime);
@@ -2637,21 +2581,21 @@ public class DirectedGraphTranslator extends JApplet {
}
if (st.command.contains(SELECT_EVENT_PARAM) && getvertexFromID(selectID).getType() == 11) {
st.command = st.command.replace(SELECT_EVENT_PARAM, WAIT_LABEL + st.channelName);
- vertex selectV = getvertexFromID(selectID);
+ Vertex selectV = getvertexFromID(selectID);
String[] chName = st.channelName.toString().split("__");
int waitEvntName = chName.length;
String waitEvnt = chName[waitEvntName - 1];
- for (vertex nextV : Graphs.successorListOf(g, selectV)) {
+ for (Vertex nextV : Graphs.successorListOf(g, selectV)) {
if (nextV.getName().contains(waitEvnt)) {
st.id = String.valueOf(nextV.getId());
selectID = nextV.getId();
}
}
} else if (st.command.contains(WAIT_REQ_LABEL)) {
- vertex v = getvertexFromID(selectID);
- if (v.getType() == vertex.TYPE_START) {
+ Vertex v = getvertexFromID(selectID);
+ if (v.getType() == Vertex.TYPE_START) {
if (Graphs.vertexHasSuccessors(g, v)) {
- for (vertex vbefore : Graphs.successorListOf(g, v)) {
+ for (Vertex vbefore : Graphs.successorListOf(g, v)) {
if (vbefore.getName().contains(GET_REQ_ARG_LABEL)) {
st.id = String.valueOf(vbefore.getId());
selectID = vbefore.getId();
@@ -2683,14 +2627,12 @@ public class DirectedGraphTranslator extends JApplet {
minIndex = times1.size();
}
dataByTask = new Object[minIndex][7];
- dataByTaskBYRow = new Object[minIndex][2];
- dataByTaskHWBYRow = new Object[minIndex][2];
for (int i = 0; i < minIndex; i++) {
HashMap<String, ArrayList<SimulationTransaction>> relatedHWs = new HashMap<String, ArrayList<SimulationTransaction>>();
HashMap<String, ArrayList<SimulationTransaction>> relatedTasks = new HashMap<String, ArrayList<SimulationTransaction>>();
relatedsimTraces = new Vector<SimulationTransaction>();
delayDueTosimTraces = new Vector<SimulationTransaction>();
- runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
+ dependencyGraphRelations.setRunnableTimePerDevice(new HashMap<String, ArrayList<ArrayList<Integer>>>());
for (SimulationTransaction st : transFile1) {
int startTime = Integer.valueOf(st.startTime);
int endTime = Integer.valueOf(st.endTime);
@@ -2699,21 +2641,21 @@ public class DirectedGraphTranslator extends JApplet {
if (!(startTime < times1.get(i) && endTime <= times1.get(i)) && !(startTime >= times2.get(i) && endTime > times2.get(i))) {
if (st.command.contains(SELECT_EVENT_PARAM) && getvertexFromID(selectID).getType() == 11) {
st.command = st.command.replace(SELECT_EVENT_PARAM, WAIT_LABEL + st.channelName);
- vertex selectV = getvertexFromID(selectID);
+ Vertex selectV = getvertexFromID(selectID);
String[] chName = st.channelName.toString().split("__");
int waitEvntName = chName.length;
String waitEvnt = chName[waitEvntName - 1];
- for (vertex nextV : Graphs.successorListOf(g, selectV)) {
+ for (Vertex nextV : Graphs.successorListOf(g, selectV)) {
if (nextV.getName().contains(waitEvnt)) {
st.id = String.valueOf(nextV.getId());
selectID = nextV.getId();
}
}
} else if (st.command.contains(WAIT_REQ_LABEL)) {
- vertex v = getvertexFromID(selectID);
- if (v.getType() == vertex.TYPE_START) {
+ Vertex v = getvertexFromID(selectID);
+ if (v.getType() == Vertex.TYPE_START) {
if (Graphs.vertexHasSuccessors(g, v)) {
- for (vertex vbefore : Graphs.successorListOf(g, v)) {
+ for (Vertex vbefore : Graphs.successorListOf(g, v)) {
if (vbefore.getName().startsWith(GET_REQ_ARG_LABEL)) {
st.id = String.valueOf(vbefore.getId());
selectID = vbefore.getId();
@@ -2740,7 +2682,7 @@ public class DirectedGraphTranslator extends JApplet {
endTime = times2.get(i);
}
String taskname = "";
- for (vertex tasknameCheck : g.vertexSet()) {
+ for (Vertex tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.toString().replaceAll(" ", "").split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
@@ -2756,8 +2698,8 @@ public class DirectedGraphTranslator extends JApplet {
// there is a path between task 1 and task 2
if (path2 != null && path2.getLength() > 0) {
if (!taskname.equals(null) && !taskname.equals("")) {
- GraphPath<vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
+ GraphPath<Vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, getvertex(taskname));
+ GraphPath<Vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
getvertex(task22));
if (taskname.equals(task12) || taskname.equals(task22) || (pathToOrigin != null && pathToOrigin.getLength() > 0
&& pathToDestination != null && pathToDestination.getLength() > 0)) {
@@ -2767,14 +2709,14 @@ public class DirectedGraphTranslator extends JApplet {
timeValues.add(1, startTime);
String dName = st.deviceName + "_" + st.coreNumber;
if (!(st.runnableTime).equals(st.startTime)) {
- if (runnableTimePerDevice.containsKey(dName)) {
- if (!runnableTimePerDevice.get(dName).contains(timeValues)) {
- runnableTimePerDevice.get(dName).add(timeValues);
+ if (dependencyGraphRelations.getRunnableTimePerDevice().containsKey(dName)) {
+ if (!dependencyGraphRelations.getRunnableTimePerDevice().get(dName).contains(timeValues)) {
+ dependencyGraphRelations.getRunnableTimePerDevice().get(dName).add(timeValues);
}
} else {
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
- runnableTimePerDevice.put(dName, timeValuesList);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
@@ -2785,9 +2727,9 @@ public class DirectedGraphTranslator extends JApplet {
}
} else {
if (!taskname.equals(null) && !taskname.equals("")) {
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, v1,
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, v1,
getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g,
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g,
getvertex(taskname), getvertex(task22));
if (pathExistsTestwithTask1 != null && pathExistsTestwithTask1.getLength() > 0
|| pathExistsTestwithTask2 != null && pathExistsTestwithTask2.getLength() > 0) {
@@ -2813,7 +2755,7 @@ public class DirectedGraphTranslator extends JApplet {
dataByTask[i][5] = "";
dataByTaskR.put(i, relatedsimTraces);
dataBydelayedTasks.put(i, delayDueTosimTraces);
- timeDelayedPerRow.put(i, runnableTimePerDevice);
+ timeDelayedPerRow.put(i, dependencyGraphRelations.getRunnableTimePerDevice());
// dataByTask[i][5] = list.getModel();
// dataByTask[i][6] = totalTime;
}
@@ -3040,20 +2982,20 @@ public class DirectedGraphTranslator extends JApplet {
}
}
- private String getfirstCommonLabel(vertex vertex, vertex v) {
+ private String getfirstCommonLabel(Vertex Vertex, Vertex v) {
for (int i = 0; i < v.getLabel().size(); i++) {
- if (!vertex.getLabel().contains(v.getLabel().get(i))) {
+ if (!Vertex.getLabel().contains(v.getLabel().get(i))) {
return v.getLabel().get(i);
}
}
for (int j = 0; j < v.getLabel().size(); j++) {
- if (vertex.getMaxTaintFixedNumber().containsKey(v.getLabel().get(j)) && vertex.getMaxTaintFixedNumber().get(v.getLabel().get(j)) == 0) {
+ if (Vertex.getMaxTaintFixedNumber().containsKey(v.getLabel().get(j)) && Vertex.getMaxTaintFixedNumber().get(v.getLabel().get(j)) == 0) {
return v.getLabel().get(j);
}
}
for (int j = 0; j < v.getLabel().size(); j++) {
- if (vertex.getTaintConsideredNumber().containsKey(v.getLabel().get(j))
- && vertex.getTaintConsideredNumber().get(v.getLabel().get(j)) < vertex.getMaxTaintFixedNumber().get(v.getLabel().get(j))) {
+ if (Vertex.getTaintConsideredNumber().containsKey(v.getLabel().get(j))
+ && Vertex.getTaintConsideredNumber().get(v.getLabel().get(j)) < Vertex.getMaxTaintFixedNumber().get(v.getLabel().get(j))) {
return v.getLabel().get(j);
}
}
@@ -3065,8 +3007,8 @@ public class DirectedGraphTranslator extends JApplet {
private Boolean considerVertex(String task12, String taskname, String virtualLength, String command) {
boolean hasLabelAstask12 = false;
- vertex v1 = getvertex(task12);
- vertex v = getvertex(taskname);
+ Vertex v1 = getvertex(task12);
+ Vertex v = getvertex(taskname);
String Label = null;
if (command.contains(WRITE) || command.contains(READ)) {
String[] str = command.split(",");
@@ -3090,9 +3032,9 @@ public class DirectedGraphTranslator extends JApplet {
String labelConsidered = v.getLabel().get(i);
int consideredNbr = v.getTaintConsideredNumber().get(labelConsidered);
if (Graphs.vertexHasPredecessors(g, v)) {
- for (vertex previousV : Graphs.predecessorListOf(g, v)) {
- if (previousV.getType() == vertex.TYPE_CHOICE) {
- for (Entry<vertex, List<vertex>> vChoice : allChoiceValues.entrySet()) {
+ for (Vertex previousV : Graphs.predecessorListOf(g, v)) {
+ if (previousV.getType() == Vertex.TYPE_CHOICE) {
+ for (Entry<Vertex, List<Vertex>> vChoice : dependencyGraphRelations.getAllChoiceValues().entrySet()) {
if (previousV.equals(vChoice.getKey())) {
if (v1.getLabel().contains(v.getLabel().get(i)) && consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
@@ -3113,8 +3055,8 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (previousV.getType() == vertex.TYPE_SELECT_EVT) {
- for (Entry<vertex, List<vertex>> vChoice : allSelectEvtValues.entrySet()) {
+ if (previousV.getType() == Vertex.TYPE_SELECT_EVT) {
+ for (Entry<Vertex, List<Vertex>> vChoice : dependencyGraphRelations.getAllSelectEvtValues().entrySet()) {
if (previousV.equals(vChoice.getKey())) {
if (v1.getLabel().contains(v.getLabel().get(i)) && consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
@@ -3134,8 +3076,8 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- } else if (previousV.getType() == vertex.TYPE_SEQ) {
- for (Entry<vertex, List<vertex>> vSeq : allSeqValues.entrySet()) {
+ } else if (previousV.getType() == Vertex.TYPE_SEQ) {
+ for (Entry<Vertex, List<Vertex>> vSeq : dependencyGraphRelations.getAllSeqValues().entrySet()) {
if (previousV.equals(vSeq.getKey())) {
if (v1.getLabel().contains(v.getLabel().get(i)) && consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
@@ -3155,7 +3097,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- } else if (previousV.getType() == vertex.TYPE_UNORDER_SEQ) {
+ } else if (previousV.getType() == Vertex.TYPE_UNORDER_SEQ) {
if (v1.getLabel().contains(v.getLabel().get(i)) && consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
consideredNbr = v.getTaintConsideredNumber().get(labelConsidered);
@@ -3163,10 +3105,10 @@ public class DirectedGraphTranslator extends JApplet {
v.getTaintConsideredNumber().put(labelConsidered, consideredNbr);
hasLabelAstask12 = true;
v.setVirtualLengthAdded(0);
- for (Entry<vertex, List<vertex>> vSeq : allRandomSeqValues.entrySet()) {
+ for (Entry<Vertex, List<Vertex>> vSeq : dependencyGraphRelations.getAllRandomSeqValues().entrySet()) {
if (previousV.equals(vSeq.getKey())) {
int count = 0;
- for (vertex seqNext : vSeq.getValue()) {
+ for (Vertex seqNext : vSeq.getValue()) {
if (seqNext.getTaintConsideredNumber().get(labelConsidered) != seqNext.getMaxTaintFixedNumber()
.get(labelConsidered)) {
count++;
@@ -3186,13 +3128,13 @@ public class DirectedGraphTranslator extends JApplet {
hasLabelAstask12 = true;
}
}
- } else if ((previousV.getType() == vertex.TYPE_FOR_LOOP || previousV.getType() == vertex.TYPE_STATIC_FOR_LOOP)
+ } else if ((previousV.getType() == Vertex.TYPE_FOR_LOOP || previousV.getType() == Vertex.TYPE_STATIC_FOR_LOOP)
&& (previousV.getLabel().contains(labelConsidered))) {
if (v1.getLabel().contains(v.getLabel().get(i)) && (previousV.getTaintConsideredNumber()
.get(labelConsidered) == previousV.getMaxTaintFixedNumber().get(labelConsidered) - 1)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
- for (Entry<String, List<String>> nextvertexOfLoop : allForLoopNextValues.entrySet()) {
- vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
+ for (Entry<String, List<String>> nextvertexOfLoop : dependencyGraphRelations.getAllForLoopNextValues().entrySet()) {
+ Vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
if (v.getName().equals(previousV.getName())) {
consideredNbr = v.getTaintConsideredNumber().get(labelConsidered);
consideredNbr++;
@@ -3214,16 +3156,16 @@ public class DirectedGraphTranslator extends JApplet {
}
if (Graphs.vertexHasSuccessors(g, v)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
- for (vertex nextV : Graphs.successorListOf(g, v)) {
- if (nextV.getType() == vertex.TYPE_END) {
+ for (Vertex nextV : Graphs.successorListOf(g, v)) {
+ if (nextV.getType() == Vertex.TYPE_END) {
if (nextV.getLabel().contains(labelConsidered)) {
consideredNbr = nextV.getTaintConsideredNumber().get(labelConsidered);
if (consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
consideredNbr++;
nextV.getTaintConsideredNumber().put(labelConsidered, consideredNbr);
}
- for (vertex subE : Graphs.successorListOf(g, nextV)) {
- if (subE.getType() == vertex.TYPE_FOR_LOOP || subE.getType() == vertex.TYPE_STATIC_FOR_LOOP) {
+ for (Vertex subE : Graphs.successorListOf(g, nextV)) {
+ if (subE.getType() == Vertex.TYPE_FOR_LOOP || subE.getType() == Vertex.TYPE_STATIC_FOR_LOOP) {
consideredNbr = subE.getTaintConsideredNumber().get(labelConsidered);
if (consideredNbr < subE.getMaxTaintFixedNumber().get(labelConsidered)) {
consideredNbr++;
@@ -3232,7 +3174,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- } else if (nextV.getType() == vertex.TYPE_START) {
+ } else if (nextV.getType() == Vertex.TYPE_START) {
consideredNbr = nextV.getTaintConsideredNumber().get(labelConsidered);
if (consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
consideredNbr++;
@@ -3242,7 +3184,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (!hasLabelAstask12 && (v.getType() == vertex.TYPE_TRANSACTION || v.getType() == vertex.TYPE_CHANNEL)) {
+ if (!hasLabelAstask12 && (v.getType() == Vertex.TYPE_TRANSACTION || v.getType() == Vertex.getTypeChannel())) {
consideredNbr = v.getTaintConsideredNumber().get(labelConsidered);
if (v1.getLabel().contains(v.getLabel().get(i)) && consideredNbr < v.getMaxTaintFixedNumber().get(labelConsidered)) {
if (v.getVirtualLengthAdded() == v.getSampleNumber()) {
@@ -3262,15 +3204,15 @@ public class DirectedGraphTranslator extends JApplet {
return hasLabelAstask12;
}
- private HashMap<vertex, List<vertex>> taintingNonTransVertexes(vertex subV, vertex v, vertex v1) {
- HashMap<vertex, List<vertex>> NonTransV = new LinkedHashMap<vertex, List<vertex>>();
+ private HashMap<Vertex, List<Vertex>> taintingNonTransVertexes(Vertex subV, Vertex v, Vertex v1) {
+ HashMap<Vertex, List<Vertex>> NonTransV = new LinkedHashMap<Vertex, List<Vertex>>();
String label = getfirstCommonLabel(subV, v);
int i = v.getMaxTaintFixedNumber().get(label);
;
- if (v.getType() == vertex.TYPE_FOR_EVER_LOOP || v.getType() == vertex.TYPE_STATIC_FOR_LOOP || v.getType() == vertex.TYPE_FOR_LOOP) {
- for (Entry<String, List<String>> nextvertexOfLoop : allForLoopNextValues.entrySet()) {
- vertex vFor0 = getvertex(nextvertexOfLoop.getValue().get(0));
- vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
+ if (v.getType() == Vertex.TYPE_FOR_EVER_LOOP || v.getType() == Vertex.TYPE_STATIC_FOR_LOOP || v.getType() == Vertex.TYPE_FOR_LOOP) {
+ for (Entry<String, List<String>> nextvertexOfLoop : dependencyGraphRelations.getAllForLoopNextValues().entrySet()) {
+ Vertex vFor0 = getvertex(nextvertexOfLoop.getValue().get(0));
+ Vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
if ((getvertex(nextvertexOfLoop.getKey())).equals(v)) {
if (subV.equals(vFor1)) {
int max = subV.getMaxTaintFixedNumber().get(label) / subV.getTaintFixedNumber();
@@ -3279,7 +3221,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- if (subV.getType() == vertex.TYPE_FOR_EVER_LOOP) {
+ if (subV.getType() == Vertex.TYPE_FOR_EVER_LOOP) {
if (subV.getLabel().contains(label)) {
if (subV.getMaxTaintFixedNumber().containsKey(label)) {
if (subV.getMaxTaintFixedNumber().get(label) != i) {
@@ -3293,7 +3235,7 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- for (vertex subFor : Graphs.successorListOf(g, subV)) {
+ for (Vertex subFor : Graphs.successorListOf(g, subV)) {
if (!subFor.equals(v1)) {
/*
* if (subFor.getLabel().contains(label)) { if
@@ -3310,18 +3252,18 @@ public class DirectedGraphTranslator extends JApplet {
subFor.addLabel(label);
subFor.getMaxTaintFixedNumber().put(label, subV.getMaxTaintFixedNumber().get(label) * subFor.getTaintFixedNumber());
}
- if (subFor.getType() != vertex.TYPE_TRANSACTION) {
+ if (subFor.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subFor);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subFor);
NonTransV.put(subV, lv);
}
}
}
}
- } else if ((subV.getType() == vertex.TYPE_STATIC_FOR_LOOP || subV.getType() == vertex.TYPE_FOR_LOOP)) {
+ } else if ((subV.getType() == Vertex.TYPE_STATIC_FOR_LOOP || subV.getType() == Vertex.TYPE_FOR_LOOP)) {
/*
* if (subV.getLabel().contains(label)) { if
* (subV.getMaxTaintFixedNumber().containsKey(label)) { if
@@ -3338,9 +3280,9 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- for (Entry<String, List<String>> nextvertexOfLoop : allForLoopNextValues.entrySet()) {
- vertex vFor0 = getvertex(nextvertexOfLoop.getValue().get(0));
- vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
+ for (Entry<String, List<String>> nextvertexOfLoop : dependencyGraphRelations.getAllForLoopNextValues().entrySet()) {
+ Vertex vFor0 = getvertex(nextvertexOfLoop.getValue().get(0));
+ Vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
if ((getvertex(nextvertexOfLoop.getKey())).equals(subV)) {
if (!vFor0.equals(v1)) {
/*
@@ -3356,11 +3298,11 @@ public class DirectedGraphTranslator extends JApplet {
vFor0.addLabel(label);
vFor0.getMaxTaintFixedNumber().put(label, subV.getMaxTaintFixedNumber().get(label) * vFor0.getTaintFixedNumber());
}
- if (vFor0.getType() != vertex.TYPE_TRANSACTION) {
+ if (vFor0.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(vFor0);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(vFor0);
NonTransV.put(subV, lv);
}
@@ -3382,11 +3324,11 @@ public class DirectedGraphTranslator extends JApplet {
vFor1.addLabel(label);
vFor1.getMaxTaintFixedNumber().put(label, vFor1.getTaintFixedNumber() * max);
}
- if (vFor1.getType() != vertex.TYPE_TRANSACTION) {
+ if (vFor1.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(vFor1);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(vFor1);
NonTransV.put(subV, lv);
}
@@ -3394,7 +3336,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- } else if (subV.getType() == vertex.TYPE_CHOICE) {
+ } else if (subV.getType() == Vertex.TYPE_CHOICE) {
/*
* if (subV.getLabel().contains(label)) { if
* (subV.getMaxTaintFixedNumber().containsKey(label)) { if
@@ -3409,8 +3351,8 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- List<vertex> subChoice = new ArrayList<vertex>();
- for (vertex subCh : Graphs.successorListOf(g, subV)) {
+ List<Vertex> subChoice = new ArrayList<Vertex>();
+ for (Vertex subCh : Graphs.successorListOf(g, subV)) {
subChoice.add(subCh);
if (!subCh.equals(v1)) {
if (subCh.getLabel().contains(label)) {
@@ -3425,25 +3367,25 @@ public class DirectedGraphTranslator extends JApplet {
subCh.addLabel(label);
subCh.getMaxTaintFixedNumber().put(label, subV.getMaxTaintFixedNumber().get(label) * subCh.getTaintFixedNumber());
}
- if (subCh.getType() != vertex.TYPE_TRANSACTION) {
+ if (subCh.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subCh);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subCh);
NonTransV.put(subV, lv);
}
}
}
}
- allChoiceValues.put(subV, subChoice);
- } else if (subV.getType() == vertex.TYPE_SELECT_EVT) {
+ dependencyGraphRelations.getAllChoiceValues().put(subV, subChoice);
+ } else if (subV.getType() == Vertex.TYPE_SELECT_EVT) {
if (!subV.getLabel().contains(label)) {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- List<vertex> subChoice = new ArrayList<vertex>();
- for (vertex subCh : Graphs.successorListOf(g, subV)) {
+ List<Vertex> subChoice = new ArrayList<Vertex>();
+ for (Vertex subCh : Graphs.successorListOf(g, subV)) {
subChoice.add(subCh);
if (!subCh.equals(v1)) {
if (subCh.getLabel().contains(label)) {
@@ -3458,19 +3400,19 @@ public class DirectedGraphTranslator extends JApplet {
subCh.addLabel(label);
subCh.getMaxTaintFixedNumber().put(label, subV.getMaxTaintFixedNumber().get(label) * subCh.getTaintFixedNumber());
}
- if (subCh.getType() != vertex.TYPE_TRANSACTION) {
+ if (subCh.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subCh);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subCh);
NonTransV.put(subV, lv);
}
}
}
}
- allSelectEvtValues.put(subV, subChoice);
- } else if (subV.getType() == vertex.TYPE_END) {
+ dependencyGraphRelations.getAllSelectEvtValues().put(subV, subChoice);
+ } else if (subV.getType() == Vertex.TYPE_END) {
if (subV.getLabel().contains(label)) {
if (subV.getMaxTaintFixedNumber().containsKey(label)) {
if (subV.getMaxTaintFixedNumber().get(label) != i) {
@@ -3483,9 +3425,9 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- for (vertex subSE : Graphs.successorListOf(g, subV)) {
+ for (Vertex subSE : Graphs.successorListOf(g, subV)) {
if (!subSE.equals(v1)) {
- if (subSE.getType() == vertex.TYPE_STATIC_FOR_LOOP || subSE.getType() == vertex.TYPE_FOR_LOOP) {
+ if (subSE.getType() == Vertex.TYPE_STATIC_FOR_LOOP || subSE.getType() == Vertex.TYPE_FOR_LOOP) {
if (subSE.getLabel().contains(label)) {
if (subSE.getMaxTaintFixedNumber().containsKey(label)) {
if (subSE.getMaxTaintFixedNumber().get(label) != subV.getMaxTaintFixedNumber().get(label)) {
@@ -3496,9 +3438,9 @@ public class DirectedGraphTranslator extends JApplet {
subSE.addLabel(label);
subSE.getMaxTaintFixedNumber().put(label, subV.getMaxTaintFixedNumber().get(label));
}
- for (Entry<String, List<String>> nextvertexOfLoop : allForLoopNextValues.entrySet()) {
+ for (Entry<String, List<String>> nextvertexOfLoop : dependencyGraphRelations.getAllForLoopNextValues().entrySet()) {
if ((getvertex(nextvertexOfLoop.getKey())).equals(subSE)) {
- vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
+ Vertex vFor1 = getvertex(nextvertexOfLoop.getValue().get(1));
int max;
if (subSE.getMaxTaintFixedNumber().get(label) > 0 && subSE.getTaintFixedNumber() > 0) {
max = subSE.getMaxTaintFixedNumber().get(label) / subSE.getTaintFixedNumber();
@@ -3516,11 +3458,11 @@ public class DirectedGraphTranslator extends JApplet {
vFor1.addLabel(label);
vFor1.getMaxTaintFixedNumber().put(label, vFor1.getTaintFixedNumber() * max);
}
- if (vFor1.getType() != vertex.TYPE_TRANSACTION) {
+ if (vFor1.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subSE)) {
NonTransV.get(subSE).add(vFor1);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(vFor1);
NonTransV.put(subSE, lv);
}
@@ -3528,7 +3470,7 @@ public class DirectedGraphTranslator extends JApplet {
}
}
}
- } else if (subSE.getType() == vertex.TYPE_TRANSACTION) {
+ } else if (subSE.getType() == Vertex.TYPE_TRANSACTION) {
if (subSE.getLabel().contains(label)) {
if (subSE.getMaxTaintFixedNumber().containsKey(label)) {
if (subSE.getMaxTaintFixedNumber().get(label) != subV.getMaxTaintFixedNumber().get(label)) {
@@ -3539,7 +3481,7 @@ public class DirectedGraphTranslator extends JApplet {
subSE.addLabel(label);
subSE.getMaxTaintFixedNumber().put(label, subSE.getTaintFixedNumber() * subV.getMaxTaintFixedNumber().get(label));
}
- } else if (subSE.getType() == vertex.TYPE_FOR_EVER_LOOP) {
+ } else if (subSE.getType() == Vertex.TYPE_FOR_EVER_LOOP) {
if (subSE.getLabel().contains(label)) {
if (subSE.getMaxTaintFixedNumber().containsKey(label)) {
if (subSE.getMaxTaintFixedNumber().get(label) != subSE.getTaintFixedNumber()) {
@@ -3553,7 +3495,7 @@ public class DirectedGraphTranslator extends JApplet {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subSE);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subSE);
NonTransV.put(subV, lv);
}
@@ -3571,14 +3513,14 @@ public class DirectedGraphTranslator extends JApplet {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subSE);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subSE);
NonTransV.put(subV, lv);
}
}
}
}
- } else if (subV.getType() == vertex.TYPE_START || subV.getType() == vertex.TYPE_CTRL) {
+ } else if (subV.getType() == Vertex.TYPE_START || subV.getType() == Vertex.TYPE_CTRL) {
if (subV.getLabel().contains(label)) {
if (subV.getMaxTaintFixedNumber().containsKey(label)) {
if (subV.getMaxTaintFixedNumber().get(label) != i) {
@@ -3591,7 +3533,7 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- for (vertex subSE : Graphs.successorListOf(g, subV)) {
+ for (Vertex subSE : Graphs.successorListOf(g, subV)) {
if (!subSE.equals(v1)) {
if (subSE.getLabel().contains(label)) {
if (subSE.getMaxTaintFixedNumber().containsKey(label)) {
@@ -3603,18 +3545,18 @@ public class DirectedGraphTranslator extends JApplet {
subSE.addLabel(label);
subSE.getMaxTaintFixedNumber().put(label, subSE.getTaintFixedNumber() * subV.getMaxTaintFixedNumber().get(label));
}
- if (subSE.getType() != vertex.TYPE_TRANSACTION) {
+ if (subSE.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subSE);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subSE);
NonTransV.put(subV, lv);
}
}
}
}
- } else if (subV.getType() == vertex.TYPE_SEQ) {
+ } else if (subV.getType() == Vertex.TYPE_SEQ) {
/*
* if (subV.getLabel().contains(label)) { if
* (subV.getMaxTaintFixedNumber().containsKey(label)) { if
@@ -3629,8 +3571,8 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- List<vertex> subSeq = new ArrayList<vertex>();
- for (vertex subSEQ : Graphs.successorListOf(g, subV)) {
+ List<Vertex> subSeq = new ArrayList<Vertex>();
+ for (Vertex subSEQ : Graphs.successorListOf(g, subV)) {
if (!subSEQ.equals(v1)) {
if (subSEQ.getLabel().contains(label)) {
if (subSEQ.getMaxTaintFixedNumber().containsKey(label)) {
@@ -3642,11 +3584,11 @@ public class DirectedGraphTranslator extends JApplet {
subSEQ.addLabel(label);
subSEQ.getMaxTaintFixedNumber().put(label, subSEQ.getTaintFixedNumber() * subV.getMaxTaintFixedNumber().get(label));
}
- if (subSEQ.getType() != vertex.TYPE_TRANSACTION) {
+ if (subSEQ.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(subSEQ);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(subSEQ);
NonTransV.put(subV, lv);
}
@@ -3654,8 +3596,8 @@ public class DirectedGraphTranslator extends JApplet {
}
subSeq.add(subSEQ);
}
- allSeqValues.put(subV, subSeq);
- } else if (subV.getType() == vertex.TYPE_UNORDER_SEQ) {
+ dependencyGraphRelations.getAllSeqValues().put(subV, subSeq);
+ } else if (subV.getType() == Vertex.TYPE_UNORDER_SEQ) {
/*
* if (subV.getLabel().contains(label)) { if
* (subV.getMaxTaintFixedNumber().containsKey(label)) { if
@@ -3670,9 +3612,9 @@ public class DirectedGraphTranslator extends JApplet {
subV.addLabel(label);
subV.getMaxTaintFixedNumber().put(label, i * subV.getTaintFixedNumber());
}
- List<vertex> subSeq = new ArrayList<vertex>();
- List<vertex> preSeq = Graphs.predecessorListOf(g, subV);
- for (vertex sub_UN_SEQ : Graphs.successorListOf(g, subV)) {
+ List<Vertex> subSeq = new ArrayList<Vertex>();
+ List<Vertex> preSeq = Graphs.predecessorListOf(g, subV);
+ for (Vertex sub_UN_SEQ : Graphs.successorListOf(g, subV)) {
if (preSeq.contains(sub_UN_SEQ)) {
continue;
}
@@ -3688,11 +3630,11 @@ public class DirectedGraphTranslator extends JApplet {
sub_UN_SEQ.addLabel(label);
sub_UN_SEQ.getMaxTaintFixedNumber().put(label, sub_UN_SEQ.getTaintFixedNumber() * subV.getMaxTaintFixedNumber().get(label));
}
- if (sub_UN_SEQ.getType() != vertex.TYPE_TRANSACTION) {
+ if (sub_UN_SEQ.getType() != Vertex.TYPE_TRANSACTION) {
if (NonTransV.containsKey(subV)) {
NonTransV.get(subV).add(sub_UN_SEQ);
} else {
- List<vertex> lv = new ArrayList<vertex>();
+ List<Vertex> lv = new ArrayList<Vertex>();
lv.add(sub_UN_SEQ);
NonTransV.put(subV, lv);
}
@@ -3700,13 +3642,13 @@ public class DirectedGraphTranslator extends JApplet {
}
subSeq.add(sub_UN_SEQ);
}
- allRandomSeqValues.put(subV, subSeq);
+ dependencyGraphRelations.getAllRandomSeqValues().put(subV, subSeq);
}
return NonTransV;
}
- protected vertex getvertex(String task12) {
- for (vertex v : g.vertexSet()) {
+ public Vertex getvertex(String task12) {
+ for (Vertex v : g.vertexSet()) {
if (v.getName().equals(task12)) {
return v;
}
@@ -3714,8 +3656,8 @@ public class DirectedGraphTranslator extends JApplet {
return null;
}
- protected vertex getvertexFromID(int id) {
- for (vertex v : g.vertexSet()) {
+ protected Vertex getvertexFromID(int id) {
+ for (Vertex v : g.vertexSet()) {
if (v.getId() == (id)) {
return v;
}
@@ -3723,7 +3665,7 @@ public class DirectedGraphTranslator extends JApplet {
return null;
}
- private void addTaint(vertex currentVertex) {
+ private void addTaint(Vertex currentVertex) {
String label = generateLabel();
boolean generatenewLabel = false;
while (!generatenewLabel) {
@@ -3914,19 +3856,19 @@ public class DirectedGraphTranslator extends JApplet {
HashMap<String, ArrayList<SimulationTransaction>> relatedTasks = new HashMap<String, ArrayList<SimulationTransaction>>();
relatedsimTraces = new Vector<SimulationTransaction>();
delayDueTosimTraces = new Vector<SimulationTransaction>();
- runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
+ dependencyGraphRelations.setRunnableTimePerDevice(new HashMap<String, ArrayList<ArrayList<Integer>>>());
// AllDirectedPaths<String, DefaultEdge> allPaths = new AllDirectedPaths<String,
// DefaultEdge>(g);
// List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(task12,
// task22, false, g.vertexSet().size());
// int size = path.size();
- GraphPath<vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(task22));
+ GraphPath<Vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(task22));
if (path2 != null && path2.getLength() > 0) {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
- GraphPath<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(ChannelName));
- GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
+ GraphPath<Vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(ChannelName));
+ GraphPath<Vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
}
@@ -3935,8 +3877,8 @@ public class DirectedGraphTranslator extends JApplet {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
- GraphPath<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(ChannelName));
- GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
+ GraphPath<Vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(ChannelName));
+ GraphPath<Vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
if ((pathTochannel != null && pathTochannel.getLength() > 0) || (pathFromChannel != null && pathFromChannel.getLength() > 0)) {
devicesToBeConsidered.addAll(busChList);
}
@@ -3966,7 +3908,7 @@ public class DirectedGraphTranslator extends JApplet {
st.length = String.valueOf(maxTime - minTime);
}
String taskname = "";
- for (vertex tasknameCheck : g.vertexSet()) {
+ for (Vertex tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.toString().split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
@@ -3982,8 +3924,8 @@ public class DirectedGraphTranslator extends JApplet {
// there is a path between task 1 and task 2
if (path2 != null && path2.getLength() > 0) {
if (!taskname.equals(null) && !taskname.equals("")) {
- GraphPath<vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
+ GraphPath<Vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, getvertex(task12), getvertex(taskname));
+ GraphPath<Vertex, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
getvertex(task22));
if (taskname.equals(task12) || taskname.equals(task22) || (pathToOrigin != null && pathToOrigin.getLength() > 0
&& pathToDestination != null && pathToDestination.getLength() > 0)) {
@@ -3993,14 +3935,14 @@ public class DirectedGraphTranslator extends JApplet {
timeValues.add(1, startTime);
if (!(st.runnableTime).equals(st.startTime)) {
String dName = st.deviceName + "_" + st.coreNumber;
- if (runnableTimePerDevice.containsKey(dName)) {
- if (!runnableTimePerDevice.get(dName).contains(timeValues)) {
- runnableTimePerDevice.get(dName).add(timeValues);
+ if (dependencyGraphRelations.getRunnableTimePerDevice().containsKey(dName)) {
+ if (!dependencyGraphRelations.getRunnableTimePerDevice().get(dName).contains(timeValues)) {
+ dependencyGraphRelations.getRunnableTimePerDevice().get(dName).add(timeValues);
}
} else {
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
- runnableTimePerDevice.put(dName, timeValuesList);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
@@ -4009,12 +3951,12 @@ public class DirectedGraphTranslator extends JApplet {
delayDueTosimTraces.add(st);
}
}
- timeDelayedPerRowMinMax.put(row, runnableTimePerDevice);
+ timeDelayedPerRowMinMax.put(row, dependencyGraphRelations.getRunnableTimePerDevice());
} else {
if (!taskname.equals(null) && !taskname.equals("")) {
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, getvertex(task12),
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, getvertex(task12),
getvertex(taskname));
- GraphPath<vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
+ GraphPath<Vertex, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, getvertex(taskname),
getvertex(task22));
if (pathExistsTestwithTask1 != null && pathExistsTestwithTask1.getLength() > 0
|| pathExistsTestwithTask2 != null && pathExistsTestwithTask2.getLength() > 0) {
@@ -4213,14 +4155,6 @@ public class DirectedGraphTranslator extends JApplet {
importer.importGraph(importedGraph, ps);
}
- public List<TMLComponentDesignPanel> getCpanels() {
- return cpanels;
- }
-
- public void setCpanels(List<TMLComponentDesignPanel> cpanels) {
- this.cpanels = cpanels;
- }
-
public HashMap<String, String> getNameIDTaskList() {
return nameIDTaskList;
}
@@ -4230,7 +4164,7 @@ public class DirectedGraphTranslator extends JApplet {
}
public static void setScrollPane(JScrollPane scrollPane) {
- DirectedGraphTranslator.scrollPane = scrollPane;
+ DependencyGraphTranslator.scrollPane = scrollPane;
}
public String checkPath(String task12ID, String task22ID) {
@@ -4244,9 +4178,9 @@ public class DirectedGraphTranslator extends JApplet {
idTask2 = task2[task2index - 1];
String task12 = nameIDTaskList.get(idTask1);
String task22 = nameIDTaskList.get(idTask2);
- vertex v1 = getvertex(task12);
- vertex v2 = getvertex(task22);
- GraphPath<vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, v2);
+ Vertex v1 = getvertex(task12);
+ Vertex v2 = getvertex(task22);
+ GraphPath<Vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, v2);
if (pathToOrigin != null && pathToOrigin.getLength() > 0) {
isPath = true;
}
@@ -4259,21 +4193,21 @@ public class DirectedGraphTranslator extends JApplet {
}
public Vector<String> getreadChannelNodes() {
- return readChannelTransactions;
+ return dependencyGraphRelations.getReadChannelTransactions();
}
public Vector<String> getwriteChannelNodes() {
- return writeChannelTransactions;
+ return dependencyGraphRelations.getWriteChannelTransactions();
}
public String addRule(String node1, String node2, Vector<String> writeChannelTransactions, String ruleDirection) {
- vertex v1 = getvertex(node1);
- vertex v2 = getvertex(node2);
- vertex v1Channel = null, v2Channel = null;
+ Vertex v1 = getvertex(node1);
+ Vertex v2 = getvertex(node2);
+ Vertex v1Channel = null, v2Channel = null;
String message = "";
if (v2Channel == null && Graphs.vertexHasSuccessors(g, v2)) {
- for (vertex n : Graphs.successorListOf(g, v2)) {
- if (n.getType() == vertex.TYPE_CHANNEL) {
+ for (Vertex n : Graphs.successorListOf(g, v2)) {
+ if (n.getType() == Vertex.getTypeChannel()) {
v2Channel = n;
break;
}
@@ -4281,10 +4215,10 @@ public class DirectedGraphTranslator extends JApplet {
}
Boolean hasWriteVertex = false;
if (Graphs.vertexHasPredecessors(g, v1)) {
- for (vertex n : Graphs.predecessorListOf(g, v1)) {
- if (n.getType() == vertex.TYPE_CHANNEL) {
+ for (Vertex n : Graphs.predecessorListOf(g, v1)) {
+ if (n.getType() == Vertex.getTypeChannel()) {
if (Graphs.vertexHasPredecessors(g, n)) {
- for (vertex writenode : Graphs.predecessorListOf(g, n)) {
+ for (Vertex writenode : Graphs.predecessorListOf(g, n)) {
if (writeChannelTransactions.contains(writenode.getName())) {
hasWriteVertex = true;
break;
@@ -4302,21 +4236,21 @@ public class DirectedGraphTranslator extends JApplet {
}
if (v1Channel != null && v2Channel != null) {
if (ruleDirection.equals("After")) {
- if (ruleAddedEdges.containsKey(v2Channel)) {
- ruleAddedEdges.get(v2Channel).add(v1Channel);
+ if (dependencyGraphRelations.getRuleAddedEdges().containsKey(v2Channel)) {
+ dependencyGraphRelations.getRuleAddedEdges().get(v2Channel).add(v1Channel);
message = "Rule between " + v1Channel + " and " + v2Channel + " was added";
} else {
- List<vertex> sendVertex = new ArrayList<vertex>();
+ List<Vertex> sendVertex = new ArrayList<Vertex>();
sendVertex.add(v1Channel);
- ruleAddedEdges.put(v2Channel, sendVertex);
+ dependencyGraphRelations.getRuleAddedEdges().put(v2Channel, sendVertex);
message = "Rule between " + v1Channel + " and " + v2Channel + " was added";
}
- if (ruleAddedEdgesChannels.containsKey(v2)) {
- ruleAddedEdgesChannels.get(v2).add(v1);
+ if (dependencyGraphRelations.getRuleAddedEdgesChannels().containsKey(v2)) {
+ dependencyGraphRelations.getRuleAddedEdgesChannels().get(v2).add(v1);
} else {
- List<vertex> sendVertex = new ArrayList<vertex>();
+ List<Vertex> sendVertex = new ArrayList<Vertex>();
sendVertex.add(v1);
- ruleAddedEdgesChannels.put(v2, sendVertex);
+ dependencyGraphRelations.getRuleAddedEdgesChannels().put(v2, sendVertex);
}
}
}
@@ -4327,35 +4261,40 @@ public class DirectedGraphTranslator extends JApplet {
}
public Boolean edgeExists(int vID1, int vID2) {
- vertex v1 = getvertexFromID(vID1);
- vertex v2 = getvertexFromID(vID2);
+ Vertex v1 = getvertexFromID(vID1);
+ Vertex v2 = getvertexFromID(vID2);
if (g.containsEdge(v1, v2)) {
return true;
}
return false;
}
- public HashMap<vertex, List<vertex>> getRuleAddedEdges() {
- return ruleAddedEdges;
- }
-
- public void setRuleAddedEdges(HashMap<vertex, List<vertex>> ruleAddedEdges) {
- this.ruleAddedEdges = ruleAddedEdges;
- }
-
- public void setRuleAddedEdgesChannels(HashMap<vertex, List<vertex>> ruleAddedEdgesChannels) {
- this.ruleAddedEdgesChannels = ruleAddedEdgesChannels;
- }
-
- public HashMap<vertex, List<vertex>> getRuleAddedEdgesChannels() {
- return ruleAddedEdgesChannels;
+ public Vector<SimulationTransaction> parseFile(File file2) {
+ SAXParserFactory saxParserFactory = SAXParserFactory.newInstance();
+ SAXParser saxParser = null;
+ try {
+ saxParser = saxParserFactory.newSAXParser();
+ } catch (ParserConfigurationException e) {
+ e.getMessage();
+ } catch (SAXException e) {
+ e.getMessage();
+ }
+ SimulationTransactionParser handler = new SimulationTransactionParser();
+ try {
+ saxParser.parse(file2, handler);
+ } catch (SAXException e) {
+ e.getMessage();
+ } catch (IOException e) {
+ e.getMessage();
+ }
+ return handler.getStList();
}
- public Graph<vertex, DefaultEdge> getG() {
+ public Graph<Vertex, DefaultEdge> getG() {
return g;
}
- public void setG(Graph<vertex, DefaultEdge> g) {
+ public void setG(Graph<Vertex, DefaultEdge> g) {
this.g = g;
}
@@ -4386,4 +4325,25 @@ public class DirectedGraphTranslator extends JApplet {
public void setOffPathDelay(List<SimulationTransaction> offPathDelay) {
this.offPathDelay = offPathDelay;
}
+
+ @Override
+ protected Void doInBackground() throws Exception {
+ return null;
+ }
+
+ public int getNodeNbProgressBar() {
+ return nodeNbProgressBar;
+ }
+
+ public List<String> getErrors() {
+ return errors;
+ }
+
+ public void setErrors(List<String> errors) {
+ this.errors = errors;
+ }
+
+ public DependencyGraphRelations getDependencyGraphRelations() {
+ return dependencyGraphRelations;
+ }
}
\ No newline at end of file
diff --git a/src/main/java/simulationtraceanalysis/PlanArrays.java b/src/main/java/simulationtraceanalysis/PlanArrays.java
new file mode 100644
index 0000000000000000000000000000000000000000..8601a07ed2108d922c04826c9ba5a0089a7494c6
--- /dev/null
+++ b/src/main/java/simulationtraceanalysis/PlanArrays.java
@@ -0,0 +1,312 @@
+package simulationtraceanalysis;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Vector;
+import ui.interactivesimulation.SimulationTransaction;
+
+public class PlanArrays {
+ private List<String> onPathBehavior = new ArrayList<String>();
+ private List<String> offPathBehavior = new ArrayList<String>();
+ private List<String> offPathBehaviorCausingDelay = new ArrayList<String>();
+ private static final String ZERO = "0";
+ private static final String DEVICE_NAME = "Device Name";
+ private String[] columnNames;
+ private Object[][] dataDetailedByTask;
+
+ public void fillArrays(DependencyGraphTranslator dgraph, int row, boolean firstTable, Boolean taint) {
+ int maxTime = -1;
+ int minTime = Integer.MAX_VALUE;
+ int tmpEnd, tmpStart, length;
+ Vector<String> deviceNames1 = new Vector<String>();
+ if (firstTable) {
+ for (SimulationTransaction st : dgraph.getRowDetailsTaks(row)) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ int timeInterval = 0;
+ if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
+ timeInterval = (maxTime - minTime);
+ }
+ columnNames = new String[timeInterval + 1];
+ columnNames[0] = DEVICE_NAME;
+ for (int i = 0; i < timeInterval; i++) {
+ columnNames[i + 1] = Integer.toString(minTime + i);
+ }
+ dataDetailedByTask = new Object[deviceNames1.size()][timeInterval + 1];
+ for (SimulationTransaction st : dgraph.getRowDetailsTaks(row)) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ for (String dName : deviceNames1) {
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (deviceNameandcore.equals(dName)) {
+ length = Integer.parseInt(st.length);
+ for (int i = 0; i < length; i++) {
+ int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
+ dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
+ ;
+ onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOnPath().contains(st)) {
+ dgraph.getOnPath().add(st);
+ }
+ }
+ }
+ }
+ }
+ HashMap<String, ArrayList<ArrayList<Integer>>> delayTime = dgraph.getRowDelayDetailsByHW(row);
+ for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
+ int startTime = Integer.valueOf(st.startTime);
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ for (String dName : deviceNames1) {
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (deviceNameandcore.equals(dName)) {
+ length = Integer.parseInt(st.length);
+ for (int i = 0; i < length; i++) {
+ int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
+ dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
+ ;
+ boolean causeDelay = false;
+ if (delayTime.containsKey(deviceNameandcore)) {
+ for (Entry<String, ArrayList<ArrayList<Integer>>> entry : delayTime.entrySet()) {
+ if (entry.getKey().equals(deviceNameandcore)) {
+ ArrayList<ArrayList<Integer>> timeList = entry.getValue();
+ for (int j = 0; j < timeList.size(); j++) {
+ if (startTime >= timeList.get(j).get(0) && startTime <= timeList.get(j).get(1)) {
+ causeDelay = true;
+ }
+ }
+ }
+ }
+ }
+ if (causeDelay) {
+ offPathBehaviorCausingDelay.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOffPathDelay().contains(st)) {
+ dgraph.getOffPathDelay().add(st);
+ }
+ } else {
+ offPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOffPath().contains(st)) {
+ dgraph.getOffPath().add(st);
+ }
+ }
+ }
+ }
+ }
+ }
+ for (String dName : deviceNames1) {
+ dataDetailedByTask[deviceNames1.indexOf(dName)][0] = dName;
+ ;
+ }
+ } else {
+ Vector<SimulationTransaction> minMaxTasksByRow;
+ List<SimulationTransaction> minMaxHWByRowDetails;
+ HashMap<String, ArrayList<ArrayList<Integer>>> delayTime;
+ // min/max table row selected
+ if (taint) {
+ delayTime = dgraph.getTimeDelayedPerRowMinMaxTainted(row);
+ minMaxTasksByRow = dgraph.getMinMaxTasksByRowTainted(row);
+ minMaxHWByRowDetails = dgraph.getTaskMinMaxHWByRowDetailsTainted(row);
+ for (SimulationTransaction st : minMaxTasksByRow) {
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ for (SimulationTransaction st : minMaxHWByRowDetails) {
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ } else {
+ delayTime = dgraph.getRowDelayDetailsByHWMinMax(row);
+ minMaxTasksByRow = dgraph.getMinMaxTasksByRow(row);
+ minMaxHWByRowDetails = dgraph.getTaskMinMaxHWByRowDetails(row);
+ for (SimulationTransaction st : minMaxTasksByRow) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ for (SimulationTransaction st : minMaxHWByRowDetails) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
+ }
+ int timeInterval = 0;
+ if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
+ timeInterval = (maxTime - minTime);
+ }
+ columnNames = new String[timeInterval + 1];
+ columnNames[0] = DEVICE_NAME;
+ for (int i = 0; i < timeInterval; i++) {
+ columnNames[i + 1] = Integer.toString(minTime + i);
+ }
+ dataDetailedByTask = new Object[deviceNames1.size()][timeInterval + 1];
+ for (SimulationTransaction st : minMaxTasksByRow) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ for (String dName : deviceNames1) {
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (deviceNameandcore.equals(dName)) {
+ length = Integer.parseInt(st.length);
+ for (int i = 0; i < length; i++) {
+ int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
+ dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
+ ;
+ onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOnPath().contains(st)) {
+ dgraph.getOnPath().add(st);
+ }
+ }
+ }
+ }
+ }
+ for (SimulationTransaction st : minMaxHWByRowDetails) {
+ int startTime = Integer.valueOf(st.startTime);
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ for (String dName : deviceNames1) {
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (deviceNameandcore.equals(dName)) {
+ length = Integer.parseInt(st.length);
+ for (int i = 0; i < length; i++) {
+ int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
+ dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
+ ;
+ boolean causeDelay = false;
+ if (delayTime.containsKey(deviceNameandcore)) {
+ for (Entry<String, ArrayList<ArrayList<Integer>>> entry : delayTime.entrySet()) {
+ if (entry.getKey().equals(deviceNameandcore)) {
+ ArrayList<ArrayList<Integer>> timeList = entry.getValue();
+ for (int j = 0; j < timeList.size(); j++) {
+ if (startTime >= timeList.get(j).get(0) && startTime <= timeList.get(j).get(1)) {
+ causeDelay = true;
+ }
+ }
+ }
+ }
+ }
+ if (causeDelay) {
+ offPathBehaviorCausingDelay.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOffPathDelay().contains(st)) {
+ dgraph.getOffPathDelay().add(st);
+ }
+ } else {
+ offPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOffPath().contains(st)) {
+ dgraph.getOffPath().add(st);
+ }
+ }
+ }
+ }
+ }
+ }
+ for (String dName : deviceNames1) {
+ dataDetailedByTask[deviceNames1.indexOf(dName)][0] = dName;
+ ;
+ }
+ }
+ return;
+ }
+
+ public Object[][] getDataDetailedByTask() {
+ return dataDetailedByTask;
+ }
+
+ public List<String> getOnPathBehavior() {
+ return onPathBehavior;
+ }
+
+ public List<String> getOffPathBehavior() {
+ return offPathBehavior;
+ }
+
+ public List<String> getOffPathBehaviorCausingDelay() {
+ return offPathBehaviorCausingDelay;
+ }
+
+ public String[] getColumnNames() {
+ return columnNames;
+ }
+}
diff --git a/src/main/java/ui/simulationtraceanalysis/vertex.java b/src/main/java/simulationtraceanalysis/Vertex.java
similarity index 93%
rename from src/main/java/ui/simulationtraceanalysis/vertex.java
rename to src/main/java/simulationtraceanalysis/Vertex.java
index 164e0f808ad13cbf671e335145c94bf31894be64..260e10841b44775b931eaa09b646799adfd8dced 100644
--- a/src/main/java/ui/simulationtraceanalysis/vertex.java
+++ b/src/main/java/simulationtraceanalysis/Vertex.java
@@ -1,11 +1,11 @@
-package ui.simulationtraceanalysis;
+package simulationtraceanalysis;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
-public class vertex {
- protected static final int TYPE_CHANNEL = 11;
+public class Vertex {
+ private static final int TYPE_CHANNEL = 11;
protected static final int TYPE_FOR_EVER_LOOP = 1;
protected static final int TYPE_STATIC_FOR_LOOP = 2;
protected static final int TYPE_FOR_LOOP = 3;
@@ -28,7 +28,7 @@ public class vertex {
private HashMap<String, Integer> taintConsideredNumber = new HashMap<String, Integer>();; // the number of times the taint should be considered
private HashMap<String, Integer> maxTaintFixedNumber = new HashMap<String, Integer>();
- public vertex(String name, int id) {
+ public Vertex(String name, int id) {
this.name = name;
this.id = id;
this.label = this.getLabel();
@@ -65,7 +65,7 @@ public class vertex {
}
public boolean equals(Object o) {
- return (o instanceof vertex) && (toString().equals(o.toString()));
+ return (o instanceof Vertex) && (toString().equals(o.toString()));
}
public List<String> getLabel() {
@@ -81,6 +81,10 @@ public class vertex {
this.getTaintConsideredNumber().put(l, 0);
}
+ public static int getTypeChannel() {
+ return TYPE_CHANNEL;
+ }
+
public String getLastLabel() {
for (int i = 0; i < this.getLabel().size(); i++) {
if (this.getMaxTaintFixedNumber().get(this.label.get(i)) == 0) {
diff --git a/src/main/java/ui/MainGUI.java b/src/main/java/ui/MainGUI.java
index 646ac40f7e18f9e57387580f3cd0d80c849ddb7b..80643aeb7fd16bde745a882b7a2f49ab133723e9 100644
--- a/src/main/java/ui/MainGUI.java
+++ b/src/main/java/ui/MainGUI.java
@@ -72,7 +72,6 @@ import ui.ebrdd.EBRDDPanel;
import ui.eln.ELNDiagramPanel;
import ui.file.*;
import ui.ftd.FaultTreeDiagramPanel;
-import ui.interactivesimulation.JFrameCompareSimulationTraces;
import ui.interactivesimulation.JFrameInteractiveSimulation;
import ui.interactivesimulation.SimulationTransaction;
import ui.iod.InteractionOverviewDiagramPanel;
@@ -81,7 +80,8 @@ import ui.osad.TURTLEOSActivityDiagramPanel;
import ui.prosmd.ProactiveSMDPanel;
import ui.req.Requirement;
import ui.req.RequirementDiagramPanel;
-import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
+import ui.simulationtraceanalysis.JFrameCompareSimulationTraces;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
import ui.syscams.SysCAMSComponentTaskDiagramPanel;
import ui.syscams.SysCAMSCompositeComponent;
import ui.tmlad.TMLActivityDiagramPanel;
@@ -341,7 +341,7 @@ public class MainGUI implements ActionListener, WindowListener, KeyListener, Per
private JFrameCompareSimulationTraces cSimTrace;
- private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
@@ -9684,7 +9684,7 @@ public class MainGUI implements ActionListener, WindowListener, KeyListener, Per
public void compareLatencyForXML(SimulationTrace selectedST, boolean b) {
try {
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(1, this, selectedST, b, false, 0);
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(1, this, selectedST, b, false, 0);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
@@ -9696,7 +9696,7 @@ public class MainGUI implements ActionListener, WindowListener, KeyListener, Per
throws XPathExpressionException, ParserConfigurationException, SAXException, IOException {
try {
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(2, this, selectedST, b, compare, j);
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(2, this, selectedST, b, compare, j);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
diff --git a/src/main/java/ui/interactivesimulation/JPanelCompareXmlGraph.java b/src/main/java/ui/interactivesimulation/JPanelCompareXmlGraph.java
deleted file mode 100644
index 24bd5bda065ac4d793eba982f20258aa4b4533b6..0000000000000000000000000000000000000000
--- a/src/main/java/ui/interactivesimulation/JPanelCompareXmlGraph.java
+++ /dev/null
@@ -1,352 +0,0 @@
-/* Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
- *
- * ludovic.apvrille AT enst.fr
- *
- * This software is a computer program whose purpose is to allow the
- * edition of TURTLE analysis, design and deployment diagrams, to
- * allow the generation of RT-LOTOS or Java code from this diagram,
- * and at last to allow the analysis of formal validation traces
- * obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
- * from INRIA Rhone-Alpes.
- *
- * This software is governed by the CeCILL license under French law and
- * abiding by the rules of distribution of free software. You can use,
- * modify and/ or redistribute the software under the terms of the CeCILL
- * license as circulated by CEA, CNRS and INRIA at the following URL
- * "http://www.cecill.info".
- *
- * As a counterpart to the access to the source code and rights to copy,
- * modify and redistribute granted by the license, users are provided only
- * with a limited warranty and the software's author, the holder of the
- * economic rights, and the successive licensors have only limited
- * liability.
- *
- * In this respect, the user's attention is drawn to the risks associated
- * with loading, using, modifying and/or developing or reproducing the
- * software by the user in light of its specific status of free software,
- * that may mean that it is complicated to manipulate, and that also
- * therefore means that it is reserved for developers and experienced
- * professionals having in-depth computer knowledge. Users are therefore
- * encouraged to load and test the software's suitability as regards their
- * requirements in conditions enabling the security of their systems and/or
- * data to be ensured and, more generally, to use and operate it in the
- * same conditions as regards security.
- *
- * The fact that you are presently reading this means that you have had
- * knowledge of the CeCILL license and that you accept its terms.
- */
-package ui.interactivesimulation;
-
-import java.awt.GridLayout;
-import java.util.Vector;
-
-import javax.swing.JPanel;
-import javax.swing.JScrollPane;
-import javax.swing.JTable;
-import javax.swing.event.TableModelEvent;
-import javax.swing.event.TableModelListener;
-import javax.swing.table.TableColumn;
-import javax.swing.table.TableColumnModel;
-
-/**
- * Class JPanelCompareXmlGraph : arranges the two simulation traces in a table
- * and load the table to the compare pop up . It includes functionality to show
- * the difference in the simulation traces and to load the drop down for latency
- * compare later
- *
- * Creation: 19/07/2019
- *
- * @author Maysam ZOOR
- */
-
-public class JPanelCompareXmlGraph extends JPanel implements TableModelListener {
-
- public static JTable table, tableUpdated;
-
- private String[] columnNames;
- private Object[][] data;
- static JScrollPane scrollPane = new JScrollPane();
-
- public JPanelCompareXmlGraph(Vector<SimulationTransaction> transFile1, Vector<SimulationTransaction> transFile2) {
-
- super(new GridLayout(1, 0));
-
- if (transFile1.isEmpty() || transFile2.isEmpty()) {
- return;
- }
-
- int maxTime = -1;
-
- Vector<String> deviceNames1 = new Vector<String>();
- Vector<String> deviceNames2 = new Vector<String>();
-
- for (SimulationTransaction st : transFile1) {
- if (Integer.parseInt(st.endTime) > maxTime) {
- maxTime = Integer.parseInt(st.endTime);
- }
- if (!deviceNames1.contains(st.deviceName)) {
- deviceNames1.add(st.deviceName);
-
- }
-
- }
-
- for (SimulationTransaction st : transFile2) {
- if (Integer.parseInt(st.endTime) > maxTime) {
- maxTime = Integer.parseInt(st.endTime);
- }
- if (!deviceNames2.contains(st.deviceName)) {
- deviceNames2.add(st.deviceName);
-
- }
- }
-
- Vector<String> allDevices = new Vector<String>();
-
- for (String device : deviceNames1) {
- if (!deviceNames2.contains(device)) {
- allDevices.add(device.concat("1"));
- } else {
- allDevices.add(device.concat("1"));
- allDevices.add(device.concat("2"));
-
- }
- }
- for (String device : deviceNames2) {
- if (!deviceNames1.contains(device)) {
- allDevices.add(device.concat("2"));
- }
-
- }
-
- columnNames = new String[maxTime + 2];
- data = new Object[deviceNames1.size() + deviceNames2.size()][maxTime + 2];
-
- columnNames[0] = "Device Name";
- columnNames[1] = "Trace Name";
-
- for (SimulationTransaction st : transFile1) {
-
- for (String dName : deviceNames1) {
-
- if (st.deviceName.equals(dName)) {
-
- for (int i = 0; i < Integer.parseInt(st.length); i++) {
-
- String[] sentences2 = null;
-
- sentences2 = st.command.split("__");
-
- if (sentences2[0].contains(",") && sentences2.length > 1)
-
- {
-
- String[] writeCommand = sentences2[0].split(",");
-
- st.command = writeCommand[0] + " " + sentences2[1];
-
- } else if (sentences2[0].contains(" ") && sentences2.length > 1)
-
- {
-
- String[] writeCommand = sentences2[0].split(" ");
-
- st.command = writeCommand[0] + " " + sentences2[1];
-
- }
-
- data[allDevices.indexOf(dName.concat("1"))][Integer.parseInt(st.startTime) + i
- + 2] = st.command;
- ;
- data[allDevices.indexOf(dName.concat("1"))][1] = "transFile 1";
- }
- }
-
- }
-
- }
-
- for (SimulationTransaction st : transFile2) {
-
- for (String dName : deviceNames2) {
-
- if (st.deviceName.equals(dName)) {
-
- for (int i = 0; i < Integer.parseInt(st.length); i++) {
-
- String[] sentences2 = null;
-
- sentences2 = st.command.split("__");
-
- if (sentences2[0].contains(",") && sentences2.length > 1)
-
- {
-
- String[] writeCommand = sentences2[0].split(",");
-
- st.command = writeCommand[0] + " " + sentences2[1];
-
- } else if (sentences2[0].contains(" ") && sentences2.length > 1)
-
- {
-
- String[] writeCommand = sentences2[0].split(" ");
-
- st.command = writeCommand[0] + " " + sentences2[1];
-
- }
-
- data[allDevices.indexOf(dName.concat("2"))][Integer.parseInt(st.startTime) + i
- + 2] = st.command;
- data[allDevices.indexOf(dName.concat("2"))][1] = "transFile 2";
- }
- }
-
- }
-
- }
-
- for (String dName : allDevices) {
- data[allDevices.indexOf(dName)][0] = dName.substring(0, dName.length() - 1);
- ;
- }
-
- for (int i = 2; i < maxTime + 2; i++) {
-
- columnNames[i] = Integer.toString(i - 2);
-
- }
-
- table = new JTable(data, columnNames);
-
- table.setFillsViewportHeight(true);
-
- table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
- TableRenderer tr = new TableRenderer();
- int ncols = table.getColumnCount();
-
- table.getModel().addTableModelListener(this);
-
- TableColumnModel tcm = table.getColumnModel();
-
- for (int c = 0; c < ncols; c++) {
- TableColumn tc = tcm.getColumn(c);
- tc.setCellRenderer(tr);
- }
-
- }
-
- public void showDifference() {
-
- int numRows = table.getRowCount();
- int numCols = table.getColumnCount();
-
- for (int j = 2; j < numCols; j++) {
-
- for (int i = 0; i < numRows; i++) {
- for (int k = 0; k < numRows; k++) {
-
- if (table.getValueAt(i, 0).equals(table.getValueAt(k, 0)))
-
- {
-
- if (i != k && table.getValueAt(i, j) != null && table.getValueAt(k, j) != null
- && table.getValueAt(i, j).equals(table.getValueAt(k, j))) {
-
- table.setValueAt(null, k, j);
- table.setValueAt(null, i, j);
-
- }
- }
-
- }
-
- }
-
- }
-
- numRows = table.getRowCount();
- numCols = table.getColumnCount();
-
- table.repaint();
- table.revalidate();
- scrollPane.setViewportView(table);
-
- scrollPane.setVisible(true);
-
- scrollPane.revalidate();
- scrollPane.repaint();
-
- }
-
- public void drawTable() {
-
- scrollPane.setViewportView(table);
-
- scrollPane.setVisible(true);
- add(scrollPane);
-
- }
-
- public void updateTable() {
-
- scrollPane.setViewportView(table);
-
- scrollPane.setVisible(true);
-
- scrollPane.revalidate();
- scrollPane.repaint();
-
- }
-
- @Override
- public void tableChanged(TableModelEvent e) {
-
- }
-
- public Vector<Object> loadTransacationsDropDown(Object object) {
-
- Vector<Object> allTransacions = new Vector<Object>();
- ;
-
- int numRows = table.getRowCount();
- int numCols = table.getColumnCount();
-
- for (int i = 0; i < numRows; i++) {
- for (int j = 2; j < numCols; j++) {
-
- if (table.getValueAt(i, j) != null && !allTransacions.contains(table.getValueAt(i, j))
- && table.getValueAt(i, 0).equals(object)) {
- allTransacions.add(table.getValueAt(i, j));
- }
- }
-
- }
-
- return allTransacions;
- }
-
- public Vector<Object> loadDevicesDropDown() {
- Vector<Object> allDevices = new Vector<Object>();
- ;
-
- int numRows = table.getRowCount();
-
- for (int i = 0; i < numRows; i++) {
-
- if (table.getValueAt(i, 0) != null && !allDevices.contains(table.getValueAt(i, 0))) {
- allDevices.add(table.getValueAt(i, 0));
-
- }
-
- }
-
- return allDevices;
- }
-
- public JTable getTable() {
- return table;
-
- }
-
-}
diff --git a/src/main/java/ui/interactivesimulation/TableRenderer.java b/src/main/java/ui/interactivesimulation/TableRenderer.java
deleted file mode 100644
index 5fb197f325051053f313de57eea0a3b23d096908..0000000000000000000000000000000000000000
--- a/src/main/java/ui/interactivesimulation/TableRenderer.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package ui.interactivesimulation;
-
-import java.awt.Color;
-import java.awt.Component;
-import java.util.Random;
-import java.util.Vector;
-
-import javax.swing.JTable;
-import javax.swing.UIManager;
-import javax.swing.table.DefaultTableCellRenderer;
-
-class TableRenderer extends DefaultTableCellRenderer {
-
- private int row, col;
-
- private Vector<Object> allCommands = new Vector<Object>();
- private Vector<Color> allColors = new Vector<Color>();
-
- public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
- int row, int column) {
-
- this.row = row;
- this.col = column;
-
- // Allow superclass to return rendering component.
-
- return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
- }
-
- protected void setValue(Object v) {
-
- super.setValue(v);
-
- if (v == null) {
- setForeground(UIManager.getColor("Table.foreground"));
- setBackground(UIManager.getColor("Table.background"));
- return;
- } else if (!allCommands.contains(v)) {
- allCommands.add(v);
- boolean x = true;
- while (x) {
-
- Random randomGenerator = new Random();
- int red = randomGenerator.nextInt(256);
- int green = randomGenerator.nextInt(256);
- int blue = randomGenerator.nextInt(256);
-
- Color randomColour = new Color(red, green, blue);
-
- if (!allColors.contains(randomColour)) {
- allColors.add(randomColour);
- x = false;
-
- }
- }
-
- }
-
- if (allCommands.contains(v)) {
- setForeground(Color.yellow);
- setBackground(allColors.get(allCommands.indexOf(v)));
- } else {
- setForeground(UIManager.getColor("Table.foreground"));
- setBackground(UIManager.getColor("Table.background"));
- }
- }
-}
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameCompareLatencyDetail.java b/src/main/java/ui/simulationtraceanalysis/JFrameCompareLatencyDetail.java
index d69bee65f0f5bd66d1bff0be724e7968a1f63c1e..e970d28a58efb57ec1b8d18e1f69b428a74f8da5 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameCompareLatencyDetail.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameCompareLatencyDetail.java
@@ -10,9 +10,10 @@ import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.IOException;
-import java.util.HashMap;
import java.util.List;
import java.util.Vector;
import javax.swing.BorderFactory;
@@ -44,6 +45,7 @@ import common.ConfigurationTTool;
import myutil.GraphicLib;
import myutil.ScrolledJTextArea;
import myutil.TraceManager;
+import simulationtraceanalysis.DependencyGraphTranslator;
import tmltranslator.TMLMapping;
import ui.ColorManager;
import ui.MainGUI;
@@ -56,7 +58,7 @@ import ui.interactivesimulation.SimulationTransactionParser;
public class JFrameCompareLatencyDetail extends JFrame implements ActionListener {
private JButton buttonClose, buttonShowDGraph1, buttonShowDGraph2, buttonDetailedAnalysis, buttonCompareInDetails;
private LatencyDetailedAnalysisActions[] actions;
- private DirectedGraphTranslator dgraph1, dgraph2;
+ private DependencyGraphTranslator dgraph1, dgraph2;
private JPanel loadxml, commandTab, jp05, graphAnalysisResult, jp03, jp04, loadmodel, progressBarpanel;
private JTextArea jta;
private JScrollPane jsp;
@@ -89,7 +91,7 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
private JLabel pBarLabel;
private TMLMapping<TGComponent> map;
private List<TMLComponentDesignPanel> cpanels;
- private DirectedGraphTranslator dgraph;
+ private DependencyGraphTranslator dgraph;
private LatencyAnalysisParallelAlgorithms tc;
private JCheckBox taintFirstOp, considerRules;
private static final String START_TIME_COL_NAME = "Start Time ";
@@ -102,7 +104,7 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
public JFrameCompareLatencyDetail(latencyDetailedAnalysisMain latencyDetailedAnaly, MainGUI mgui, final Vector<String> checkedTransactionsFile1,
TMLMapping<TGComponent> map1, List<TMLComponentDesignPanel> cpanels1, final SimulationTrace selectedST1, boolean b,
LatencyAnalysisParallelAlgorithms tc1) throws InterruptedException {
- super("Latency Comparision");
+ super("Latency Comparison");
this.setVisible(b);
tc = tc1;
mainGUI = mgui;
@@ -358,7 +360,26 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
protected void generateDirectedGraph1(TMLMapping<TGComponent> map, List<TMLComponentDesignPanel> cpanels) {
try {
- dgraph = new DirectedGraphTranslator(jFrameLatencyDetailedAnalysis, this, map, cpanels, 1);
+ dgraph = new DependencyGraphTranslator(map);
+ dgraph.addPropertyChangeListener(new PropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent e) {
+ if (e.getPropertyName().equals("progress")) {
+ int progress = (Integer) e.getNewValue();
+ // Update the progress bar's value with the value of the progress property.
+ if (pbar.getValue() == pbar.getMaximum()) {
+ updateBar(0);
+ } else {
+ updateBar(progress);
+ }
+ pack();
+ revalidate();
+ repaint();
+ }
+ }
+ });
+ dgraph.DrawDirectedGraph();
+ pbar.setMaximum(dgraph.getNodeNbProgressBar());
+ pbar.setMinimum(0);
dgraph1 = dgraph;
jta.append("A directed graph with " + dgraph.getGraphsize() + " vertices and " + dgraph.getGraphEdgeSet()
+ " edges has been successfully generated.\n");
@@ -531,7 +552,7 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
}
}
- private void showgraphFrame(DirectedGraphTranslator dgraph) {
+ private void showgraphFrame(DependencyGraphTranslator dgraph) {
try {
dgraph.showGraph(dgraph);
// jta.append("Refer to the generatd dialog to view the graph.\n");
@@ -668,11 +689,11 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
return tableData;
}
- public DirectedGraphTranslator getDgraph2() {
+ public DependencyGraphTranslator getDgraph2() {
return dgraph2;
}
- public void setDgraph2(DirectedGraphTranslator dgraph2) {
+ public void setDgraph2(DependencyGraphTranslator dgraph2) {
this.dgraph2 = dgraph2;
}
@@ -688,11 +709,11 @@ public class JFrameCompareLatencyDetail extends JFrame implements ActionListener
this.pbar = pbar;
}
- public DirectedGraphTranslator getDgraph() {
+ public DependencyGraphTranslator getDgraph() {
return dgraph;
}
- public void setDgraph(DirectedGraphTranslator dgraph) {
+ public void setDgraph(DependencyGraphTranslator dgraph) {
this.dgraph = dgraph;
}
// public Thread getT() {
diff --git a/src/main/java/ui/interactivesimulation/JFrameCompareSimulationTraces.java b/src/main/java/ui/simulationtraceanalysis/JFrameCompareSimulationTraces.java
similarity index 100%
rename from src/main/java/ui/interactivesimulation/JFrameCompareSimulationTraces.java
rename to src/main/java/ui/simulationtraceanalysis/JFrameCompareSimulationTraces.java
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
index 058c266e9b0e1cdf2feb1a08aef0fb20160bf9ed..644b84f9d25b6e9024b5cf80dee516d7d0a5236f 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
@@ -38,6 +38,7 @@
package ui.simulationtraceanalysis;
import java.awt.BorderLayout;
+import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.GridBagConstraints;
@@ -48,6 +49,7 @@ import java.util.List;
import java.util.Map.Entry;
import java.util.Vector;
import javax.swing.JFrame;
+import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
@@ -57,6 +59,7 @@ import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
+import simulationtraceanalysis.DependencyGraphTranslator;
import ui.interactivesimulation.SimulationTransaction;
/**
@@ -85,9 +88,20 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
private static final String END_TIME = "End Time ";
private static final String TASKS_SAME_DEVICE = "Tasks on Same device";
private static final String DEVICE_NAME = "Device Name";
+ private static final String MANDATORY_TRANSACTIONS_ST1 = "Mandatory Transactions Trace 1 ";
+ private static final String MANDATORY_TRANSACTIONS_ST2 = "Mandatory Transactions Trace 2";
+ private static final String TASKS_ON_SAME_DEVICE = "Tasks on the Same Device ";
+ private static final String NON_MANDATORY_TRANSACTIONS_ST1 = "Non-Mandatory Transactions Trace 1";
+ private static final String NON_MANDATORY_TRANSACTIONS_ST2 = "Non-Mandatory Transactions Trace 2";
+ private static final String NON_MAND_NO_CONT_TRAN = "Non-Mandatory Transactions No-Contention";
+ private static final String ST1 = "Trace 1";
+ private static final String ST2 = "Trace 2";
+ private static final String NON_MAND_CONT_TRAN = "Non-Mandatory Transactions Causing Contention";
+ private static final String TABLE_LENGED = "Table Lenged: ";
+ private static final String MANDATORY_TRANSACTIONS = "Mandatory Transactions ";
- public JFrameLatencyComparedDetailedPopup(DirectedGraphTranslator dgraph1, DirectedGraphTranslator dgraph2, int row, int row2, boolean firstTable,
- LatencyAnalysisParallelAlgorithms tc2) throws InterruptedException {
+ public JFrameLatencyComparedDetailedPopup(DependencyGraphTranslator dgraph1, DependencyGraphTranslator dgraph2, int row, int row2,
+ boolean firstTable, LatencyAnalysisParallelAlgorithms tc2) throws InterruptedException {
super("Detailed Latency By Row");
tc = tc2;
GridBagLayout gridbagmain = new GridBagLayout();
@@ -108,7 +122,6 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
columnByTaskNames[2] = HARDWARE;
columnByTaskNames[3] = START_TIME;
columnByTaskNames[4] = END_TIME;
- JPanel jp04 = new JPanel(new BorderLayout());
tc.setDgraph1(dgraph1);
tc.setDgraph2(dgraph2);
tc.setRow(row);
@@ -151,10 +164,13 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
}
};
// taskNames = new JTable(dataDetailedByTask, columnByTaskNames);
+ JPanel jp02 = new JPanel(new BorderLayout());
+ jp02.setBorder(new javax.swing.border.TitledBorder(MANDATORY_TRANSACTIONS_ST1));
JTable taskNames = new JTable(model);
taskNames.setAutoCreateRowSorter(true);
scrollPane11 = new JScrollPane(taskNames, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scrollPane11.setVisible(true);
+ jp02.add(scrollPane11);
c02.gridheight = 1;
c02.weighty = 1.0;
c02.weightx = 1.0;
@@ -163,7 +179,7 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
c02.gridy = 0;
c02.fill = GridBagConstraints.BOTH;
// c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane11, c02);
+ framePanel.add(jp02, c02);
DefaultTableModel model12 = new DefaultTableModel(dataDetailedByTask2, columnByTaskNames) {
@Override
public boolean isCellEditable(int row, int column) {
@@ -194,8 +210,10 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
scrollPane12.setVisible(true);
c02.gridx = 1;
c02.gridy = 0;
- c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane12, c02);
+ JPanel jp03 = new JPanel(new BorderLayout());
+ jp03.setBorder(new javax.swing.border.TitledBorder(MANDATORY_TRANSACTIONS_ST2));
+ jp03.add(scrollPane12);
+ framePanel.add(jp03, c02);
columnByHWNames[0] = TASKS_SAME_DEVICE;
columnByHWNames[1] = TRANSACTION_DIAGRAM_NAME;
columnByHWNames[2] = HARDWARE;
@@ -244,8 +262,10 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
scrollPane13.setVisible(true);
c02.gridx = 0;
c02.gridy = 1;
- c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane13, c02);
+ JPanel jp04 = new JPanel(new BorderLayout());
+ jp04.setBorder(new javax.swing.border.TitledBorder(NON_MANDATORY_TRANSACTIONS_ST1));
+ jp04.add(scrollPane13);
+ framePanel.add(jp04, c02);
DefaultTableModel model3 = new DefaultTableModel(dataHWDelayByTask2, columnByHWNames) {
@Override
public boolean isCellEditable(int row, int column) {
@@ -276,23 +296,79 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
scrollPane14.setVisible(true);
c02.gridx = 1;
c02.gridy = 1;
- c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane14, c02);
+ JPanel jp05 = new JPanel(new BorderLayout());
+ jp05.setBorder(new javax.swing.border.TitledBorder(NON_MANDATORY_TRANSACTIONS_ST2));
+ jp05.add(scrollPane14);
+ framePanel.add(jp05, c02);
scrollPane15 = new JScrollPane(LatencyTable(dgraph1, row, firstTable), JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scrollPane15.setVisible(true);
- c02.gridwidth = 2;
c02.gridx = 0;
c02.gridy = 3;
+ c02.gridwidth = 2;
c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane15, c02);
+ JPanel jp06 = new JPanel(new BorderLayout());
+ jp06.setBorder(new javax.swing.border.TitledBorder(ST1));
+ jp06.add(scrollPane15);
+ framePanel.add(jp06, c02);
+ // framePanel.add(scrollPane15, c02);
scrollPane16 = new JScrollPane(LatencyTable(dgraph2, row2, firstTable), JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scrollPane16.setVisible(true);
c02.gridx = 0;
c02.gridy = 4;
- c02.fill = GridBagConstraints.BOTH;
- framePanel.add(scrollPane16, c02);
+ c02.gridwidth = 2;
+ JPanel jp07 = new JPanel(new BorderLayout());
+ jp07.setBorder(new javax.swing.border.TitledBorder(ST2));
+ jp07.add(scrollPane16);
+ framePanel.add(jp07, c02);
+ c02.gridx = 0;
+ c02.gridy = 5;
+ c02.gridwidth = 2;
+ // framePanel.add(scrollPane16, c02);
+ GridBagLayout gridbag01 = new GridBagLayout();
+ GridBagConstraints c01 = new GridBagConstraints();
+ c01.gridheight = 1;
+ c01.weighty = 1.0;
+ c01.weightx = 1.0;
+ c01.gridwidth = 1;
+ c02.gridwidth = 2;
+ c01.gridx = 0;
+ c01.gridy = 0;
+ JLabel pBarLabel0 = new JLabel(TABLE_LENGED);
+ JPanel lengedpanel = new JPanel(gridbag01);
+ lengedpanel.add(pBarLabel0, c01);
+ c01.gridx = 2;
+ c01.gridy = 0;
+ JLabel pBarLabel = new JLabel(MANDATORY_TRANSACTIONS, JLabel.RIGHT);
+ lengedpanel.add(pBarLabel, c01);
+ c01.gridx = 1;
+ c01.gridy = 0;
+ JLabel pBarLabel2 = new JLabel(" ", JLabel.LEFT);
+ pBarLabel2.setOpaque(true);
+ pBarLabel2.setBackground(Color.GREEN);
+ lengedpanel.add(pBarLabel2, c01);
+ c01.gridx = 4;
+ c01.gridy = 0;
+ JLabel pBarLabel3 = new JLabel(NON_MAND_CONT_TRAN, JLabel.RIGHT);
+ lengedpanel.add(pBarLabel3, c01);
+ c01.gridx = 3;
+ c01.gridy = 0;
+ JLabel pBarLabel4 = new JLabel(" ", JLabel.LEFT);
+ pBarLabel4.setOpaque(true);
+ pBarLabel4.setBackground(Color.RED);
+ lengedpanel.add(pBarLabel4, c01);
+ c01.gridx = 6;
+ c01.gridy = 0;
+ JLabel pBarLabel5 = new JLabel(NON_MAND_NO_CONT_TRAN, JLabel.RIGHT);
+ lengedpanel.add(pBarLabel5, c01);
+ c01.gridx = 5;
+ c01.gridy = 0;
+ JLabel pBarLabel6 = new JLabel(" ", JLabel.LEFT);
+ pBarLabel6.setOpaque(true);
+ pBarLabel6.setBackground(Color.ORANGE);
+ lengedpanel.add(pBarLabel6, c01);
+ this.add(lengedpanel, c02);
this.pack();
this.setVisible(true);
}
@@ -301,7 +377,7 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
public void tableChanged(TableModelEvent e) {
}
- public JTable LatencyTable(DirectedGraphTranslator dgraph, int row, boolean firstTable) {
+ public JTable LatencyTable(DependencyGraphTranslator dgraph, int row, boolean firstTable) {
List<String> onPathBehavior = new ArrayList<String>();
List<String> offPathBehavior = new ArrayList<String>();
List<String> offPathBehaviorCausingDelay = new ArrayList<String>();
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
index 9f89020c79dc9baa052b0b71cc8d8b0c4578663d..7d3589c298ad1b02bfd6fe18f95a65c37b58e003 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
@@ -51,16 +51,16 @@ import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
-import java.lang.Thread.State;
import java.util.HashMap;
-import java.util.Iterator;
import java.util.List;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
import javax.swing.BorderFactory;
import javax.swing.ComboBoxModel;
import javax.swing.DefaultComboBoxModel;
@@ -101,7 +101,7 @@ import common.ConfigurationTTool;
import common.SpecConfigTTool;
import myutil.GraphicLib;
import myutil.ScrolledJTextArea;
-import myutil.TraceManager;
+import simulationtraceanalysis.DependencyGraphTranslator;
import tmltranslator.TMLActivity;
import tmltranslator.TMLMapping;
import tmltranslator.TMLTask;
@@ -159,7 +159,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
private File file;
private static Vector<SimulationTransaction> transFile1;
private JLabel task2, taskL;
- private DirectedGraphTranslator dgraph;
+ private DependencyGraphTranslator dgraph;
private JScrollPane scrollPane11, scrollPane12;// , scrollPane13;
private LatencyAnalysisParallelAlgorithms tc;
private Boolean allop = false;
@@ -504,13 +504,32 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
pbar.setValue(newValue);
}
- public DirectedGraphTranslator getDgraph() {
+ public DependencyGraphTranslator getDgraph() {
return dgraph;
}
protected void generateDirectedGraph(TMLMapping<TGComponent> tmap, List<TMLComponentDesignPanel> cpanels) {
try {
- dgraph = new DirectedGraphTranslator(this, jframeCompareLatencyDetail, tmap, cpanels, 0);
+ dgraph = new DependencyGraphTranslator(tmap);
+ pbar.setMaximum(dgraph.getNodeNbProgressBar());
+ pbar.setMinimum(0);
+ dgraph.addPropertyChangeListener(new PropertyChangeListener() {
+ public void propertyChange(PropertyChangeEvent e) {
+ if (e.getPropertyName().equals("progress")) {
+ int progress = (Integer) e.getNewValue();
+ // Update the progress bar's value with the value of the progress property.
+ if (pbar.getValue() == pbar.getMaximum()) {
+ updateBar(0);
+ } else {
+ updateBar(progress);
+ }
+ pack();
+ revalidate();
+ repaint();
+ }
+ }
+ });
+ dgraph.DrawDirectedGraph();
jta.append("A directed graph with " + dgraph.getGraphsize() + " vertices and " + dgraph.getGraphEdgeSet()
+ " edges has been successfully generated.\n");
// buttonSaveDGraph.setEnabled(true);
@@ -520,6 +539,11 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
jta.append(" - " + dgraph.getWarnings().get(i) + ".\n ");
}
}
+ if (dgraph.getErrors().size() > 0) {
+ for (int i = 0; i < dgraph.getErrors().size(); i++) {
+ error(dgraph.getErrors().get(i));
+ }
+ }
buttonShowDGraph.setEnabled(true);
readChannelTransactions.addAll(dgraph.getreadChannelNodes());
writeChannelTransactions.addAll(dgraph.getwriteChannelNodes());
@@ -692,14 +716,22 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
if (selectedIndex == 0) {
row1 = table11.getSelectedRow();
if (row1 > -1) {
- noLatValue = table11.getValueAt(row1, 4).toString();
+ if (table12.getValueAt(row1, 4) != null) {
+ noLatValue = table11.getValueAt(row1, 4).toString();
+ } else {
+ jta.append("Invaid latency value.\n");
+ }
} else {
jta.append("Please select a row before precise analysis.\n");
}
} else if (selectedIndex == 1) {
row1 = table12.getSelectedRow();
if (row1 > -1) {
- noLatValue = table12.getValueAt(row1, 4).toString();
+ if (table12.getValueAt(row1, 4) != null) {
+ noLatValue = table12.getValueAt(row1, 4).toString();
+ } else {
+ jta.append("Invaid latency value.\n");
+ }
} else {
jta.append("Please select a row before precise analysis.\n");
}
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
index 48ec9ec85afb8dc8c0febe7fffa68937f264dcec..c66757fb740742bf4e068bfb94a11d990bd08fd8 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
@@ -44,14 +44,10 @@ import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.util.ArrayList;
-import java.util.HashMap;
import java.util.List;
-import java.util.Map.Entry;
-import java.util.Vector;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
-import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
@@ -60,7 +56,8 @@ import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
-import ui.interactivesimulation.SimulationTransaction;
+import simulationtraceanalysis.DependencyGraphTranslator;
+import simulationtraceanalysis.PlanArrays;
/**
* Class JFrameLatencyDetailedPopup: this class opens the frame showing the
@@ -76,7 +73,6 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
private JScrollPane scrollPane12, scrollPane13, scrollPane14;
private static JTable taskNames, hardwareNames;
private Object[][] dataDetailedByTask;
- private String[] columnNames;
private List<String> onPathBehavior = new ArrayList<String>();
private List<String> offPathBehavior = new ArrayList<String>();
private List<String> offPathBehaviorCausingDelay = new ArrayList<String>();
@@ -93,8 +89,10 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
private static final String NON_MAND_NO_CONT_TRAN = "Non-Mandatory Transactions No-Contention";
private static final String DEVICE_NAME = "Device Name";
private static final String ZERO = "0";
+ private static final String NON_MAND_CONT_TRAN = "Non-Mandatory Transactions Causing Contention";
+ private static final String TABLE_LENGED = "Table Lenged: ";
- public JFrameLatencyDetailedPopup(DirectedGraphTranslator dgraph, int row, boolean firstTable, Boolean taint,
+ public JFrameLatencyDetailedPopup(DependencyGraphTranslator dgraph, int row, boolean firstTable, Boolean taint,
LatencyAnalysisParallelAlgorithms th, boolean visible) throws InterruptedException {
super("Precise Latency By Row");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
@@ -218,277 +216,9 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
scrollPane13.setVisible(visible);
jp05.add(scrollPane13);
this.add(jp05);
- int maxTime = -1;
- int minTime = Integer.MAX_VALUE;
- int tmpEnd, tmpStart, length;
- Vector<String> deviceNames1 = new Vector<String>();
- if (firstTable) {
- for (SimulationTransaction st : dgraph.getRowDetailsTaks(row)) {
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- tmpEnd = Integer.parseInt(st.endTime);
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
- tmpEnd = Integer.parseInt(st.endTime);
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- int timeInterval = 0;
- if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
- timeInterval = (maxTime - minTime);
- }
- columnNames = new String[timeInterval + 1];
- columnNames[0] = DEVICE_NAME;
- for (int i = 0; i < timeInterval; i++) {
- columnNames[i + 1] = Integer.toString(minTime + i);
- }
- dataDetailedByTask = new Object[deviceNames1.size()][timeInterval + 1];
- for (SimulationTransaction st : dgraph.getRowDetailsTaks(row)) {
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- for (String dName : deviceNames1) {
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (deviceNameandcore.equals(dName)) {
- length = Integer.parseInt(st.length);
- for (int i = 0; i < length; i++) {
- int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
- dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
- ;
- onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOnPath().contains(st)) {
- dgraph.getOnPath().add(st);
- }
- }
- }
- }
- }
- HashMap<String, ArrayList<ArrayList<Integer>>> delayTime = dgraph.getRowDelayDetailsByHW(row);
- for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
- int startTime = Integer.valueOf(st.startTime);
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- for (String dName : deviceNames1) {
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (deviceNameandcore.equals(dName)) {
- length = Integer.parseInt(st.length);
- for (int i = 0; i < length; i++) {
- int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
- dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
- ;
- boolean causeDelay = false;
- if (delayTime.containsKey(deviceNameandcore)) {
- for (Entry<String, ArrayList<ArrayList<Integer>>> entry : delayTime.entrySet()) {
- if (entry.getKey().equals(deviceNameandcore)) {
- ArrayList<ArrayList<Integer>> timeList = entry.getValue();
- for (int j = 0; j < timeList.size(); j++) {
- if (startTime >= timeList.get(j).get(0) && startTime <= timeList.get(j).get(1)) {
- causeDelay = true;
- }
- }
- }
- }
- }
- if (causeDelay) {
- offPathBehaviorCausingDelay.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOffPathDelay().contains(st)) {
- dgraph.getOffPathDelay().add(st);
- }
- } else {
- offPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOffPath().contains(st)) {
- dgraph.getOffPath().add(st);
- }
- }
- }
- }
- }
- }
- for (String dName : deviceNames1) {
- dataDetailedByTask[deviceNames1.indexOf(dName)][0] = dName;
- ;
- }
- } else {
- Vector<SimulationTransaction> minMaxTasksByRow;
- List<SimulationTransaction> minMaxHWByRowDetails;
- HashMap<String, ArrayList<ArrayList<Integer>>> delayTime;
- // min/max table row selected
- if (taint) {
- delayTime = dgraph.getTimeDelayedPerRowMinMaxTainted(row);
- minMaxTasksByRow = dgraph.getMinMaxTasksByRowTainted(row);
- minMaxHWByRowDetails = dgraph.getTaskMinMaxHWByRowDetailsTainted(row);
- for (SimulationTransaction st : minMaxTasksByRow) {
- tmpEnd = Integer.parseInt(st.endTime);
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- for (SimulationTransaction st : minMaxHWByRowDetails) {
- tmpEnd = Integer.parseInt(st.endTime);
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- } else {
- delayTime = dgraph.getRowDelayDetailsByHWMinMax(row);
- minMaxTasksByRow = dgraph.getMinMaxTasksByRow(row);
- minMaxHWByRowDetails = dgraph.getTaskMinMaxHWByRowDetails(row);
- for (SimulationTransaction st : minMaxTasksByRow) {
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- tmpEnd = Integer.parseInt(st.endTime);
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- for (SimulationTransaction st : minMaxHWByRowDetails) {
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- tmpEnd = Integer.parseInt(st.endTime);
- if (tmpEnd > maxTime) {
- maxTime = tmpEnd;
- }
- tmpStart = Integer.parseInt(st.startTime);
- if (tmpStart < minTime) {
- minTime = tmpStart;
- }
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (!deviceNames1.contains(deviceNameandcore)) {
- deviceNames1.add(deviceNameandcore);
- }
- }
- }
- int timeInterval = 0;
- if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
- timeInterval = (maxTime - minTime);
- }
- columnNames = new String[timeInterval + 1];
- columnNames[0] = DEVICE_NAME;
- for (int i = 0; i < timeInterval; i++) {
- columnNames[i + 1] = Integer.toString(minTime + i);
- }
- dataDetailedByTask = new Object[deviceNames1.size()][timeInterval + 1];
- for (SimulationTransaction st : minMaxTasksByRow) {
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- for (String dName : deviceNames1) {
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (deviceNameandcore.equals(dName)) {
- length = Integer.parseInt(st.length);
- for (int i = 0; i < length; i++) {
- int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
- dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
- ;
- onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOnPath().contains(st)) {
- dgraph.getOnPath().add(st);
- }
- }
- }
- }
- }
- for (SimulationTransaction st : minMaxHWByRowDetails) {
- int startTime = Integer.valueOf(st.startTime);
- if (st.coreNumber == null) {
- st.coreNumber = ZERO;
- }
- for (String dName : deviceNames1) {
- String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
- if (deviceNameandcore.equals(dName)) {
- length = Integer.parseInt(st.length);
- for (int i = 0; i < length; i++) {
- int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
- dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
- ;
- boolean causeDelay = false;
- if (delayTime.containsKey(deviceNameandcore)) {
- for (Entry<String, ArrayList<ArrayList<Integer>>> entry : delayTime.entrySet()) {
- if (entry.getKey().equals(deviceNameandcore)) {
- ArrayList<ArrayList<Integer>> timeList = entry.getValue();
- for (int j = 0; j < timeList.size(); j++) {
- if (startTime >= timeList.get(j).get(0) && startTime <= timeList.get(j).get(1)) {
- causeDelay = true;
- }
- }
- }
- }
- }
- if (causeDelay) {
- offPathBehaviorCausingDelay.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOffPathDelay().contains(st)) {
- dgraph.getOffPathDelay().add(st);
- }
- } else {
- offPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
- if (!dgraph.getOffPath().contains(st)) {
- dgraph.getOffPath().add(st);
- }
- }
- }
- }
- }
- }
- for (String dName : deviceNames1) {
- dataDetailedByTask[deviceNames1.indexOf(dName)][0] = dName;
- ;
- }
- }
- DefaultTableModel model3 = new DefaultTableModel(dataDetailedByTask, columnNames) {
+ PlanArrays arrays = new PlanArrays();
+ arrays.fillArrays(dgraph, row, firstTable, taint);
+ DefaultTableModel model3 = new DefaultTableModel(arrays.getDataDetailedByTask(), arrays.getColumnNames()) {
@Override
public boolean isCellEditable(int row, int column) {
return false;
@@ -498,7 +228,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
table.setFillsViewportHeight(true);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setAutoCreateRowSorter(true);
- TableRenderer tr = new TableRenderer(onPathBehavior, offPathBehaviorCausingDelay, offPathBehavior);
+ TableRenderer tr = new TableRenderer(arrays.getOnPathBehavior(), arrays.getOffPathBehaviorCausingDelay(), arrays.getOffPathBehavior());
int ncols = table.getColumnCount();
table.getModel().addTableModelListener(this);
TableColumnModel tcm = table.getColumnModel();
@@ -540,12 +270,12 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
c01.gridwidth = 1;
c01.gridx = 0;
c01.gridy = 0;
- JLabel pBarLabel0 = new JLabel("Table Lenged: ");
+ JLabel pBarLabel0 = new JLabel(TABLE_LENGED);
JPanel lengedpanel = new JPanel(gridbag01);
lengedpanel.add(pBarLabel0, c01);
c01.gridx = 2;
c01.gridy = 0;
- JLabel pBarLabel = new JLabel("Mandatory Transaction", JLabel.RIGHT);
+ JLabel pBarLabel = new JLabel(MANDATORY_TRANSACTIONS, JLabel.RIGHT);
lengedpanel.add(pBarLabel, c01);
c01.gridx = 1;
c01.gridy = 0;
@@ -555,7 +285,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
lengedpanel.add(pBarLabel2, c01);
c01.gridx = 4;
c01.gridy = 0;
- JLabel pBarLabel3 = new JLabel("Non-Mandatory Transactions Causing Contention", JLabel.RIGHT);
+ JLabel pBarLabel3 = new JLabel(NON_MAND_CONT_TRAN, JLabel.RIGHT);
lengedpanel.add(pBarLabel3, c01);
c01.gridx = 3;
c01.gridy = 0;
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameListOfRules.java b/src/main/java/ui/simulationtraceanalysis/JFrameListOfRules.java
index 65bbbda1f597b848501284d6cd408945727aa9f9..c0f85d8f7b21661ec45a2a2d17dc1c517ebf6323 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameListOfRules.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameListOfRules.java
@@ -38,17 +38,14 @@
package ui.simulationtraceanalysis;
import java.awt.BorderLayout;
-import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
-import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
-import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map.Entry;
@@ -66,6 +63,8 @@ import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableModel;
import org.jgrapht.Graphs;
import myutil.ScrolledJTextArea;
+import simulationtraceanalysis.DependencyGraphTranslator;
+import simulationtraceanalysis.Vertex;
import ui.ColorManager;
/**
@@ -79,8 +78,8 @@ import ui.ColorManager;
*/
public class JFrameListOfRules extends JFrame implements TableModelListener, ActionListener {
private String[] columnByTaskNames = new String[3];
- private HashMap<vertex, List<vertex>> ruleAddedEdges = new HashMap<vertex, List<vertex>>();
- private HashMap<vertex, List<vertex>> ruleAddedEdgesChannels = new HashMap<vertex, List<vertex>>();
+ private HashMap<Vertex, List<Vertex>> ruleAddedEdges = new HashMap<Vertex, List<Vertex>>();
+ private HashMap<Vertex, List<Vertex>> ruleAddedEdgesChannels = new HashMap<Vertex, List<Vertex>>();
private Object[][] tableData;
private JScrollPane scrollPane12;
private JButton buttonClose, buttonDeleteRule, buttonDeleteALLRules;
@@ -88,11 +87,11 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
private JTextArea jta;
private JPanel jp, jp05, commands, rulesList, rulesList1;
private JScrollPane jsp;
- private DirectedGraphTranslator directedGraph;
+ private DependencyGraphTranslator directedGraph;
private JTable taskNames;
private DefaultTableModel model;
- public JFrameListOfRules(DirectedGraphTranslator dgraph) {
+ public JFrameListOfRules(DependencyGraphTranslator dgraph) {
super("All Added Rules");
initActions();
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
@@ -122,7 +121,7 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
columnByTaskNames[0] = "Operator 2";
columnByTaskNames[1] = "After ";
columnByTaskNames[2] = "Operator 1 ";
- ruleAddedEdgesChannels = dgraph.getRuleAddedEdgesChannels();
+ ruleAddedEdgesChannels = dgraph.getDependencyGraphRelations().getRuleAddedEdgesChannels();
fillRuleTables();
scrollPane12 = new JScrollPane(taskNames, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
scrollPane12.setVisible(true);
@@ -179,16 +178,16 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
// fill table with prevously created rules in the same session
private void fillRuleTables() {
int size = 0;
- for (Entry<vertex, List<vertex>> v : ruleAddedEdgesChannels.entrySet()) {
- vertex v1 = v.getKey();
- List<vertex> lv = v.getValue();
+ for (Entry<Vertex, List<Vertex>> v : ruleAddedEdgesChannels.entrySet()) {
+ Vertex v1 = v.getKey();
+ List<Vertex> lv = v.getValue();
size = size + lv.size();
}
tableData = new Object[size][3];
int j = 0;
- for (Entry<vertex, List<vertex>> v : ruleAddedEdgesChannels.entrySet()) {
- vertex v1 = v.getKey();
- List<vertex> lv = v.getValue();
+ for (Entry<Vertex, List<Vertex>> v : ruleAddedEdgesChannels.entrySet()) {
+ Vertex v1 = v.getKey();
+ List<Vertex> lv = v.getValue();
for (int i = 0; i < lv.size(); i++) {
tableData[j][0] = lv.get(i).getName();
tableData[j][1] = "After";
@@ -247,8 +246,8 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
dispose();
setVisible(false);
} else if (command.equals(actions[LatencyDetailedAnalysisActions.ACT_DELETE_ALL_RULE].getActionCommand())) {
- directedGraph.setRuleAddedEdges(new HashMap<vertex, List<vertex>>());
- directedGraph.setRuleAddedEdgesChannels(new HashMap<vertex, List<vertex>>());
+ directedGraph.getDependencyGraphRelations().setRuleAddedEdges(new HashMap<Vertex, List<Vertex>>());
+ directedGraph.getDependencyGraphRelations().setRuleAddedEdgesChannels(new HashMap<Vertex, List<Vertex>>());
model.setRowCount(0);
taskNames.setModel(model);
jta.append("All Rules are deleted \n");
@@ -263,9 +262,9 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
this.setVisible(true);
} else if (command.equals(actions[LatencyDetailedAnalysisActions.ACT_DELETE_SELECTED_RULE].getActionCommand())) {
int i = taskNames.getSelectedRow();
- vertex v1 = directedGraph.getvertex(model.getValueAt(i, 0).toString());
- vertex v2 = directedGraph.getvertex(model.getValueAt(i, 2).toString());
- ruleAddedEdges = directedGraph.getRuleAddedEdges();
+ Vertex v1 = directedGraph.getvertex(model.getValueAt(i, 0).toString());
+ Vertex v2 = directedGraph.getvertex(model.getValueAt(i, 2).toString());
+ ruleAddedEdges = directedGraph.getDependencyGraphRelations().getRuleAddedEdges();
// remove rule and its channel
removeRule(v1, v2, i);
model.removeRow(i);
@@ -284,19 +283,19 @@ public class JFrameListOfRules extends JFrame implements TableModelListener, Act
}
}
- private void removeRule(vertex v1, vertex v2, int i) {
- vertex v1Channel = null, v2Channel = null;
+ private void removeRule(Vertex v1, Vertex v2, int i) {
+ Vertex v1Channel = null, v2Channel = null;
if (v2Channel == null && Graphs.vertexHasSuccessors(directedGraph.getG(), v2)) {
- for (vertex n : Graphs.successorListOf(directedGraph.getG(), v2)) {
- if (n.getType() == vertex.TYPE_CHANNEL) {
+ for (Vertex n : Graphs.successorListOf(directedGraph.getG(), v2)) {
+ if (n.getType() == Vertex.getTypeChannel()) {
v2Channel = n;
break;
}
}
}
if (Graphs.vertexHasPredecessors(directedGraph.getG(), v1)) {
- for (vertex n : Graphs.predecessorListOf(directedGraph.getG(), v1)) {
- if (n.getType() == vertex.TYPE_CHANNEL) {
+ for (Vertex n : Graphs.predecessorListOf(directedGraph.getG(), v1)) {
+ if (n.getType() == Vertex.getTypeChannel()) {
v1Channel = n;
break;
}
diff --git a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
index 3c62599b3881e155465b6e6b03b644184c7c03ec..a2af5cf6a6790592767f8dd979c9c574564b3200 100644
--- a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
+++ b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
@@ -6,6 +6,7 @@ import java.util.Vector;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
import org.xml.sax.SAXException;
+import simulationtraceanalysis.DependencyGraphTranslator;
import tmltranslator.TMLMapping;
import ui.MainGUI;
import ui.SimulationTrace;
@@ -21,7 +22,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
private JFrameCompareLatencyDetail cld;
private TMLMapping<TGComponent> tmap;
private List<TMLComponentDesignPanel> cpanels;
- private DirectedGraphTranslator dgraph, dgraph1, dgraph2;
+ private DependencyGraphTranslator dgraph, dgraph1, dgraph2;
private int row, row1, row2, row3, row4, selectedIndex;
private Object[][] dataDetailedByTask, dataDetailedByTask2;
private latencyDetailedAnalysisMain main;
@@ -84,7 +85,8 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
} else if (algorithmId == 14) {
dgraph.showGraph(dgraph);
} else if (algorithmId == 15) {
- dgraph = new DirectedGraphTranslator(jFrameLDA, cld, map, cpanels, 1);
+ dgraph = new DependencyGraphTranslator(map);
+ dgraph.DrawDirectedGraph();
generateDirectedGraph2(map, cpanels);
} else if (algorithmId == 16) {
cld.generateDirectedGraph2(map, cpanels);
@@ -139,7 +141,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
return t;
}
- public void setDgraph2(DirectedGraphTranslator dgraph2) {
+ public void setDgraph2(DependencyGraphTranslator dgraph2) {
this.dgraph2 = dgraph2;
}
@@ -171,7 +173,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
this.cpanels = cpanels;
}
- public void setDgraph(DirectedGraphTranslator dgraph) {
+ public void setDgraph(DependencyGraphTranslator dgraph) {
this.dgraph = dgraph;
}
@@ -211,11 +213,11 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
this.map = map;
}
- public DirectedGraphTranslator getDgraph() {
+ public DependencyGraphTranslator getDgraph() {
return dgraph;
}
- public void setDgraph1(DirectedGraphTranslator dgraph1) {
+ public void setDgraph1(DependencyGraphTranslator dgraph1) {
this.dgraph1 = dgraph1;
}
diff --git a/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisActions.java b/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisActions.java
index 628e0ba5337b5461fccee07d509c2c1e18d55058..14e7a64dd56f58255ee5a4469bec50448f499c6a 100644
--- a/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisActions.java
+++ b/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisActions.java
@@ -76,7 +76,10 @@ public class LatencyDetailedAnalysisActions extends AbstractAction {
public static final int ACT_SHOW_ALL_OP = 17;
public static final int ACT_LOAD_ALL_OP = 18;
public static final int ACT_LOAD_ALL_OP2 = 19;
- public static final int NB_ACTION = 20;
+ public static final int ACT_COMPARE_PARSE = 20;
+ public static final int ACT_COMPARE_DIFF = 21;
+ public static final int ACT_COMPARE_CLOSE = 22;
+ public static final int NB_ACTION = 23;
private static final TAction[] actions = new TAction[NB_ACTION];
private EventListenerList listeners;
public static final String JLF_IMAGE_DIR = "";
@@ -145,6 +148,11 @@ public class LatencyDetailedAnalysisActions extends AbstractAction {
"Load Task Operators", "Load Task Operators", 'T');
actions[ACT_LOAD_ALL_OP2] = new TAction("load-operators_list2", "Load Task Operators", IconManager.imgic29, IconManager.imgic29,
"Load Task Operators", "Load Task Operators", 'T');
+ actions[ACT_COMPARE_CLOSE] = new TAction("stop-and-close-all", "Terminate Compare", IconManager.imgic27, IconManager.imgic27,
+ "Terminate Compare", "Compare", 'T');
+ actions[ACT_COMPARE_PARSE] = new TAction("parse", "Parse", IconManager.imgic53, IconManager.imgic53, "Parse", "Parse", 'C');
+ actions[ACT_COMPARE_DIFF] = new TAction("difference", "View Difference", IconManager.imgic29, IconManager.imgic29, "View Difference",
+ "View Difference", 'T');
}
public String getActionCommand() {
diff --git a/src/main/java/ui/simulationtraceanalysis/latencyDetailedAnalysisMain.java b/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisMain.java
similarity index 98%
rename from src/main/java/ui/simulationtraceanalysis/latencyDetailedAnalysisMain.java
rename to src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisMain.java
index 97f042e1e88a8623b78c422ce3aad0b795dab131..64a7115059f6ab29ce15e900bfc856aabef77f88 100644
--- a/src/main/java/ui/simulationtraceanalysis/latencyDetailedAnalysisMain.java
+++ b/src/main/java/ui/simulationtraceanalysis/LatencyDetailedAnalysisMain.java
@@ -6,8 +6,8 @@ import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
@@ -19,6 +19,7 @@ import org.w3c.dom.Document;
import org.xml.sax.SAXException;
import myutil.GraphicLib;
import myutil.TraceManager;
+import simulationtraceanalysis.DependencyGraphTranslator;
import tmltranslator.TMLMapping;
import ui.MainGUI;
import ui.SimulationTrace;
@@ -31,7 +32,7 @@ import ui.tmldd.TMLArchiNode;
import ui.util.IconManager;
import ui.window.JDialogToChosePanel;
-public class latencyDetailedAnalysisMain {
+public class LatencyDetailedAnalysisMain {
private Vector<String> checkedTransactionsFile1 = new Vector<String>();
private Vector<String> checkedTransactionsFile2 = new Vector<String>();
private Vector<String> checkedTransactionsFile = new Vector<String>();
@@ -47,7 +48,7 @@ public class latencyDetailedAnalysisMain {
public static final String TML_COMP_TASK_DIAGRAM = "TML Component Task Diagram";
public static final String MODEL_PATH = "/siminfo/global/model";
- public latencyDetailedAnalysisMain(int callerId, MainGUI mainGUI, SimulationTrace selectedST, boolean b, boolean compare, int j)
+ public LatencyDetailedAnalysisMain(int callerId, MainGUI mainGUI, SimulationTrace selectedST, boolean b, boolean compare, int j)
throws InterruptedException {
try {
setTc(new LatencyAnalysisParallelAlgorithms(this));
@@ -199,7 +200,7 @@ public class latencyDetailedAnalysisMain {
}
public void compareLatencyForXML(MainGUI mainGUI, SimulationTrace selectedST, boolean b) throws InterruptedException {
- final DirectedGraphTranslator dgraph1, dgraph2;
+ final DependencyGraphTranslator dgraph1, dgraph2;
try {
checkedTransactionsFile = new Vector<String>();
latencyDetailedAnalysisForXML(mainGUI, selectedST, false, true, 1);
diff --git a/src/main/java/ui/simulationtraceanalysis/SimulationTraceTableRenderer.java b/src/main/java/ui/simulationtraceanalysis/SimulationTraceTableRenderer.java
new file mode 100644
index 0000000000000000000000000000000000000000..c2e383be5cd77499979c7dff3c1f6f239a4d5f84
--- /dev/null
+++ b/src/main/java/ui/simulationtraceanalysis/SimulationTraceTableRenderer.java
@@ -0,0 +1,52 @@
+package ui.simulationtraceanalysis;
+
+import java.awt.Color;
+import java.awt.Component;
+import java.util.Random;
+import java.util.Vector;
+import javax.swing.JTable;
+import javax.swing.UIManager;
+import javax.swing.table.DefaultTableCellRenderer;
+
+public class SimulationTraceTableRenderer extends DefaultTableCellRenderer {
+ private int row, col;
+ private Vector<Object> allCommands = new Vector<Object>();
+ private Vector<Color> allColors = new Vector<Color>();
+
+ public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
+ this.row = row;
+ this.col = column;
+ // Allow superclass to return rendering component.
+ return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
+ }
+
+ protected void setValue(Object v) {
+ super.setValue(v);
+ if (v == null) {
+ setForeground(UIManager.getColor("Table.foreground"));
+ setBackground(UIManager.getColor("Table.background"));
+ return;
+ } else if (!allCommands.contains(v)) {
+ allCommands.add(v);
+ boolean x = true;
+ while (x) {
+ Random randomGenerator = new Random();
+ int red = randomGenerator.nextInt(256);
+ int green = randomGenerator.nextInt(256);
+ int blue = randomGenerator.nextInt(256);
+ Color randomColour = new Color(red, green, blue);
+ if (!allColors.contains(randomColour)) {
+ allColors.add(randomColour);
+ x = false;
+ }
+ }
+ }
+ if (allCommands.contains(v)) {
+ setForeground(Color.yellow);
+ setBackground(allColors.get(allCommands.indexOf(v)));
+ } else {
+ setForeground(UIManager.getColor("Table.foreground"));
+ setBackground(UIManager.getColor("Table.background"));
+ }
+ }
+}
diff --git a/ttool/src/test/java/ui/ComparisonOfsimulationTracesInXML/ComparisonOfsimulationTraces.java b/ttool/src/test/java/ui/ComparisonOfsimulationTracesInXML/ComparisonOfsimulationTraces.java
index 19746511f645744f850a31a53f0f237e23ccdb9e..db8173ba7908736482835727004b1b9b929c21fc 100644
--- a/ttool/src/test/java/ui/ComparisonOfsimulationTracesInXML/ComparisonOfsimulationTraces.java
+++ b/ttool/src/test/java/ui/ComparisonOfsimulationTracesInXML/ComparisonOfsimulationTraces.java
@@ -1,84 +1,60 @@
package ui.ComparisonOfsimulationTracesInXML;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.*;
-
-import java.awt.event.ActionEvent;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
-import org.junit.*;
+import org.junit.BeforeClass;
+import org.junit.Test;
import org.xml.sax.SAXException;
+import simulationtraceanalysis.CompareSimulationTrace;
import ui.AbstractUITest;
import ui.SimulationTrace;
-import ui.interactivesimulation.JFrameCompareSimulationTraces;
import ui.interactivesimulation.JFrameShowLatencyDetails;
-import ui.interactivesimulation.JPanelCompareXmlGraph;
-
+import ui.simulationtraceanalysis.JFrameCompareSimulationTraces;
public class ComparisonOfsimulationTraces extends AbstractUITest {
-
protected static SimulationTrace selectedST1;
protected static SimulationTrace selectedST2;
-
protected static String STfilePath1;
protected static String STfilePath2;
-
private static JFrameCompareSimulationTraces cSimTrace;
- private static JPanelCompareXmlGraph newContentPane;
+ private static CompareSimulationTrace newContentPane;
private static JFrameShowLatencyDetails showLatencyDetails;
private static final String PATH1 = "/ui/xmlCompare/input/simple.xml";
private static final String PATH2 = "/ui/xmlCompare/input/simplifiedWithSecurity.xml";
-
@BeforeClass
public static void setUpBeforeClass() throws Exception {
-
STfilePath1 = getBaseResourcesDir() + PATH1;
STfilePath2 = getBaseResourcesDir() + PATH2;
-
selectedST1 = new SimulationTrace("simple.xml", 6, STfilePath1);
selectedST2 = new SimulationTrace("simplifiedWithSecurity.xml", 6, STfilePath2);
-
}
-
@Test
public void loadTest() {
assertNotNull(selectedST1);
assertNotNull(selectedST2);
-
}
-
@Test
public void parseXMLTest() throws SAXException, IOException, ParserConfigurationException {
-
cSimTrace = new JFrameCompareSimulationTraces(mainGUI, "Compare Simulation simulation", selectedST1, false);
cSimTrace.setVisible(false);
cSimTrace.parseXML(STfilePath1, STfilePath2);
-
assertNotNull(cSimTrace.getTransFile1());
assertNotNull(cSimTrace.getTransFile2());
-
- newContentPane = new JPanelCompareXmlGraph(cSimTrace.getTransFile1(), cSimTrace.getTransFile2());
- newContentPane.setVisible(false);
-
}
-
@Test
public void diffTest() throws SAXException, IOException, ParserConfigurationException {
-
+ newContentPane = new CompareSimulationTrace();
+ newContentPane.JPanelCompareXmlGraph(cSimTrace.getTransFile1(), cSimTrace.getTransFile2());
assertTrue(newContentPane.getTable().getRowCount() > 0);
-
}
-
- @Test
- public void latencyTest() throws SAXException, IOException, ParserConfigurationException {
+ /* public void latencyTest() throws SAXException, IOException, ParserConfigurationException {
JFrameShowLatencyDetails showLatencyDetails = new JFrameShowLatencyDetails(cSimTrace.getTransFile1(), cSimTrace.getTransFile2(), "CPU1_1",
"Request SmartCard", "CPU1_1", "Send end", false);
-
showLatencyDetails.setVisible(false);
-
assertTrue(showLatencyDetails.getTable11().getRowCount() > 0);
-
- }
-
+ }*/
}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/GraphLatencyAnalysis/CompareLatencyInSimulationTraces.java b/ttool/src/test/java/ui/GraphLatencyAnalysis/CompareLatencyInSimulationTraces.java
index df611dd38742c5eb3ba4c737d6b9451e6fc17e3e..6bc3b0a250f42ec590c01979396db627ec72cbac 100644
--- a/ttool/src/test/java/ui/GraphLatencyAnalysis/CompareLatencyInSimulationTraces.java
+++ b/ttool/src/test/java/ui/GraphLatencyAnalysis/CompareLatencyInSimulationTraces.java
@@ -5,8 +5,8 @@ import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.IOException;
import java.util.HashMap;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
@@ -15,210 +15,148 @@ import org.junit.Before;
import org.junit.Test;
import org.xml.sax.SAXException;
+import simulationtraceanalysis.DependencyGraphTranslator;
import ui.AbstractUITest;
import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.interactivesimulation.SimulationTransaction;
-import ui.simulationtraceanalysis.DirectedGraphTranslator;
import ui.simulationtraceanalysis.JFrameCompareLatencyDetail;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
import ui.simulationtraceanalysis.LatencyAnalysisParallelAlgorithms;
-import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class CompareLatencyInSimulationTraces extends AbstractUITest {
-
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
-
private static final String simulationTracePathFile1 = INPUT_PATH + "/graphTestSimulationTrace.xml";
-
private static final String simulationTracePathFile2 = INPUT_PATH + "/testFunc.xml";
private static final String modelPath = INPUT_PATH + "/GraphTestModel.xml";
-
private static final String mappingDiagName = "Architecture2";
-
private Vector<String> checkedTransactionsFile1 = new Vector<String>();
private Vector<String> checkedTransactionsFile2 = new Vector<String>();
-
private static final int operator1ID = 44;
private static final int operator2ID = 26;
private static final int operator3ID = 40;
private static final int operator4ID = 28;
- private DirectedGraphTranslator dgraph1, dgraph2;
+ private DependencyGraphTranslator dgraph1, dgraph2;
private static String task1, task2, task3, task4;
private JFrameCompareLatencyDetail cld;
- private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
private JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis;
-
private Vector<SimulationTransaction> transFile1, transFile2;
private SimulationTrace simT1, simT2;
private File file1, file2;
private int row, row2;
-
private HashMap<String, Integer> checkedT1 = new HashMap<String, Integer>();
private HashMap<String, Integer> checkedT2 = new HashMap<String, Integer>();
-
// protected MainGUI mainGUI1 = null;
-
private static Object[][] dataDetailedByTask, dataDetailedByTask2, dataHWDelayByTask, dataHWDelayByTask2;
public CompareLatencyInSimulationTraces() {
-
super();
-
}
@Before
public void GraphLatencyAnalysis()
throws XPathExpressionException, ParserConfigurationException, SAXException, IOException, InterruptedException {
-
mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + modelPath));
-
final TMLArchiPanel panel = findArchiPanel(mappingDiagName);
-
simT1 = new SimulationTrace("graphTestSimulationTrace", 6, (getBaseResourcesDir() + simulationTracePathFile1));
-
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(3, mainGUI, simT1, false, false, 3);
- latencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
-
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, simT1, false, false, 3);
+ LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
try {
- latencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT1, false, true, 1);
- latencyDetailedAnalysisMain.setTc(new LatencyAnalysisParallelAlgorithms(latencyDetailedAnalysisMain));
-
- cld = new JFrameCompareLatencyDetail(latencyDetailedAnalysisMain, mainGUI, checkedTransactionsFile1,
- latencyDetailedAnalysisMain.getMap1(), latencyDetailedAnalysisMain.getCpanels1(), simT1, false,
- latencyDetailedAnalysisMain.getTc());
-
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT1, false, true, 1);
+ LatencyDetailedAnalysisMain.setTc(new LatencyAnalysisParallelAlgorithms(LatencyDetailedAnalysisMain));
+ cld = new JFrameCompareLatencyDetail(LatencyDetailedAnalysisMain, mainGUI, checkedTransactionsFile1,
+ LatencyDetailedAnalysisMain.getMap1(), LatencyDetailedAnalysisMain.getCpanels1(), simT1, false,
+ LatencyDetailedAnalysisMain.getTc());
if (cld == null) {
System.out.println("NULL Panel");
} else {
cld.setVisible(false);
}
-
} catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
-
- latencyDetailedAnalysisMain.getTc().getT().join();
+ LatencyDetailedAnalysisMain.getTc().getT().join();
if (cld.getDgraph().getGraphsize() > 0) {
dgraph1 = cld.getDgraph();
- checkedTransactionsFile1 = latencyDetailedAnalysisMain.getCheckedTransactionsFile();
- checkedT1 = latencyDetailedAnalysisMain.getCheckedT1();
+ checkedTransactionsFile1 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
+ checkedT1 = LatencyDetailedAnalysisMain.getCheckedT1();
cld.setDgraph(null);
-
- latencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
+ LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
simT2 = new SimulationTrace("graphTestSimulationTrace", 6, (getBaseResourcesDir() + simulationTracePathFile2));
-
try {
-
- latencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT2, false, true, 1);
-
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT2, false, true, 1);
} catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
-
- dgraph2 = new DirectedGraphTranslator(jFrameLatencyDetailedAnalysis, cld, latencyDetailedAnalysisMain.getMap1(),
- latencyDetailedAnalysisMain.getCpanels1(), 3);
-
- checkedTransactionsFile2 = latencyDetailedAnalysisMain.getCheckedTransactionsFile();
- checkedT2 = latencyDetailedAnalysisMain.getCheckedT2();
-
+ dgraph2 = new DependencyGraphTranslator(LatencyDetailedAnalysisMain.getMap1());
+ dgraph2.DrawDirectedGraph();
+ checkedTransactionsFile2 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
+ checkedT2 = LatencyDetailedAnalysisMain.getCheckedT2();
}
-
}
@Test
public void parseFile() {
-
int graphsize = dgraph1.getGraphsize();
-
assertTrue(1 > 0);
-
graphsize = dgraph2.getGraphsize();
-
assertTrue(graphsize > 0);
-
assertTrue(checkedT1.size() == 3);
-
assertTrue(checkedT2.size() == 3);
-
for (Entry<String, Integer> cT : checkedT1.entrySet()) {
-
int id = cT.getValue();
String taskName = cT.getKey();
if (id == operator1ID) {
task1 = taskName;
-
} else if (id == operator2ID) {
task2 = taskName;
-
}
}
-
for (Entry<String, Integer> cT : checkedT2.entrySet()) {
-
int id = cT.getValue();
String taskName = cT.getKey();
if (id == operator3ID) {
task3 = taskName;
-
} else if (id == operator4ID) {
task4 = taskName;
-
}
}
-
file1 = new File(simT1.getFullPath());
file2 = new File(simT2.getFullPath());
-
transFile1 = cld.parseFile(file1);
transFile2 = cld.parseFile(file2);
-
cld.setDgraph2(dgraph2);
-
cld.latencyDetailedAnalysis(task1, task2, task3, task4, transFile1, transFile2, false, false, false);
-
cld.setVisible(false);
-
assertTrue(cld.getTableData().length > 0);
assertTrue(cld.getTableData2().length > 0);
assertTrue(cld.getTableData1MinMax().length > 0);
assertTrue(cld.getTableData2MinMax().length > 0);
-
// test row 1 table 1 and row 1 table 2
-
row = 1;
row2 = 1;
-
dataDetailedByTask = dgraph1.getTaskByRowDetails(row);
-
dataDetailedByTask2 = dgraph2.getTaskByRowDetails(row2);
-
dataHWDelayByTask = dgraph1.getTaskHWByRowDetails(row);
dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetails(row2);
-
assertTrue(dataDetailedByTask.length > 0);
assertTrue(dataDetailedByTask2.length > 0);
assertTrue(dataHWDelayByTask.length > 0);
assertTrue(dataHWDelayByTask2.length > 0);
-
// test max table 1 and max table 2
-
dgraph1.getRowDetailsMinMax(row);
dataDetailedByTask = dgraph1.getTasksByRowMinMax(row);
-
dgraph2.getRowDetailsMinMax(row2);
dataDetailedByTask2 = dgraph2.getTasksByRowMinMax(row2);
-
dataHWDelayByTask = dgraph1.getTaskHWByRowDetailsMinMax(row);
dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetailsMinMax(row2);
-
assertTrue(dataDetailedByTask.length > 0);
assertTrue(dataDetailedByTask2.length > 0);
assertTrue(dataHWDelayByTask.length > 0);
assertTrue(dataHWDelayByTask2.length > 0);
-
}
-
}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/GraphLatencyAnalysis/GraphLatencyAnalysis.java b/ttool/src/test/java/ui/GraphLatencyAnalysis/GraphLatencyAnalysis.java
index b3ae083d4711e11bffa98423afdd642e08fc03ae..b81072a68bdb77fdd6d92b69f50f191b0b910ae8 100644
--- a/ttool/src/test/java/ui/GraphLatencyAnalysis/GraphLatencyAnalysis.java
+++ b/ttool/src/test/java/ui/GraphLatencyAnalysis/GraphLatencyAnalysis.java
@@ -2,19 +2,22 @@ package ui.GraphLatencyAnalysis;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.util.HashMap;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
+
import org.junit.Before;
import org.junit.Test;
+
+import simulationtraceanalysis.DependencyGraphTranslator;
import ui.AbstractUITest;
import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.interactivesimulation.SimulationTransaction;
-import ui.simulationtraceanalysis.DirectedGraphTranslator;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
-import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class GraphLatencyAnalysis extends AbstractUITest {
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
@@ -28,10 +31,10 @@ public class GraphLatencyAnalysis extends AbstractUITest {
private static final int OPERATOR2_ID = 26;
private static String task1;
private static String task2;
- private static DirectedGraphTranslator dgt;
+ private static DependencyGraphTranslator dgt;
private static Object[][] allLatencies, minMaxArray, taskHWByRowDetails, detailedLatency;
private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
- private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
@Before
public void GraphLatencyAnalysis() throws InterruptedException {
@@ -45,10 +48,10 @@ public class GraphLatencyAnalysis extends AbstractUITest {
}
mainGUI.checkModelingSyntax(panel, true);
SimulationTrace file2 = new SimulationTrace("graphTestSimulationTrace", 6, SIMULATIONTRACE_PATH);
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
- latencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
- latencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
- latencyDetailedAnalysis = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
if (latencyDetailedAnalysis != null) {
latencyDetailedAnalysis.setVisible(false);
try {
@@ -68,7 +71,7 @@ public class GraphLatencyAnalysis extends AbstractUITest {
assertTrue(graphsize == 40);
checkedDropDown = latencyDetailedAnalysis.getCheckedT();
assertTrue(checkedDropDown.size() == 3);
- transFile1 = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH));
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH));
assertTrue(transFile1.size() == 175);
for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
int id = cT.getValue();
diff --git a/ttool/src/test/java/ui/GraphLatencyAnalysis/NestedStructurePLAN.java b/ttool/src/test/java/ui/GraphLatencyAnalysis/NestedStructurePLAN.java
index a723594ff0971f1a4494a45fc029b579c419445f..ae2678b2dcd3ac09307ad5847d7433638a3c1167 100644
--- a/ttool/src/test/java/ui/GraphLatencyAnalysis/NestedStructurePLAN.java
+++ b/ttool/src/test/java/ui/GraphLatencyAnalysis/NestedStructurePLAN.java
@@ -3,28 +3,31 @@ package ui.GraphLatencyAnalysis;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.util.HashMap;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
+
import org.junit.Before;
import org.junit.Test;
+
+import simulationtraceanalysis.DependencyGraphTranslator;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.interactivesimulation.SimulationTransaction;
-import ui.simulationtraceanalysis.DirectedGraphTranslator;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
-import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
-import ui.AbstractUITest;
-import ui.SimulationTrace;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class NestedStructurePLAN extends AbstractUITest {
private static final String mapping_Diag_Name = "Architecture";
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
private static final String SIMULATIONTRACE_PATH_FILE = INPUT_PATH + "/loopseqTrace.xml";
private static final String MODEL_PATH = INPUT_PATH + "/loopseqgraph.xml";
- private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
- private static DirectedGraphTranslator dgt;
+ private static DependencyGraphTranslator dgt;
private Vector<SimulationTransaction> transFile1;
private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
private static final int OPERATOR1_ID = 69;
@@ -45,10 +48,10 @@ public class NestedStructurePLAN extends AbstractUITest {
}
mainGUI.checkModelingSyntax(panel, true);
SimulationTrace file2 = new SimulationTrace("graphTestSimulationTrace", 6, SIMULATIONTRACE_PATH_FILE);
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
- latencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
- latencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
- latencyDetailedAnalysis = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
if (latencyDetailedAnalysis != null) {
latencyDetailedAnalysis.setVisible(false);
try {
@@ -120,7 +123,7 @@ public class NestedStructurePLAN extends AbstractUITest {
assertTrue(dgt.edgeExists(52, 54));
assertFalse(dgt.edgeExists(40, 54));
assertFalse(dgt.edgeExists(40, 42));
- transFile1 = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH_FILE));
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH_FILE));
assertTrue(transFile1.size() == 38);
checkedDropDown = latencyDetailedAnalysis.getCheckedT();
for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
diff --git a/ttool/src/test/java/ui/GraphLatencyTainting/GraphLatencyAnalysisTainting.java b/ttool/src/test/java/ui/GraphLatencyTainting/GraphLatencyAnalysisTainting.java
index 53ab5ad41de051287e8d3f904016071fc8595ab2..703674200babf91e37515c6fb8298410142fe9d1 100644
--- a/ttool/src/test/java/ui/GraphLatencyTainting/GraphLatencyAnalysisTainting.java
+++ b/ttool/src/test/java/ui/GraphLatencyTainting/GraphLatencyAnalysisTainting.java
@@ -5,68 +5,55 @@ import static org.junit.Assert.assertTrue;
import java.io.File;
import java.util.HashMap;
-import java.util.Vector;
import java.util.Map.Entry;
+import java.util.Vector;
import org.junit.Before;
import org.junit.Test;
+import simulationtraceanalysis.DependencyGraphTranslator;
import ui.AbstractUITest;
import ui.SimulationTrace;
import ui.TMLArchiPanel;
import ui.interactivesimulation.SimulationTransaction;
-import ui.simulationtraceanalysis.DirectedGraphTranslator;
import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
-import ui.simulationtraceanalysis.latencyDetailedAnalysisMain;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
public class GraphLatencyAnalysisTainting extends AbstractUITest {
-
// private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
-
private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
private static final String simulationTracePath = INPUT_PATH + "/tainting.xml";
-
private static final String modelPath = INPUT_PATH + "/GraphLatencyAnalysisTainting.xml";
-
private static final String mappingDiagName = "Architecture";
private Vector<SimulationTransaction> transFile1;
private Vector<String> dropDown;
-
private static final int operator1ID = 47;
private static final int operator2ID = 37;
private static String task1;
private static String task2;
- private static DirectedGraphTranslator dgt;
-
+ private static DependencyGraphTranslator dgt;
private static Object[][] allLatencies, minMaxArray, taskHWByRowDetails, detailedLatency;
private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
- private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
@Before
public void GraphLatencyAnalysis() throws InterruptedException {
-
mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + modelPath));
-
final TMLArchiPanel panel = findArchiPanel(mappingDiagName);
-
if (panel == null) {
System.out.println("NULL Panel");
} else {
System.out.println("Non NULL Panel");
}
-
mainGUI.checkModelingSyntax(panel, true);
SimulationTrace file2 = new SimulationTrace("tainting", 6, simulationTracePath);
- latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
- latencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
- latencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
-
- latencyDetailedAnalysis = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
-
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
if (latencyDetailedAnalysis != null) {
latencyDetailedAnalysis.setVisible(false);
-
try {
latencyDetailedAnalysis.getT().join();
} catch (InterruptedException e) {
@@ -74,63 +61,40 @@ public class GraphLatencyAnalysisTainting extends AbstractUITest {
e.printStackTrace();
}
dgt = latencyDetailedAnalysis.getDgraph();
-
}
-
}
@Test
public void parseFile() {
-
assertNotNull(latencyDetailedAnalysis);
-
int graphsize = dgt.getGraphsize();
-
assertTrue(graphsize == 34);
-
checkedDropDown = latencyDetailedAnalysis.getCheckedT();
-
assertTrue(checkedDropDown.size() == 2);
-
- transFile1 = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + simulationTracePath));
-
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + simulationTracePath));
assertTrue(transFile1.size() > 0);
-
for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
-
int id = cT.getValue();
String taskName = cT.getKey();
if (id == operator1ID) {
task1 = taskName;
-
} else if (id == operator2ID) {
task2 = taskName;
-
}
}
-
allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, true, false);
-
assertTrue(allLatencies.length == 1);
-
assertTrue(allLatencies[0][4] == Integer.valueOf(105));
-
minMaxArray = dgt.latencyMinMaxAnalysis(task1, task2, transFile1);
dgt.getRowDetailsMinMax(1);
taskHWByRowDetails = dgt.getTasksByRowMinMax(0);
-
assertTrue(minMaxArray.length > 0);
-
assertTrue(taskHWByRowDetails.length == 12);
taskHWByRowDetails = dgt.getTaskHWByRowDetailsMinMax(0);
assertTrue(taskHWByRowDetails.length == 6);
-
detailedLatency = dgt.getTaskByRowDetails(0);
assertTrue(detailedLatency.length == 12);
-
detailedLatency = dgt.getTaskHWByRowDetails(0);
assertTrue(detailedLatency.length == 3);
-
}
-
}
\ No newline at end of file