From 6574d9a5c6311b14936c9e2e648f189cd2699bd6 Mon Sep 17 00:00:00 2001
From: maysam zoor <maysam_zoor@hotmail.com>
Date: Thu, 25 Feb 2021 09:44:30 +0100
Subject: [PATCH] add new group of traces
---
.../simulation/DependencyGraphTranslator.java | 44 ++++++++++++++++++-
.../tmltranslator/simulation/PlanArrays.java | 43 ++++++++++++++++++
.../JFrameLatencyComparedDetailedPopup.java | 2 +-
.../JFrameLatencyDetailedAnalysis.java | 1 +
.../JFrameLatencyDetailedPopup.java | 2 +-
.../LatencyAnalysisParallelAlgorithms.java | 7 ++-
.../TableRenderer.java | 8 +++-
7 files changed, 102 insertions(+), 5 deletions(-)
diff --git a/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java b/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
index d8730bbbb9..08b2806520 100644
--- a/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
+++ b/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
@@ -153,6 +153,7 @@ public class DependencyGraphTranslator extends SwingWorker {
private Object[][] dataByTask = null;
private Object[][] dataByTaskMinMax = null;
private HashMap<Integer, Vector<SimulationTransaction>> dataByTaskR = new HashMap<Integer, Vector<SimulationTransaction>>();
+ private HashMap<Integer, Vector<SimulationTransaction>> mandatoryOptionalSimT = 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>>>>();
@@ -168,6 +169,7 @@ public class DependencyGraphTranslator extends SwingWorker {
private ArrayList<String> devicesToBeConsidered = new ArrayList<String>();
private Vector<SimulationTransaction> relatedsimTraces = new Vector<SimulationTransaction>();
private Vector<SimulationTransaction> delayDueTosimTraces = new Vector<SimulationTransaction>();
+ private Vector<SimulationTransaction> mandatoryOptional = new Vector<SimulationTransaction>();
private HashMap<String, ArrayList<SimulationTransaction>> relatedsimTraceswithTaint = new HashMap<String, ArrayList<SimulationTransaction>>();
private int nbOfNodes = 0;
private List<String> usedLabels = new ArrayList<String>();
@@ -2063,6 +2065,7 @@ public class DependencyGraphTranslator extends SwingWorker {
dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
dataByTask = null;
relatedsimTraces = new Vector<SimulationTransaction>();
+ mandatoryOptional = new Vector<SimulationTransaction>();
delayDueTosimTraces = new Vector<SimulationTransaction>();
dependencyGraphRelations.setRunnableTimePerDevice(new HashMap<String, ArrayList<ArrayList<Integer>>>());
if (path2 != null && path2.getLength() > 0) {
@@ -2072,7 +2075,7 @@ public class DependencyGraphTranslator extends SwingWorker {
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) {
+ if (pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
}
}
@@ -2720,6 +2723,25 @@ public class DependencyGraphTranslator extends SwingWorker {
dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
+
+ } else if (pathToDestination != null && pathToDestination.getLength() > 0) {
+ mandatoryOptional.add(st);
+
+ ArrayList<Integer> timeValues = new ArrayList<Integer>();
+ timeValues.add(0, Integer.valueOf(st.runnableTime));
+ timeValues.add(1, startTime);
+ String dName = st.deviceName + "_" + st.coreNumber;
+ if (!(st.runnableTime).equals(st.startTime)) {
+ 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);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
+ }
+ }
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
|| (st.deviceName.equals(task1DeviceName) && task1CoreNbr.equals(st.coreNumber))
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
@@ -2757,6 +2779,8 @@ public class DependencyGraphTranslator extends SwingWorker {
dataByTaskR.put(i, relatedsimTraces);
dataBydelayedTasks.put(i, delayDueTosimTraces);
timeDelayedPerRow.put(i, dependencyGraphRelations.getRunnableTimePerDevice());
+ mandatoryOptionalSimT.put(i, mandatoryOptional);
+
// dataByTask[i][5] = list.getModel();
// dataByTask[i][6] = totalTime;
}
@@ -3713,6 +3737,20 @@ public class DependencyGraphTranslator extends SwingWorker {
return dataByTaskRowDetails;
}
+ public String[][] getMandatoryOptionalByRow(int row) {
+ String[][] dataByTaskRowDetails = new String[mandatoryOptionalSimT.get(row).size()][5];
+ int i = 0;
+ for (SimulationTransaction st : mandatoryOptionalSimT.get(row)) {
+ dataByTaskRowDetails[i][0] = st.command;
+ dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
+ dataByTaskRowDetails[i][2] = st.deviceName + "_" + st.coreNumber;
+ dataByTaskRowDetails[i][3] = st.startTime;
+ dataByTaskRowDetails[i][4] = st.endTime;
+ i++;
+ }
+ return dataByTaskRowDetails;
+ }
+
// fill the detailed latency table once a row is selected
public Object[][] getTaskByRowDetailsMinMaxTaint(int row) {
String task12 = (String) dataByTaskMinMax[row][0];
@@ -3775,6 +3813,10 @@ public class DependencyGraphTranslator extends SwingWorker {
return dataByTaskR.get(row);
}
+ public List<SimulationTransaction> getMandatoryOptionalSimTTaks(int row) {
+ return mandatoryOptionalSimT.get(row);
+ }
+
public Vector<SimulationTransaction> getMinMaxTasksByRowTainted(int row) {
int maxStartTime = (int) dataByTaskMinMax[row][1];
int maxEndTime = (int) dataByTaskMinMax[row][3];
diff --git a/src/main/java/tmltranslator/simulation/PlanArrays.java b/src/main/java/tmltranslator/simulation/PlanArrays.java
index b16153a788..06f9906163 100644
--- a/src/main/java/tmltranslator/simulation/PlanArrays.java
+++ b/src/main/java/tmltranslator/simulation/PlanArrays.java
@@ -10,6 +10,7 @@ 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 List<String> mandatoryOptional = new ArrayList<String>();
private static final String ZERO = "0";
private static final String DEVICE_NAME = "Device Name";
private String[] columnNames;
@@ -38,6 +39,23 @@ public class PlanArrays {
deviceNames1.add(deviceNameandcore);
}
}
+ for (SimulationTransaction st : dgraph.getMandatoryOptionalSimTTaks(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) {
@@ -85,6 +103,26 @@ public class PlanArrays {
}
}
}
+ for (SimulationTransaction st : dgraph.getMandatoryOptionalSimTTaks(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);
+ ;
+ mandatoryOptional.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);
@@ -308,4 +346,9 @@ public class PlanArrays {
public String[] getColumnNames() {
return columnNames;
}
+
+ public List<String> getMandatoryOptional() {
+ return mandatoryOptional;
+ }
+
}
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
index 05e6f2cf21..91a9834ffb 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
@@ -560,7 +560,7 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
table.setFillsViewportHeight(true);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setAutoCreateRowSorter(true);
- TableRenderer tr = new TableRenderer(onPathBehavior, offPathBehaviorCausingDelay, offPathBehavior);
+ TableRenderer tr = new TableRenderer(onPathBehavior, offPathBehaviorCausingDelay, offPathBehavior,offPathBehavior);
int ncols = table.getColumnCount();
table.getModel().addTableModelListener(this);
TableColumnModel tcm = table.getColumnModel();
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
index 1e8d5948c8..58633d849e 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
@@ -511,6 +511,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
protected void generateDirectedGraph(TMLMapping<TGComponent> tmap, List<TMLComponentDesignPanel> cpanels) {
try {
dgraph = new DependencyGraphTranslator(tmap);
+ tc.setDgraph(dgraph);
pbar.setMaximum(dgraph.getNodeNbProgressBar());
pbar.setMinimum(0);
dgraph.addPropertyChangeListener(new PropertyChangeListener() {
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
index 3cda41c3b4..5433179ad8 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
@@ -229,7 +229,7 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
table.setFillsViewportHeight(true);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setAutoCreateRowSorter(true);
- TableRenderer tr = new TableRenderer(arrays.getOnPathBehavior(), arrays.getOffPathBehaviorCausingDelay(), arrays.getOffPathBehavior());
+ TableRenderer tr = new TableRenderer(arrays.getOnPathBehavior(), arrays.getOffPathBehaviorCausingDelay(), arrays.getOffPathBehavior(),arrays.getMandatoryOptional());
int ncols = table.getColumnCount();
table.getModel().addTableModelListener(this);
TableColumnModel tcm = table.getColumnModel();
diff --git a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
index e59cb0cdcc..7018f4cbc3 100644
--- a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
+++ b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
@@ -25,7 +25,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
private List<TMLComponentDesignPanel> cpanels;
private DependencyGraphTranslator dgraph, dgraph1, dgraph2;
private int row, row1, row2, row3, row4, selectedIndex;
- private Object[][] dataDetailedByTask, dataDetailedByTask2;
+ private Object[][] dataDetailedByTask, dataDetailedByTask2, dataMandatoryOptional;
private LatencyDetailedAnalysisMain main;
private MainGUI mainGUI;
private SimulationTrace selectedST;
@@ -45,6 +45,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
jFrameLDA.generateDirectedGraph(tmap, cpanels);
} else if (algorithmId == 2) {
dataDetailedByTask = dgraph.getTaskByRowDetails(row);
+ dataMandatoryOptional = dgraph.getMandatoryOptionalByRow(row);
} else if (algorithmId == 3) {
dataDetailedByTask = dgraph.getTaskByRowDetailsMinMaxTaint(row);
} else if (algorithmId == 4) {
@@ -222,6 +223,10 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
this.dgraph1 = dgraph1;
}
+ public Object[][] getDataMandatoryOptional() {
+ return dataMandatoryOptional;
+ }
+
public void latencyDetailedAnalysis(JFrameCompareLatencyDetail jFrameCompareLatencyDetail, String task12, String task22, String task32,
String task42, Vector<SimulationTransaction> transFile12, Vector<SimulationTransaction> transFile22) {
cld = jFrameCompareLatencyDetail;
diff --git a/src/main/java/ui/simulationtraceanalysis/TableRenderer.java b/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
index 407d06889b..9168a37280 100644
--- a/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
+++ b/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
@@ -17,14 +17,16 @@ class TableRenderer extends DefaultTableCellRenderer {
private List<String> onPathBehaviors = new Vector<String>();
private List<String> offPathBehaviors = new Vector<String>();
private List<String> offPathBehaviorCausingDelay = new Vector<String>();
+ private List<String> mandatoryOptionalByRow = new Vector<String>();
- public TableRenderer(List<String> onPathBehavior, List<String> offPathBehaviorCausingDelay, List<String> offPathBehavior) {
+ public TableRenderer(List<String> onPathBehavior, List<String> offPathBehaviorCausingDelay, List<String> offPathBehavior,List<String> mandatoryOptionalByRow) {
this.onPathBehaviors = new Vector<String>();
this.offPathBehaviorCausingDelay = new Vector<String>();
this.offPathBehaviors = new Vector<String>();
this.onPathBehaviors = onPathBehavior;
this.offPathBehaviorCausingDelay = offPathBehaviorCausingDelay;
this.offPathBehaviors = offPathBehavior;
+ this.mandatoryOptionalByRow=mandatoryOptionalByRow;
}
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
@@ -45,6 +47,10 @@ class TableRenderer extends DefaultTableCellRenderer {
randomColour = Color.orange;
// randomColour = Color.red;
}
+ else if (mandatoryOptionalByRow.contains(value.toString() + table.getColumnName(column))) {
+ randomColour = Color.LIGHT_GRAY;
+ // randomColour = Color.red;
+ }
} else {
this.colorCell = false;
}
--
GitLab