diff --git a/src/main/java/cli/Interpreter.java b/src/main/java/cli/Interpreter.java
index 991d47d615cc16cac60586fdba8895fd0eacdc53..36ca96a432fd1a2dd755a02362712191fa8a96ea 100644
--- a/src/main/java/cli/Interpreter.java
+++ b/src/main/java/cli/Interpreter.java
@@ -58,7 +58,7 @@ import java.util.Vector;
*/
public class Interpreter implements Runnable, TerminalProviderInterface {
- public final static Command[] commands = {new Action(), new Help(), new History(), new Print(), new PluginAction(), new Quit(),
+ public final static Command[] commands = {new Action(), new Help(), new History(), new Print(), new Plan(), new PluginAction(), new Quit(),
new TestSpecific(), new TML(), new Set(), new Wait(), new Robot(), new BF(), new SimulatorScript()};
// Errors
diff --git a/src/main/java/cli/Plan.java b/src/main/java/cli/Plan.java
new file mode 100644
index 0000000000000000000000000000000000000000..59f774e5a1e6df29ca1dbfbfcf528c6ebc278539
--- /dev/null
+++ b/src/main/java/cli/Plan.java
@@ -0,0 +1,417 @@
+/* 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 cli;
+
+import common.ConfigurationTTool;
+import common.SpecConfigTTool;
+import launcher.RTLLauncher;
+import myutil.FileUtils;
+import myutil.PluginManager;
+import myutil.TraceManager;
+import tmltranslator.*;
+import tmltranslator.dsez3engine.InputInstance;
+import tmltranslator.dsez3engine.OptimizationModel;
+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
+ *
+ * @author Ludovic APVRILLE
+ */
+public class Plan extends Command {
+ private final static String TABS = "tabs";
+
+ private TMLModeling tmlm;
+ private TMLMapping tmlmap;
+ private static Object[][] allLatencies, minMaxArray, taskHWByRowDetails, detailedLatency;
+ private HashMap<String, Integer> checkedT = new HashMap<String, Integer>();
+ private Vector<SimulationTransaction> transFile1;
+ private latencyDetailedAnalysisMain latencyDetailedAnalysisMain;
+ private DirectedGraphTranslator dgt;
+ private String traceFile;
+ private Boolean taint;
+
+ private OptimizationResult result;
+
+ public Plan() {
+
+ }
+
+ public List<Command> getListOfSubCommands() {
+ return subcommands;
+ }
+
+ public String getCommand() {
+ return "plan";
+ }
+
+ public String getShortCommand() {
+ return "plan";
+ }
+
+ public String getUsage() {
+ return "plan <subcommand>";
+ }
+
+ public String getDescription() {
+ return "Can be used to compute Latency";
+ }
+
+ public void fillSubCommands() {
+ Command graph = new Command() {
+ public String getCommand() {
+ return "graph";
+ }
+
+ public String getShortCommand() {
+ return "g";
+ }
+
+ public String getDescription() {
+ return "generate graph to use in latency computation";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return generateGraph(command, interpreter);
+ }
+ };
+
+ Command latency = new Command() {
+ public String getCommand() {
+ return "latency";
+ }
+
+ public String getShortCommand() {
+ return "lat";
+ }
+
+ public String getDescription() {
+ return "compute latency between two operators";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return computeLat(command, interpreter);
+ }
+
+ };
+
+ Command listAllOp = new Command() {
+ public String getCommand() {
+ return "listAllOp";
+ }
+
+ public String getShortCommand() {
+ return "lao";
+ }
+
+ public String getDescription() {
+ return "List all operators Id that can be used for latency analysis";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return listAllOperators(command, interpreter);
+ }
+
+ };
+
+ Command preciseLatByRow = new Command() {
+ public String getCommand() {
+ return "planByRow";
+ }
+
+ public String getShortCommand() {
+ return "planR";
+ }
+
+ public String getDescription() {
+ return "precise Latency analysis by row";
+ }
+
+ public String executeCommand(String command, Interpreter interpreter) {
+ // interpreter.print("Command=" + command);
+ return preciseLatByRow(command, interpreter);
+ }
+
+ };
+ addAndSortSubcommand(graph);
+ addAndSortSubcommand(latency);
+ addAndSortSubcommand(listAllOp);
+ addAndSortSubcommand(preciseLatByRow);
+
+ }
+
+ private String generateGraph(String command, Interpreter interpreter) {
+
+ JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
+
+ String[] commands = command.split(" ");
+
+ traceFile = commands[0];
+ String mappingDiagName = commands[1];
+
+ SimulationTrace file2 = new SimulationTrace("graphTestSimulationTrace", 6, traceFile);
+
+ MainGUI mgui = interpreter.mgui;
+ interpreter.print("file2=" + file2.toString());
+
+ TMLArchiPanel panel = null;
+
+ for (final TMLArchiPanel panel1 : mgui.getTMLArchiDiagramPanels()) {
+ if (mappingDiagName.equals(mgui.getTitleAt(panel1))) {
+ panel = panel1;
+ }
+ }
+
+ try {
+ mgui.checkModelingSyntax(panel, true);
+
+ latencyDetailedAnalysisMain = new latencyDetailedAnalysisMain(3, mgui, file2, false, false, 3);
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ return ("Exception during file loading: " + e.getMessage());
+ }
+
+ latencyDetailedAnalysisMain.getTc().setMainGUI(mgui);
+
+ // latencyDetailedAnalysisMain.setTc();
+
+ interpreter.print("panel=" + panel);
+
+ latencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mgui);
+
+ latencyDetailedAnalysis = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+
+ if (latencyDetailedAnalysis != null) {
+ latencyDetailedAnalysis.setVisible(false);
+ try {
+ latencyDetailedAnalysis.getT().join();
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ // if (latencyDetailedAnalysis.graphStatus() == Thread.State.TERMINATED) {
+ dgt = latencyDetailedAnalysis.getDgraph();
+
+ interpreter.print("graph=" + dgt.getGraphsize());
+
+ TMLActivity activity;
+
+ for (TMLTask tmltask : latencyDetailedAnalysis.getTmap1().getTMLModeling().getTasks()) {
+
+ int opCount = 0;
+
+ activity = tmltask.getActivityDiagram();
+ TMLActivityDiagramPanel tadp = (TMLActivityDiagramPanel) (activity.getReferenceObject());
+ List<TGComponent> list = tadp.getComponentList();
+ Iterator<TGComponent> iterator = list.listIterator();
+ TGComponent tgc;
+ opCount = 0;
+
+ iterator = list.listIterator();
+ while (iterator.hasNext()) {
+ tgc = iterator.next();
+ String compName = "";
+ if (tgc.isEnabled()) {
+ if (tgc instanceof CheckableLatency) {
+
+ compName = tmltask.getName() + ":" + tgc.getName();
+ compName = compName.replaceAll(" ", "");
+
+ if (tgc.getValue().contains("(")) {
+ compName = compName + ":" + tgc.getValue().split("\\(")[0];
+ } else {
+ if (tgc instanceof TMLADExecI) {
+ compName = ((TMLADExecI) tgc).getDelayValue();
+ }
+ }
+ checkedT.put(compName + "__" + tgc.getDIPLOID(), tgc.getDIPLOID());
+
+ }
+ }
+
+ }
+
+ }
+
+ return null;
+ }
+ return mappingDiagName;
+ }
+
+ 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]);
+ int operator2ID = Integer.valueOf(commands[1]);
+ taint = Boolean.parseBoolean(commands[2]);
+ String filename = commands[3];
+
+ 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;
+
+ }
+ }
+
+ transFile1 = latencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(traceFile));
+
+ allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, taint, false);
+
+ interpreter.print("lat=" + allLatencies.length);
+
+ if (taint) {
+
+ minMaxArray = dgt.latencyMinMaxAnalysisTaintedData(task1, task2, transFile1);
+ } else {
+
+ minMaxArray = dgt.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);
+
+ dgt.saveLAtencyValuesToXML(filename);
+
+ return null;
+ }
+
+ private String listAllOperators(String command, Interpreter interpreter) {
+
+ String allop = "";
+ for (Entry<String, Integer> cT : checkedT.entrySet()) {
+
+ int id = cT.getValue();
+
+ allop = allop.concat(id + " ");
+ }
+
+ interpreter.print(allop);
+
+ return null;
+ }
+
+ private String preciseLatByRow(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 id = Integer.valueOf(i);
+ if (!minmax) {
+
+ // detailedLatency = dgt.getTaskByRowDetails(id);
+
+ // interpreter.print("detailedLatency.length=" + detailedLatency.length);
+
+ // detailedLatency = dgt.getTaskHWByRowDetails(id);
+
+ // interpreter.print("detailedLatency.length=" + detailedLatency.length);
+
+ try {
+ new JFrameLatencyDetailedPopup(dgt, id, true, taint, latencyDetailedAnalysisMain.getTc(), false);
+ interpreter.print("dgt.getOffPathBehavior=" + dgt.getOffPath().size());
+ interpreter.print("dgt.getOffPathBehaviorCausingDelay=" + dgt.getOffPathDelay().size());
+ interpreter.print("dgt.getOnPath=" + dgt.getOnPath().size());
+ dgt.saveDetailsToXML(filename);
+
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ } else {
+ try {
+ new JFrameLatencyDetailedPopup(dgt, id, false, taint, latencyDetailedAnalysisMain.getTc(), false);
+ interpreter.print("dgt.getOffPathBehavior=" + dgt.getOffPath().size());
+ interpreter.print("dgt.getOffPathBehaviorCausingDelay=" + dgt.getOffPathDelay().size());
+ interpreter.print("dgt.getOnPath=" + dgt.getOnPath().size());
+ dgt.saveDetailsToXML(filename);
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ }
+
+ return null;
+ }
+}
diff --git a/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java b/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java
index a211a10cf4d89f76f4af96f659ca0851921d39a6..a2db77556538446bd010227dc2cb7cb6bd5debd2 100644
--- a/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java
+++ b/src/main/java/ui/simulationtraceanalysis/DirectedGraphTranslator.java
@@ -52,6 +52,10 @@ import org.jgrapht.ext.JGraphXAdapter;
import org.jgrapht.graph.DefaultDirectedGraph;
import org.jgrapht.graph.DefaultEdge;
import org.jgrapht.io.*;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
import tmltranslator.*;
import tmltranslator.tomappingsystemc2.DiploSimulatorCodeGenerator;
import ui.TGComponent;
@@ -66,6 +70,21 @@ 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.*;
@@ -196,6 +215,7 @@ public class DirectedGraphTranslator extends JApplet {
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;
@@ -207,6 +227,10 @@ public class DirectedGraphTranslator extends JApplet {
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>();
+
@SuppressWarnings("deprecation")
public DirectedGraphTranslator(JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis, JFrameCompareLatencyDetail jframeCompareLatencyDetail,
TMLMapping<TGComponent> tmap1, List<TMLComponentDesignPanel> cpanels1, int i) {
@@ -346,6 +370,8 @@ public class DirectedGraphTranslator extends JApplet {
}
+
+
private void addCPUs() {
// TODO Auto-generated method stub
HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
@@ -358,8 +384,9 @@ public class DirectedGraphTranslator extends JApplet {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
-
- cpuTasks = getCPUTaskMap(cpuTask);
+ if (cpuTask.size() > 0) {
+ cpuTasks = getCPUTaskMap(cpuTask);
+ }
}
@@ -497,8 +524,9 @@ public class DirectedGraphTranslator extends JApplet {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
-
- cpuTasks = getCPUTaskMap(cpuTask);
+ if (cpuTask.size() > 0) {
+ cpuTasks = getCPUTaskMap(cpuTask);
+ }
}
@@ -1688,14 +1716,13 @@ public class DirectedGraphTranslator extends JApplet {
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();
+ for (TMLWaitEvent wait_sendEvent : destinationTasks.getWaitEvents()) {
+ String receivePortparams = wait_sendEvent.getAllParams();
- sendEvt.get("sendevent:" + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")")
- .add("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")");
+ sendEvt.get("sendevent:" + sendingPortdetails.getPortName() + "(" + sendingPortparams + ")")
+ .add("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")");
- }
+ }
}
}
@@ -3595,8 +3622,8 @@ public class DirectedGraphTranslator extends JApplet {
for (SimulationTransaction st : relatedsimTraceswithTaint.get(labeli)) {
- if (!(Integer.valueOf(st.startTime) < s1 && Integer.valueOf(st.endTime) < s1)
- && !(Integer.valueOf(st.startTime) > s2 && Integer.valueOf(st.endTime) > s2)) {
+ if (!(Integer.valueOf(st.startTime) < s1 && Integer.valueOf(st.endTime) <= s1)
+ && !(Integer.valueOf(st.startTime) >= s2 && Integer.valueOf(st.endTime) > s2)) {
// if (Integer.valueOf(st.startTime) >= minTime && Integer.valueOf(st.startTime)
// < maxTime) {
@@ -3606,7 +3633,7 @@ public class DirectedGraphTranslator extends JApplet {
st.length = Integer.valueOf(Integer.valueOf(s2) - Integer.valueOf(st.startTime)).toString();
}
- if (Integer.valueOf(st.startTime) < s1) {
+ if (Integer.valueOf(st.startTime) < s1 && Integer.valueOf(st.endTime) != s1) {
st.startTime = Integer.valueOf(s1).toString();
st.length = Integer.valueOf(Integer.valueOf(st.endTime) - Integer.valueOf(s1)).toString();
}
@@ -3636,8 +3663,8 @@ public class DirectedGraphTranslator extends JApplet {
for (SimulationTransaction st : delayDueTosimTraces) {
- if (!(Integer.valueOf(st.startTime) < times1.get(row) && Integer.valueOf(st.endTime) < times1.get(row))
- && !(Integer.valueOf(st.startTime) > times2.get(row) && Integer.valueOf(st.endTime) > times2.get(row))) {
+ if (!(Integer.valueOf(st.startTime) < times1.get(row) && Integer.valueOf(st.endTime) <= times1.get(row))
+ && !(Integer.valueOf(st.startTime) >= times2.get(row) && Integer.valueOf(st.endTime) > times2.get(row))) {
// if (Integer.valueOf(st.startTime) >= minTime && Integer.valueOf(st.startTime)
// < maxTime) {
@@ -3900,6 +3927,289 @@ public class DirectedGraphTranslator extends JApplet {
}
+ public void saveDetailsToXML(String outputFile) {
+
+ DocumentBuilder builder;
+ try {
+ builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+
+ Document dom = builder.newDocument();
+
+ Element root2 = dom.createElement("Transactions");
+ dom.appendChild(root2); // write DOM to XML file
+
+ Element root1 = dom.createElement("Mandatory");
+ root2.appendChild(root1); // write DOM to XML file
+
+ for (int i = 0; i < onPath.size(); i++) {
+
+ SimulationTransaction st = onPath.get(i);
+
+ // first create root element
+ Element root = dom.createElement("st");
+ root1.appendChild(root);
+
+ // set `id` attribute to root element
+ Attr attr = dom.createAttribute("id");
+ attr.setValue(st.id);
+ root.setAttributeNode(attr);
+
+ // now create child elements (name, email, phone)
+ Element operator = dom.createElement("operator");
+ operator.setTextContent(st.command);
+ Element start = dom.createElement("starttime");
+ start.setTextContent(st.startTime);
+ Element et = dom.createElement("endtime");
+ et.setTextContent(st.endTime);
+ Element l = dom.createElement("length");
+ l.setTextContent(st.length);
+
+ // add child nodes to root node
+ root.appendChild(operator);
+ root.appendChild(start);
+ root.appendChild(et);
+ root.appendChild(l);
+
+ }
+
+ Element root3 = dom.createElement("NoContention");
+ root2.appendChild(root3); // write DOM to XML file
+
+ for (int i = 0; i < offPath.size(); i++) {
+
+ SimulationTransaction st = offPath.get(i);
+
+ // first create root element
+ Element root5 = dom.createElement("st");
+ root3.appendChild(root5);
+
+ // set `id` attribute to root element
+ Attr attr = dom.createAttribute("id");
+ attr.setValue(st.id);
+ root5.setAttributeNode(attr);
+
+ // now create child elements (name, email, phone)
+ Element operator = dom.createElement("operator");
+ operator.setTextContent(st.command);
+ Element start = dom.createElement("starttime");
+ start.setTextContent(st.startTime);
+ Element et = dom.createElement("endtime");
+ et.setTextContent(st.endTime);
+ Element l = dom.createElement("length");
+ l.setTextContent(st.length);
+
+ // add child nodes to root node
+ root5.appendChild(operator);
+ root5.appendChild(start);
+ root5.appendChild(et);
+ root5.appendChild(l);
+
+ }
+
+ Element root4 = dom.createElement("Contention");
+ root2.appendChild(root4); // write DOM to XML file
+
+ for (int i = 0; i < offPathDelay.size(); i++) {
+
+ SimulationTransaction st = offPathDelay.get(i);
+
+ // first create root element
+ Element root6 = dom.createElement("st");
+ root4.appendChild(root6);
+
+ // set `id` attribute to root element
+ Attr attr = dom.createAttribute("id");
+ attr.setValue(st.id);
+ root6.setAttributeNode(attr);
+
+ // now create child elements (name, email, phone)
+ Element operator = dom.createElement("operator");
+ operator.setTextContent(st.command);
+ Element start = dom.createElement("starttime");
+ start.setTextContent(st.startTime);
+ Element et = dom.createElement("endtime");
+ et.setTextContent(st.endTime);
+ Element l = dom.createElement("length");
+ l.setTextContent(st.length);
+
+ // add child nodes to root node
+ root6.appendChild(operator);
+ root6.appendChild(start);
+ root6.appendChild(et);
+ root6.appendChild(l);
+
+ }
+ Transformer tr;
+ try {
+ tr = TransformerFactory.newInstance().newTransformer();
+ tr.setOutputProperty(OutputKeys.INDENT, "yes");
+ try {
+ tr.transform(new DOMSource(dom), new StreamResult(new File(outputFile)));
+ } catch (TransformerException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ } catch (TransformerConfigurationException | TransformerFactoryConfigurationError e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ } catch (ParserConfigurationException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ }
+
+ public void saveLAtencyValuesToXML(String outputFile) {
+
+ DocumentBuilder builder;
+ try {
+ builder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
+
+ Document dom = builder.newDocument();
+
+ Element root1 = dom.createElement("LatencyTable");
+ dom.appendChild(root1);
+
+ for (int id = 0; id < dataByTask.length; id++) {
+
+ String starttime = String.valueOf(dataByTask[id][1]);
+ String endtime = String.valueOf(dataByTask[id][3]);
+ String latency = String.valueOf(dataByTask[id][4]);
+
+ String op1 = String.valueOf(dataByTask[id][0]);
+ String op2 = String.valueOf(dataByTask[id][2]);
+
+ // first create root element
+ Element root = dom.createElement("Row");
+ root1.appendChild(root);
+
+ // set `id` attribute to root element
+ Attr attr = dom.createAttribute("id");
+ attr.setValue(String.valueOf(id));
+ root.setAttributeNode(attr);
+
+ // now create child elements (name, email, phone)
+ Element operator1 = dom.createElement("op1");
+ operator1.setTextContent(op1);
+ Element operator2 = dom.createElement("op2");
+ operator2.setTextContent(op2);
+ Element st = dom.createElement("starttime");
+ st.setTextContent(starttime);
+ Element et = dom.createElement("endtime");
+ et.setTextContent(endtime);
+ Element lat = dom.createElement("latency");
+ lat.setTextContent(latency);
+
+ // add child nodes to root node
+ root.appendChild(operator1);
+ root.appendChild(st);
+ root.appendChild(operator2);
+ root.appendChild(et);
+ root.appendChild(lat);
+
+ }
+
+ // for (int id = 0; id < dataByTaskMinMax.length; id++) {
+
+ String starttime = String.valueOf(dataByTaskMinMax[0][1]);
+ String endtime = String.valueOf(dataByTaskMinMax[0][3]);
+ String latency = String.valueOf(dataByTaskMinMax[0][4]);
+
+ String op1 = String.valueOf(dataByTaskMinMax[0][0]);
+ String op2 = String.valueOf(dataByTaskMinMax[0][2]);
+
+ // first create root element
+ Element root = dom.createElement("Min");
+ root1.appendChild(root);
+
+ // set `id` attribute to root element
+ // Attr attr = dom.createAttribute("id");
+ // attr.setValue(String.valueOf(0));
+ // root.setAttributeNode(attr);
+
+ // now create child elements (name, email, phone)
+ Element operator1 = dom.createElement("op1");
+ operator1.setTextContent(op1);
+ Element operator2 = dom.createElement("op2");
+ operator2.setTextContent(op2);
+ Element st = dom.createElement("starttime");
+ st.setTextContent(starttime);
+ Element et = dom.createElement("endtime");
+ et.setTextContent(endtime);
+ Element lat = dom.createElement("latency");
+ lat.setTextContent(latency);
+
+ // add child nodes to root node
+ root.appendChild(operator1);
+ root.appendChild(st);
+ root.appendChild(operator2);
+ root.appendChild(et);
+ root.appendChild(lat);
+
+ String starttimeMax = String.valueOf(dataByTaskMinMax[1][1]);
+ String endtimeMax = String.valueOf(dataByTaskMinMax[1][3]);
+ String latencyMax = String.valueOf(dataByTaskMinMax[1][4]);
+
+ String op1Max = String.valueOf(dataByTaskMinMax[1][0]);
+ String op2Max = String.valueOf(dataByTaskMinMax[1][2]);
+
+ // first create root element
+ Element rootMax = dom.createElement("Max");
+ root1.appendChild(rootMax);
+
+ // set `id` attribute to root element
+ // Attr attrMax = dom.createAttribute("id");
+ // attrMax.setValue(String.valueOf(1));
+ // root1.setAttributeNode(attrMax);
+
+ // now create child elements
+ Element operator1Max = dom.createElement("op1");
+ operator1Max.setTextContent(op1Max);
+ Element operator2Max = dom.createElement("op2");
+ operator2Max.setTextContent(op2Max);
+ Element stMax = dom.createElement("starttime");
+ stMax.setTextContent(starttimeMax);
+ Element etMax = dom.createElement("endtime");
+ etMax.setTextContent(endtimeMax);
+ Element latMax = dom.createElement("latency");
+ latMax.setTextContent(latencyMax);
+
+ // add child nodes to root node
+ rootMax.appendChild(operator1Max);
+ rootMax.appendChild(stMax);
+ rootMax.appendChild(operator2Max);
+ rootMax.appendChild(etMax);
+ rootMax.appendChild(latMax);
+
+ // }
+
+ // write DOM to XML file
+ Transformer tr;
+ try {
+ tr = TransformerFactory.newInstance().newTransformer();
+ tr.setOutputProperty(OutputKeys.INDENT, "yes");
+ try {
+ tr.transform(new DOMSource(dom), new StreamResult(new File(outputFile)));
+ } catch (TransformerException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ } catch (TransformerConfigurationException | TransformerFactoryConfigurationError e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ } catch (ParserConfigurationException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ }
+
private String getfirstCommonLabel(vertex vertex, vertex v) {
for (int i = 0; i < v.getLabel().size(); i++) {
@@ -5702,4 +6012,28 @@ public class DirectedGraphTranslator extends JApplet {
return warnings;
}
+ public List<SimulationTransaction> getOnPath() {
+ return onPath;
+ }
+
+ public void setOnPath(List<SimulationTransaction> onPath) {
+ this.onPath = onPath;
+ }
+
+ public List<SimulationTransaction> getOffPath() {
+ return offPath;
+ }
+
+ public void setOffPath(List<SimulationTransaction> offPath) {
+ this.offPath = offPath;
+ }
+
+ public List<SimulationTransaction> getOffPathDelay() {
+ return offPathDelay;
+ }
+
+ public void setOffPathDelay(List<SimulationTransaction> offPathDelay) {
+ this.offPathDelay = offPathDelay;
+ }
+
}
\ No newline at end of file
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
index 1afdddeb66381445445b0efe2d7205dbe1d8356e..758a1458cae5fde71bfbc304305fa8f14aa43745 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
@@ -1034,8 +1034,8 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
ComboBoxModel<String> aModel1 = new DefaultComboBoxModel<String>(checkedTransactions);
tasksDropDownCombo2.setModel(aModel1);
- tasksDropDownCombo1.setModel(getAlloperators((String) tasksDropDownCombo6.getItemAt(0)));
- tasksDropDownCombo2.setModel(getAlloperators((String) tasksDropDownCombo7.getItemAt(0)));
+ tasksDropDownCombo1.setModel(getAlloperators(tasksDropDownCombo6.getItemAt(0)));
+ tasksDropDownCombo2.setModel(getAlloperators(tasksDropDownCombo7.getItemAt(0)));
// ComboBoxModel<String> aModel2 = new
// DefaultComboBoxModel<String>(checkedTransactions);
@@ -1080,17 +1080,17 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
} else if (command.equals(actions[LatencyDetailedAnalysisActions.ACT_LOAD_ALL_OP].getActionCommand())) {
- tasksDropDownCombo1.setModel(getAlloperators((String) tasksDropDownCombo6.getSelectedItem()));
+ tasksDropDownCombo1.setModel(getAlloperators(tasksDropDownCombo6.getSelectedItem()));
} else if (command.equals(actions[LatencyDetailedAnalysisActions.ACT_LOAD_ALL_OP2].getActionCommand())) {
- tasksDropDownCombo2.setModel(getAlloperators((String) tasksDropDownCombo7.getSelectedItem()));
+ tasksDropDownCombo2.setModel(getAlloperators(tasksDropDownCombo7.getSelectedItem()));
}
}
- private ComboBoxModel<String> getAlloperators(String dropdown) {
+ private ComboBoxModel<String> getAlloperators(Object object) {
TMLActivity activity;
checkedTransactions = new Vector<String>();
@@ -1101,7 +1101,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
int opCount = 0;
- if (tmltask.getName().equals(dropdown)) {
+ if (tmltask.getName().equals(object)) {
activity = tmltask.getActivityDiagram();
TMLActivityDiagramPanel tadp = (TMLActivityDiagramPanel) (activity.getReferenceObject());
@@ -1188,7 +1188,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
if (row >= 0) {
try {
- new JFrameLatencyDetailedPopup(dgraph, row, true, taint, tc);
+ new JFrameLatencyDetailedPopup(dgraph, row, true, taint, tc,true);
} catch (Exception e) {
jta.append("An error has occurred \n");
jta.append(e.getMessage() + "\n");
@@ -1201,7 +1201,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
row = table12.getSelectedRow();
if (row >= 0) {
try {
- new JFrameLatencyDetailedPopup(dgraph, row, false, taint, tc);
+ new JFrameLatencyDetailedPopup(dgraph, row, false, taint, tc,true);
} catch (Exception e) {
jta.append("An error has occurred \n");
jta.append(e.getMessage() + "\n");
@@ -1484,4 +1484,8 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
return checkedT;
}
+ public TMLMapping<TGComponent> getTmap1() {
+ return tmap1;
+ }
+
}
\ No newline at end of file
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
index 797aa43fda13752599e5f49af1562582d694a8f5..a05b0706ea3a7c30ac4580e7a6245cac61474172 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
@@ -84,7 +84,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
private Object[][] dataHWDelayByTask;
public JFrameLatencyDetailedPopup(DirectedGraphTranslator dgraph, int row, boolean firstTable, Boolean taint,
- LatencyAnalysisParallelAlgorithms th) throws InterruptedException {
+ LatencyAnalysisParallelAlgorithms th, boolean visible) throws InterruptedException {
super("Precise Latency By Row");
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
@@ -164,7 +164,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
taskNames.setAutoCreateRowSorter(true);
scrollPane12 = new JScrollPane(taskNames, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
- scrollPane12.setVisible(true);
+ scrollPane12.setVisible(visible);
this.add(scrollPane12);
@@ -241,7 +241,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
scrollPane13 = new JScrollPane(hardwareNames, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
- scrollPane13.setVisible(true);
+ scrollPane13.setVisible(visible);
this.add(scrollPane13);
int maxTime = -1;
@@ -293,12 +293,11 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
}
- int timeInterval=0;
- if (maxTime>-1 && minTime<Integer.MAX_VALUE )
- {
+ int timeInterval = 0;
+ if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
timeInterval = (maxTime - minTime);
- }
-
+ }
+
columnNames = new String[timeInterval + 1];
columnNames[0] = "Device Name";
@@ -325,8 +324,12 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
;
onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ if (!dgraph.getOnPath().contains(st)) {
+ dgraph.getOnPath().add(st);
+ }
}
+
}
}
@@ -375,8 +378,15 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
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);
+ }
}
}
@@ -488,13 +498,11 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
}
}
- int timeInterval=0;
- if (maxTime>-1 && minTime<Integer.MAX_VALUE )
- {
+ int timeInterval = 0;
+ if (maxTime > -1 && minTime < Integer.MAX_VALUE) {
timeInterval = (maxTime - minTime);
- }
-
-
+ }
+
columnNames = new String[timeInterval + 1];
columnNames[0] = "Device Name";
@@ -521,7 +529,9 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
;
onPathBehavior.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
-
+ if (!dgraph.getOnPath().contains(st)) {
+ dgraph.getOnPath().add(st);
+ }
}
}
@@ -571,8 +581,16 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
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);
+ }
}
}
@@ -649,11 +667,11 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
}
scrollPane14 = new JScrollPane(table, JScrollPane.VERTICAL_SCROLLBAR_ALWAYS, JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
- scrollPane14.setVisible(true);
+ scrollPane14.setVisible(visible);
this.add(scrollPane14);
this.pack();
- this.setVisible(true);
+ this.setVisible(visible);
// TODO Auto-generated constructor stub
}