Newer
Older
/* 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.
*/
import com.mxgraph.layout.hierarchical.mxHierarchicalLayout;
import com.mxgraph.swing.mxGraphComponent;
import org.jgrapht.Graph;
import org.jgrapht.GraphPath;
import org.jgrapht.alg.shortestpath.AllDirectedPaths;
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 tmltranslator.*;
import tmltranslator.tomappingsystemc2.DiploSimulatorCodeGenerator;
import ui.TGComponent;
import ui.TGConnectingPoint;
import ui.TGConnector;
import ui.TMLComponentDesignPanel;
import ui.interactivesimulation.SimulationTransaction;
import ui.tmlcompd.TMLCPrimitivePort;
import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;
import java.util.*;
import java.util.List;
import java.util.Map.Entry;
/**
* Class DirectedGraphTranslator: this class generate the directed graph
* equivalent for the sysml model
* 23/09/2019
*
* @author Maysam Zoor
*/
public class DirectedGraphTranslator extends JApplet {
// private TMLArchiPanel tmlap; // USed to retrieve the currently opened
// architecture panel
// private TMLMapping<TGComponent> tmap;
private TMLTask task, task1, task2;
protected TMLActivity activity;
int nodeNbProgressBar = 0;
int nodeNb = 0;
// List<HwNode> path;
private TMLActivityElement currentElement;
private TMLActivityElement backwardElement;
private ArrayList<String> SummaryCommMapping;
private Graph<String, DefaultEdge> g;
public Graph<String, DefaultEdge> getG() {
return g;
}
public void setG(Graph<String, DefaultEdge> g) {
this.g = g;
}
private static final Dimension DEFAULT_SIZE = new Dimension(530, 320);
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>> 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();
// List<String,String> = new ArrayList<String,String>();
private final HashMap<String, String> nameIDTaskList = new HashMap<String, String>();
private final HashMap<String, ArrayList<String>> channelPaths = new HashMap<String, ArrayList<String>>();
public HashMap<String, String> getNameIDTaskList() {
return nameIDTaskList;
}
public JScrollPane getScrollPane() {
return scrollPane;
}
public static void setScrollPane(JScrollPane scrollPane) {
DirectedGraphTranslator.scrollPane = scrollPane;
}
private Object[][] dataByTask = null;
private Object[][] dataByTaskMinMax = null;
private Object[][] dataByTaskBYRow;
private Object[][] dataByTaskHWBYRow;
HashMap<Integer, List<SimulationTransaction>> dataByTaskR = new HashMap<Integer, List<SimulationTransaction>>();
HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRow = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
HashMap<Integer, List<String>> detailsOfMinMaxRow = new HashMap<Integer, List<String>>();
HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasksOfMinMAx = new HashMap<Integer, List<SimulationTransaction>>();
private final JFrame frame = new JFrame("The Sys-ML Model As Directed Graph");
List<Integer> times1 = new ArrayList<Integer>();
List<Integer> times2 = new ArrayList<Integer>();
Vector<SimulationTransaction> transFile;
String idTask1;
String idTask2;
String task2DeviceName = "";
String task1DeviceName = "";
ArrayList<String> devicesToBeConsidered = new ArrayList<String>();
Vector<SimulationTransaction> relatedsimTraces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> delayDueTosimTraces = new Vector<SimulationTransaction>();
JFrameLatencyDetailedAnalysis frameLatencyDetailedAnalysis;
JFrameCompareLatencyDetail frameCompareLatencyDetail;
int callingFrame;
int nbOfNodes = 0;
HashMap<String, ArrayList<ArrayList<Integer>>> runnableTimePerDevice = new HashMap<String, ArrayList<ArrayList<Integer>>>();
@SuppressWarnings("deprecation")
public DirectedGraphTranslator(JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis, JFrameCompareLatencyDetail jframeCompareLatencyDetail,
TMLMapping<TGComponent> tmap1, List<TMLComponentDesignPanel> cpanels1, int i) {
links = tmap.getTMLArchitecture().getHwLinks();
// frameCompareLatencyDetail.pack();
// frameCompareLatencyDetail.revalidate();
// frameCompareLatencyDetail.repaint();
DrawDirectedGraph();
/*
* JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String,
* DefaultEdge>(g);
*
* mxHierarchicalLayout layout = new mxHierarchicalLayout(graphAdapter);
*
* layout.setInterHierarchySpacing(100); layout.setInterRankCellSpacing(100);
* layout.setIntraCellSpacing(100);
*
* layout.execute(graphAdapter.getDefaultParent());
*
* scrollPane.setViewportView(new mxGraphComponent(graphAdapter));
*
* scrollPane.setVisible(true);
*
* scrollPane.revalidate(); scrollPane.repaint(); frame = new
* JFrame("The Sys-ML Model As Directed Graph"); frame.add(scrollPane);
* frame.pack();
*/
// frame.setVisible(false);
}
// The main function to add the vertices and edges according to the model
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();
for (HwA node : tmap.getArch().getHwA()) {
if (tmap.getLisMappedTasks(node).size() > 0) {
nodeNbProgressBar = tmap.getLisMappedTasks(node).size() + nodeNbProgressBar;
for (TMLTask task : tmap.getLisMappedTasks(node)) {
nodeNbProgressBar = task.getActivityDiagram().nElements() + nodeNbProgressBar;
for (HwNode node : tmap.getArch().getCPUs()) {
if (tmap.getLisMappedTasks(node).size() > 0) {
nodeNbProgressBar = tmap.getLisMappedTasks(node).size() + nodeNbProgressBar;
for (TMLTask task : tmap.getLisMappedTasks(node)) {
nodeNbProgressBar = task.getActivityDiagram().nElements() + nodeNbProgressBar;
HashSet<String> mappedcomm = new HashSet<String>();
for (HwNode node : tmap.getArch().getBUSs()) {
if (tmap.getLisMappedChannels(node).size() > 0) {
for (TMLElement entry : tmap.getLisMappedChannels(node)) {
if (!mappedcomm.contains(entry.getName())) {
mappedcomm.add(entry.getName());
nodeNbProgressBar++;
for (HwNode node : tmap.getArch().getHwBridge()) {
if (tmap.getLisMappedChannels(node).size() > 0) {
for (TMLElement entry : tmap.getLisMappedChannels(node)) {
if (!mappedcomm.contains(entry.getName())) {
mappedcomm.add(entry.getName());
nodeNbProgressBar++;
}
}
for (HwNode node : tmap.getArch().getMemories()) {
if (tmap.getLisMappedChannels(node).size() > 0) {
for (TMLElement entry : tmap.getLisMappedChannels(node)) {
if (!mappedcomm.contains(entry.getName())) {
mappedcomm.add(entry.getName());
nodeNbProgressBar++;
for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
if (!mappedcomm.contains(ch.getName())) {
mappedcomm.add(ch.getName());
nodeNbProgressBar++;
if (callingFrame == 0)
{
frameLatencyDetailedAnalysis.pbar.setMaximum(nodeNbProgressBar);
frameLatencyDetailedAnalysis.pbar.setMinimum(0);
if (callingFrame == 1)
{
frameCompareLatencyDetail.pbar.setMaximum(nodeNbProgressBar);
frameCompareLatencyDetail.pbar.setMinimum(0);
}
HashMap<String, HashSet<String>> cpuTasks;
HashMap<String, HashSet<TMLElement>> buschannel = new HashMap<String, HashSet<TMLElement>>();
HashMap<String, HashSet<TMLElement>> memorychannel = new HashMap<String, HashSet<TMLElement>>();
HashMap<String, HashSet<TMLElement>> bridgechannel = new HashMap<String, HashSet<TMLElement>>();
HashMap<String, HashSet<TMLTask>> cpuTask = new HashMap<String, HashSet<TMLTask>>();
g = new DefaultDirectedGraph<>(DefaultEdge.class);
for (HwNode node : tmap.getArch().getBUSs()) {
if (!g.containsVertex(node.getName())) {
g.addVertex(node.getName());
updatemainBar("getBUSs");
if (tmap.getLisMappedChannels(node).size() > 0) {
buschannel.put(node.getName(), tmap.getLisMappedChannels(node));
for (HwNode node : tmap.getArch().getHwBridge()) {
if (!g.containsVertex(node.getName())) {
g.addVertex(node.getName());
updatemainBar("getHwBridge");
}
if (tmap.getLisMappedChannels(node).size() > 0) {
bridgechannel.put(node.getName(), tmap.getLisMappedChannels(node));
if (tmap.getLisMappedTasks(node).size() > 0) {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
}
cpuTasks = getCPUTaskMap(cpuTask);
// if (tmap.getLisMappedChannels(node).size() > 0) {
// bridgechannel.put(node.getName(), tmap.getLisMappedChannels(node));
for (HwNode node : tmap.getArch().getMemories()) {
if (!g.containsVertex(node.getName())) {
g.addVertex(node.getName());
updatemainBar("getMemories");
}
if (tmap.getLisMappedChannels(node).size() > 0) {
memorychannel.put(node.getName(), tmap.getLisMappedChannels(node));
for (Entry<String, HashSet<TMLElement>> entry : buschannel.entrySet()) {
String busName = entry.getKey();
HashSet<TMLElement> busChList = entry.getValue();
for (TMLElement busCh : busChList) {
String ChannelName = busCh.getName();
if (!g.containsVertex(ChannelName)) {
g.addVertex(ChannelName);
updatemainBar("ChannelName");
g.addEdge(busName, ChannelName);
TMLChannel tmlch = (TMLChannel) busCh;
String writeChannel = tmlch.getDestinationTask().getName() + "__" + "writechannel:" + tmlch.getDestinationPort();
String readChannel;
for (Entry<String, HashSet<TMLElement>> entry : bridgechannel.entrySet()) {
String busName = entry.getKey();
HashSet<TMLElement> busChList = entry.getValue();
for (TMLElement busCh : busChList) {
String ChannelName = busCh.getName();
if (!g.containsVertex(ChannelName)) {
g.addVertex(ChannelName);
updatemainBar("ChannelName");
g.addEdge(busName, ChannelName);
for (Entry<String, HashSet<TMLElement>> entry : memorychannel.entrySet()) {
String busName = entry.getKey();
HashSet<TMLElement> busChList = entry.getValue();
for (TMLElement busCh : busChList) {
String ChannelName = busCh.getName();
if (!g.containsVertex(ChannelName)) {
g.addVertex(ChannelName);
updatemainBar("ChannelName");
g.addEdge(busName, ChannelName);
DiploSimulatorCodeGenerator gen = new DiploSimulatorCodeGenerator(tmap);
for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
List<HwCommunicationNode> pathNodes = gen.determineRoutingPath(tmap.getHwNodeOf(ch.getOriginTask()),
tmap.getHwNodeOf(ch.getDestinationTask()), ch);
if (!g.vertexSet().contains(ch.getName())) {
g.addVertex(ch.getName());
updatemainBar(ch.getName());
}
if (!pathNodes.isEmpty()) {
for (HwCommunicationNode node : pathNodes) {
if (channelPaths.containsKey(ch.getName())) {
if (!channelPaths.get(ch.getName()).contains(node.getName())) {
channelPaths.get(ch.getName()).add(node.getName());
}
} else {
ArrayList<String> pathNodeNames = new ArrayList<String>();
pathNodeNames.add(node.getName());
channelPaths.put(ch.getName(), pathNodeNames);
}
if (!g.containsEdge(node.getName(), ch.getName())) {
g.addEdge(node.getName(), ch.getName());
}
SummaryCommMapping = tmap.getSummaryCommMapping();
for (HwNode node : tmap.getArch().getCPUs()) {
cpuTask = new HashMap<String, HashSet<TMLTask>>();
if (tmap.getLisMappedTasks(node).size() > 0) {
cpuTask.put(node.getName(), tmap.getLisMappedTasks(node));
cpuTasks = getCPUTaskMap(cpuTask);
for (HwLink link : links) {
if (g.containsVertex(link.hwnode.getName()) && g.containsVertex(link.bus.getName())) {
g.addEdge(link.hwnode.getName(), link.bus.getName());
g.addEdge(link.bus.getName(), link.hwnode.getName());
}
if (addedEdges.size() > 0) {
for (Entry<String, String> edge : addedEdges.entrySet()) {
g.addEdge(edge.getKey(), edge.getValue());
if (sendEventWaitEventEdges.size() > 0) {
for (Entry<String, HashSet<String>> edge : sendEventWaitEventEdges.entrySet()) {
for (String waitEventEdge : edge.getValue())
g.addEdge(edge.getKey(), waitEventEdge);
if (readWriteChannelEdges.size() > 0) {
for (Entry<String, HashSet<String>> edge : readWriteChannelEdges.entrySet()) {
for (String readChannelEdge : edge.getValue())
g.addEdge(edge.getKey(), readChannelEdge);
if (sequenceEdges.size() > 0) {
for (Entry<String, HashSet<String>> edge : sequenceEdges.entrySet()) {
for (String sequenceEdge : edge.getValue())
g.addEdge(edge.getKey(), sequenceEdge);
if (unOrderedSequenceEdges.size() > 0) {
for (Entry<String, HashSet<String>> edge : unOrderedSequenceEdges.entrySet()) {
g.addEdge(edge.getKey(), sequenceEdge);
if (requestEdges.size() > 0) {
for (Entry<String, HashSet<String>> edge : requestEdges.entrySet()) {
for (String requestsingleEdges : edge.getValue()) {
g.addEdge(edge.getKey(), requestsingleEdges);
// draw the vertices and edges for the tasks mapped to the CPUs
private void updatemainBar(String string) {
if (callingFrame == 0)
{
frameLatencyDetailedAnalysis.updateBar(nbOfNodes);
} else if (callingFrame == 1) {
frameCompareLatencyDetail.updateBar(nbOfNodes);
public HashMap<String, HashSet<String>> getCPUTaskMap(HashMap<String, HashSet<TMLTask>> cpuTask) {
HashMap<String, HashSet<String>> cpuTaskMap = new HashMap<String, HashSet<String>>();
if (tmap == null) {
return cpuTaskMap;
for (Entry<String, HashSet<TMLTask>> entry : cpuTask.entrySet()) {
String key = entry.getKey();
HashSet<TMLTask> value = entry.getValue();
Vector<TMLActivityElement> multiNexts = new Vector<TMLActivityElement>();
TMLActivityElement elt;
// Map <String, String> sendEvt;
HashMap<String, List<String>> sendEvt = new HashMap<String, List<String>>();
HashMap<String, List<String>> waitEvt = new HashMap<String, List<String>>();
HashMap<String, String> sendData = new HashMap<String, String>();
HashMap<String, String> receiveData = new HashMap<String, String>();
// GEt List of all requests
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);
}
} else {
ArrayList<String> destinationRequestNames = new ArrayList<String>();
destinationRequestNames.add(destinationRequestName);
requestsOriginDestination.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);
}
} else {
ArrayList<String> requestsPortNames = new ArrayList<String>();
requestsPortNames.add(requestsPortName);
requestsPorts.put(task.getName(), requestsPortNames);
}
if (requestsDestination.containsKey(destinationRequestName)) {
if (!requestsDestination.get(destinationRequestName).contains(destinationRequest)) {
requestsDestination.get(destinationRequestName).add(destinationRequest);
}
} else {
ArrayList<String> destinationRequestNames = new ArrayList<String>();
destinationRequestNames.add(destinationRequest);
requestsDestination.put(destinationRequestName, destinationRequestNames);
for (TMLTask task : value) {
/*
* for (TMLComponentDesignPanel dpPanel : getCpanels()) { String[] taskpanel =
* task.getName().split("__");
*
* if (dpPanel.getNameOfTab().equals(taskpanel[0])) { tmlcdp = dpPanel; }
*
* }
*/
// get the names and params of send events per task and their corresponding wait
// events
for (TMLSendEvent sendEvent : task.getSendEvents()) {
TMLCPrimitivePort sendingPortdetails = sendEvent.getEvent().port;
TMLCPrimitivePort receivePortdetails = sendEvent.getEvent().port2;
String sendingPortparams = sendEvent.getAllParams();
TMLTask destinationTasks = sendEvent.getEvent().getDestinationTask();
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 + ")");
}
// get the names of read channels per task and their corresponding write
// channels
for (TMLReadChannel readChannel : task.getReadChannels()) {
int i = readChannel.getNbOfChannels();
for (int j = 0; j < i; j++) {
String sendingDataPortdetails = readChannel.getChannel(j).getOriginPort().getName();
String receiveDataPortdetails = readChannel.getChannel(j).getDestinationPort().getName();
if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
receiveData.put(receiveDataPortdetails, sendingDataPortdetails);
}
// get the names of write channels per task and their corresponding read
// channels
for (TMLWriteChannel writeChannel : task.getWriteChannels()) {
int i = writeChannel.getNbOfChannels();
for (int j = 0; j < i; j++) {
// writeChannel.getChannel(j);
String sendingDataPortdetails = writeChannel.getChannel(j).getOriginPort().getName();
String receiveDataPortdetails = writeChannel.getChannel(j).getDestinationPort().getName();
if (!sendingDataPortdetails.equals(receiveDataPortdetails)) {
sendData.put(sendingDataPortdetails, receiveDataPortdetails);
}
}
// get the names and params of wait events per task and their corresponding send
// events
for (TMLWaitEvent waitEvent : task.getWaitEvents()) {
// TMLCPrimitivePort portdetails = waitEvent.getEvent().port;
TMLCPrimitivePort sendingPortdetails = waitEvent.getEvent().port;
TMLCPrimitivePort receivePortdetails = waitEvent.getEvent().port2;
String receivePortparams = waitEvent.getAllParams();
// tmlcdp.tmlctdp.getAllPortsConnectedTo(portdetails);
waitEvt.put("waitevent:" + receivePortdetails.getPortName() + "(" + receivePortparams + ")", 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 + ")");
if (!g.vertexSet().contains(key)) {
g.addVertex(key);
if (!g.vertexSet().contains(task.getName())) {
g.addVertex(task.getName());
updatemainBar(task.getName());
g.addEdge(key, task.getName());
String taskStartName = "";
String taskEndName = "";
int countTillStart = 0;
boolean hasSequence = false;
boolean hasForLoop = false;
HashMap<String, List<String>> forLoopNextValues = new HashMap<String, List<String>>();
// loop over all the activites corresponding to a task
while (count <= activity.nElements()) {
String eventName;
String preEventName;
if (currentElement.getName().equals("Stop after infinite loop")) {
if (count <= activity.nElements()) {
if (currentElement.getNexts().size() == 1) {
currentElement = currentElement.getNexts().firstElement();
} else if (!multiNexts.isEmpty()) {
currentElement = multiNexts.get(0);
} else if (currentElement.getReferenceObject() instanceof TMLADRandom) {
eventName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
} else {
eventName = task.getName() + "__" + currentElement.getReferenceObject().toString() + "__" + currentElement.getID();
}
updatemainBar(eventName);
if (currentElement.getNexts().size() > 1) {
for (TMLActivityElement ae : currentElement.getNexts()) {
multiNexts.add(ae);
}
// 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() instanceof TMLADStopState) {
taskEndName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__"
+ activity.getPrevious(currentElement).getID();
g.addVertex(taskEndName);
// allTasks.add(taskEndName);
if (!(activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADSequence)) {
g.addEdge(preEventName, taskEndName);
@SuppressWarnings({"unchecked", "rawtypes"})
AllDirectedPaths<String, DefaultEdge> allPaths = new AllDirectedPaths<String, DefaultEdge>(g);
if (orderedSequenceList.size() > 0) {
int noForLoop = 0;
// get path from sequence to end
for (Entry<String, ArrayList<String>> sequenceListEntry : orderedSequenceList.entrySet()) {
int directlyConnectedSeq = 0;
if (g.containsVertex(sequenceListEntry.getKey())) {
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(sequenceListEntry.getKey(), taskEndName, false,
g.vertexSet().size());
for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
for (int i = 0; i < path.size(); i++) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
if (path.get(i).getVertexList().contains(othersequenceListEntryValue.getKey())) {
directlyConnectedSeq++;
}
}
}
}
if (path.size() > 0 && sequenceListEntry.getValue().size() > 0 && directlyConnectedSeq == 0) {
for (int i = 0; i < path.size(); i++) {
for (String sequenceListEntryValue : sequenceListEntry.getValue()) {
if (g.containsVertex(sequenceListEntryValue)) {
if (path.get(i).getVertexList().contains(sequenceListEntryValue)) {
if (forLoopNextValues.size() > 0) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (path.get(i).getVertexList().contains(forloopListEntry.getValue().get(0))) {
noForLoop++;
}
}
}
if (forEverLoopList.size() > 0) {
for (String forloopListEntry : forEverLoopList) {
if (path.get(i).getVertexList().contains(forloopListEntry)) {
noForLoop++;
}
}
}
if (noForLoop == 0) {
int nextIndex = sequenceListEntry.getValue().indexOf(sequenceListEntryValue) + 1;
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));
}
sequenceEdges.put(eventName, endSequenceVertex);
} else if (nextIndex == sequenceListEntry.getValue().size()
&& orderedSequenceList.size() > 1) {
for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList
.entrySet()) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
int connectedSeq = 0;
List<GraphPath<String, DefaultEdge>> pathBetweenSeq = allPaths.getAllPaths(
othersequenceListEntryValue.getKey(), taskEndName, false,
g.vertexSet().size());
for (int j = 0; j < pathBetweenSeq.size(); j++) {
for (Entry<String, ArrayList<String>> adjacentsequenceListEntryValue : orderedSequenceList
.entrySet()) {
if (!adjacentsequenceListEntryValue.getKey()
.equals(sequenceListEntry.getKey())
&& !adjacentsequenceListEntryValue.getKey()
.equals(othersequenceListEntryValue.getKey())) {
if (path.get(i).getVertexList()
.contains(adjacentsequenceListEntryValue)) {
if (connectedSeq == 0 && pathBetweenSeq.size() > 0) {
for (String othersequenceListValue : othersequenceListEntryValue
.getValue()) {
List<GraphPath<String, DefaultEdge>> pathToNextValue = allPaths
.getAllPaths(othersequenceListValue, taskEndName, false,
g.vertexSet().size());
if (pathToNextValue.size() > 0)
int nextAdjIndex = othersequenceListEntryValue.getValue()
.indexOf(othersequenceListValue) + 1;
if (nextAdjIndex < othersequenceListEntryValue.getValue()
.size()) {
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(othersequenceListEntryValue.getValue()
.get(nextAdjIndex));
}
sequenceEdges.put(eventName, nextSequenceVertex);
if (unOrderedSequenceList.size() > 0) {
// get path from sequence to end
for (Entry<String, ArrayList<String>> sequenceListEntry : unOrderedSequenceList.entrySet()) {
if (g.containsVertex(sequenceListEntry.getKey())) {
int noForLoop = 0;
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(sequenceListEntry.getKey(), 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 (path.get(i).getVertexList().contains(forloopListEntry.getKey())) {
noForLoop++;
}
}
}
if (forEverLoopList.size() > 0) {
for (String forloopListEntry : forEverLoopList) {
if (path.get(i).getVertexList().contains(forloopListEntry)) {
noForLoop++;
}
}
}
if (noForLoop == 0) {
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(sequenceListEntry.getKey());
if (unOrderedSequenceEdges.containsKey(taskEndName)) {
if (!unOrderedSequenceEdges.get(taskEndName).contains(sequenceListEntry.getKey())) {
unOrderedSequenceEdges.get(taskEndName).add(sequenceListEntry.getKey());
}
unOrderedSequenceEdges.put(eventName, endSequenceVertex);
// add if sequence on path of multiple for
if (forLoopNextValues.size() > 0) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (g.containsVertex(forloopListEntry.getValue().get(0))) {
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(forloopListEntry.getValue().get(0), taskEndName,
false, g.vertexSet().size());
for (int i = 0; i < path.size(); i++) {
int forloopCount = 0;
for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
if (!forloopListEntry.getKey().equals(forEntry.getKey())) {
if (path.get(i).getVertexList().contains(forEntry.getKey())) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (path.get(i).getVertexList().contains(seqEntry.getKey())) {
if (path.get(i).getVertexList().contains(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))
} else {
forloopCount++;
}
for (Entry<String, ArrayList<String>> unOrderedseqEntry : unOrderedSequenceList.entrySet()) {
forloopCount++;
if (path.get(i).getVertexList().contains(unOrderedseqEntry.getKey())) {
HashSet<String> forLoopName = new HashSet<String>();
forLoopName.add(forloopListEntry.getKey());
if (unOrderedSequenceEdges.containsKey(unOrderedseqEntry.getKey())) {
if (unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).contains(forloopListEntry.getKey())) {
unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).add(forloopListEntry.getKey());
}
unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
}
String forvertexName = forloopListEntry.getKey();
if (forloopCount == 0 && !g.containsEdge(taskEndName, forvertexName)) {
addedEdges.put(taskEndName, forvertexName);
if (g.containsVertex(forloopListEntry.getValue().get(1)) && forLoopNextValues.size() > 1) {
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(forloopListEntry.getValue().get(1), taskEndName,
false, g.vertexSet().size());
if (path.size() > 0) {
for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
if (g.containsVertex(previousForLoop.getValue().get(0))
&& !previousForLoop.getKey().equals(forloopListEntry.getKey())) {
List<GraphPath<String, DefaultEdge>> previousForpath = allPaths
.getAllPaths(previousForLoop.getValue().get(0), taskEndName, false, g.vertexSet().size());
for (int i = 0; i < previousForpath.size(); i++) {
int forloopCount = 0;
for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
if (previousForpath.get(i).getVertexList().contains(forEntry.getKey())
&& !forloopListEntry.getKey().equals(forEntry.getKey())) {
String forvertexName = previousForLoop.getKey();
if (forloopCount == 0
&& !g.containsEdge(taskEndName, forvertexName)) {
addedEdges.put(taskEndName, forvertexName);
}
}
}
}
}
if (!forEverLoopList.isEmpty())
for (String loopforEver : forEverLoopList) {
List<GraphPath<String, DefaultEdge>> pathforloopforever = allPaths.getAllPaths(loopforEver, 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()) {
if (pathforloopforever.get(i).getVertexList().contains(previousForLoop.getValue().get(0))) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(seqEntry.getKey())) {
if (pathforloopforever.get(i).getVertexList()
.contains(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))
} else {
forloopCount++;
}
for (Entry<String, ArrayList<String>> unOrderedseqEntry : unOrderedSequenceList.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(unOrderedseqEntry.getKey())) {
forloopCount++;
HashSet<String> forLoopName = new HashSet<String>();
forLoopName.add(loopforEver);
if (unOrderedSequenceEdges.containsKey(unOrderedseqEntry.getKey())) {
if (unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).contains(loopforEver)) {
unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).add(loopforEver);
}
unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
if (forloopCount == 0) {
addedEdges.put(taskEndName, loopforEver);
}
}
}
}
// start activity is added as a vertex
if (currentElement.getReferenceObject() instanceof TMLADStartState) {
taskStartName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
g.addVertex(taskStartName);
g.addEdge(task.getName(), taskStartName);
if (!nameIDTaskList.containsKey(currentElement.getID())) {
nameIDTaskList.put(String.valueOf(currentElement.getID()), eventName);
// the below activities are added as vertex with the required edges
// these activities can be used to check later for latency
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
else if (currentElement.getReferenceObject() instanceof TMLADSendEvent
|| currentElement.getReferenceObject() instanceof TMLADWaitEvent
|| currentElement.getReferenceObject() instanceof TMLADForLoop
|| currentElement.getReferenceObject() instanceof TMLADForStaticLoop
|| currentElement.getReferenceObject() instanceof TMLADChoice
|| currentElement.getReferenceObject() instanceof TMLADForEverLoop
|| currentElement.getReferenceObject() instanceof TMLADExecI || currentElement.getReferenceObject() instanceof TMLADExecC
|| currentElement.getReferenceObject() instanceof TMLADDelay
|| currentElement.getReferenceObject() instanceof TMLADSendRequest
|| currentElement.getReferenceObject() instanceof TMLADReadRequestArg
|| currentElement.getReferenceObject() instanceof TMLADActionState
|| currentElement.getReferenceObject() instanceof TMLADDelayInterval
|| currentElement.getReferenceObject() instanceof TMLADExecCInterval
|| currentElement.getReferenceObject() instanceof TMLADExecIInterval
|| currentElement.getReferenceObject() instanceof TMLADNotifiedEvent
|| currentElement.getReferenceObject() instanceof TMLADRandom
|| currentElement.getReferenceObject() instanceof TMLADReadChannel
|| currentElement.getReferenceObject() instanceof TMLADWriteChannel
|| currentElement.getReferenceObject() instanceof TMLADSequence
|| currentElement.getReferenceObject() instanceof TMLADUnorderedSequence
|| currentElement.getReferenceObject() instanceof TMLADSelectEvt
|| currentElement.getReferenceObject() instanceof TMLADDecrypt
|| currentElement.getReferenceObject() instanceof TMLADEncrypt) {
if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADRandom) {
preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getName() + "__"
+ activity.getPrevious(currentElement).getID();
} else {
preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__"
+ activity.getPrevious(currentElement).getID();
if (!nameIDTaskList.containsKey(currentElement.getID())) {
nameIDTaskList.put(String.valueOf(currentElement.getID()), eventName);
if (g.containsVertex(preEventName)) {
g.addVertex(eventName);
g.addEdge(preEventName, eventName);
count++;
} else if ((activity.getPrevious(currentElement).getName().equals("start")) && g.containsVertex(taskStartName)) {
g.addVertex(eventName);
g.addEdge(taskStartName, eventName);
count++;
if (currentElement.getReferenceObject() instanceof TMLADSendEvent
|| currentElement.getReferenceObject() instanceof TMLADWaitEvent
|| currentElement.getReferenceObject() instanceof TMLADSendRequest
|| currentElement.getReferenceObject() instanceof TMLADActionState
|| 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 TMLADActionState
|| currentElement.getReferenceObject() instanceof TMLADDelayInterval
|| currentElement.getReferenceObject() instanceof TMLADExecCInterval
|| currentElement.getReferenceObject() instanceof TMLADExecIInterval
|| currentElement.getReferenceObject() instanceof TMLADDecrypt
|| currentElement.getReferenceObject() instanceof TMLADEncrypt
|| currentElement.getReferenceObject() instanceof TMLADReadRequestArg) {
allLatencyTasks.add(eventName);
if (currentElement.getReferenceObject() instanceof TMLADForEverLoop) {
forEverLoopList.add(eventName);
}
if (currentElement.getReferenceObject() instanceof TMLADSendRequest) {
if (requestsOriginDestination.containsKey(task.getName())) {
for (String destinationTask : requestsOriginDestination.get(task.getName())) {
if (requestsPorts.containsKey(destinationTask)) {
for (String portNames : requestsPorts.get(destinationTask)) {
String[] requestName = currentElement.getReferenceObject().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);
}
HashSet<String> destinationTaskoriginstart = new HashSet<String>();
destinationTaskoriginstart.add(destinationTaskstartname);
requestEdges.put(eventName, destinationTaskoriginstart);
if (currentElement.getReferenceObject() instanceof TMLADSendEvent) {
if (sendEvt.containsKey(currentElement.getReferenceObject().toString().replaceAll(" ", ""))) {
List<String> recieveEvt = sendEvt.get(currentElement.getReferenceObject().toString().replaceAll(" ", ""));
for (String vertex : g.vertexSet()) {
String[] vertexName = vertex.split("__");
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);
if (sendEventWaitEventEdges.containsKey(eventName)) {
if (!sendEventWaitEventEdges.get(eventName).contains(vertex)) {
sendEventWaitEventEdges.get(eventName).add(vertex);
}
sendEventWaitEventEdges.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 (String vertex : g.vertexSet()) {
String[] vertexName = vertex.split("__");
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)) {
if (!sendEventWaitEventEdges.get(vertex).contains(eventName)) {
sendEventWaitEventEdges.get(vertex).add(eventName);
}
sendEventWaitEventEdges.put(vertex, waitEventVertex);
}
}
}
}
if (currentElement.getReferenceObject() instanceof TMLADWriteChannel) {
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 = name[0] + "__" + portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces);
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(sendDatachannels);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(sendDatachannels)) {
readWriteChannelEdges.get(eventName).add(sendDatachannels);
}
readWriteChannelEdges.put(eventName, writeChVertex);
} else {
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(chwriteName);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(chwriteName)) {
readWriteChannelEdges.get(eventName).add(chwriteName);
}
readWriteChannelEdges.put(eventName, writeChVertex);
if (currentElement.getReferenceObject() instanceof TMLADReadChannel) {
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 = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__" + name[0] + "__"
+ portNameNoSpaces;
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(sendDatachannels);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(sendDatachannels)) {
readWriteChannelEdges.get(eventName).add(sendDatachannels);
}
readWriteChannelEdges.put(eventName, readChVertex);
/*
* if (g.containsVertex(chwriteName))
*
* { g.addEdge(chwriteName, eventName); }
*/
} else {
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(eventName);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(chwriteName)) {
readWriteChannelEdges.get(eventName).add(chwriteName);
}
readWriteChannelEdges.put(chwriteName, readChVertex);
// 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.getNexts().size() == 1) {
currentElement = currentElement.getNexts().firstElement();
} else if (!multiNexts.isEmpty()) {
if (currentElement.getReferenceObject() instanceof TMLADForStaticLoop
|| currentElement.getReferenceObject() instanceof TMLADForLoop) {
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();
} else if (currentElement.getReferenceObject() instanceof TMLADForLoop) {
points = Arrays.asList(((TMLADForLoop) (currentElement.getReferenceObject())).getConnectingPoints());
getOutputConnectors = ((TMLADForLoop) (currentElement
.getReferenceObject())).getOutputConnectors();
}
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) {
insideLoop = task.getName() + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
} else if (afterloopcg == outputConnector) {
outsideLoop = task.getName() + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
afterloopActivity.add(0, insideLoop);
afterloopActivity.add(1, outsideLoop);
forLoopNextValues.put(eventName, afterloopActivity);
} else if (currentElement.getReferenceObject() instanceof TMLADSequence) {
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
nextEventName = task.getName() + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
} else {
nextEventName = task.getName() + "__" + seqListnextElement.getReferenceObject().toString() + "__"
+ seqListnextElement.getID();
if (orderedSequenceList.containsKey(eventName)) {
if (!orderedSequenceList.get(eventName).contains(nextEventName)) {
orderedSequenceList.get(eventName).add(nextEventName);
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
orderedSequenceList.put(eventName, seqListNextValues);
} else if (currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
nextEventName = task.getName() + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
} else {
nextEventName = task.getName() + "__" + seqListnextElement.getReferenceObject().toString() + "__"
+ seqListnextElement.getID();
if (unOrderedSequenceList.containsKey(eventName)) {
if (!unOrderedSequenceList.get(eventName).contains(nextEventName)) {
unOrderedSequenceList.get(eventName).add(nextEventName);
}
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
unOrderedSequenceList.put(eventName, seqListNextValues);
}
List<TGConnector> cg = (((TGComponent) currentElement.getReferenceObject()).getInputConnectors());
currentElement = multiNexts.get(0);
multiNexts.remove(0);
return cpuTaskMap;
}
// get graph size
public int getGraphsize() {
return g.vertexSet().size();
}
// get graph size
public int getGraphEdgeSet() {
return g.edgeSet().size();
}
// open graph in a frame
public void showGraph(DirectedGraphTranslator dgraph) {
JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(dgraph.getG());
mxHierarchicalLayout layout = new mxHierarchicalLayout(graphAdapter);
layout.setInterHierarchySpacing(100);
layout.setInterRankCellSpacing(100);
layout.setIntraCellSpacing(100);
layout.execute(graphAdapter.getDefaultParent());
dgraph.getScrollPane().setViewportView(new mxGraphComponent(graphAdapter));
dgraph.getScrollPane().setVisible(true);
dgraph.getScrollPane().revalidate();
dgraph.getScrollPane().repaint();
dgraph.getFrame().add(dgraph.getScrollPane());
dgraph.getFrame().pack();
dgraph.getFrame().setLocationByPlatform(true);
dgraph.getFrame().setVisible(true);
}
public JFrame getFrame() {
return frame;
}
// save graph in .graphml format
public void exportGraph(String filename) throws ExportException, IOException {
@SuppressWarnings({"rawtypes", "unchecked"})
GraphMLExporter<String, DefaultEdge> gmlExporter = new GraphMLExporter();
ComponentNameProvider<String> vertexIDProvider = new ComponentNameProvider<String>() {
@Override
public String getName(String vertex) {
// TODO Auto-generated method stub
vertex = vertex.replaceAll("\\s+", "");
vertex = vertex.replaceAll("\\(", "\\u0028");
vertex = vertex.replaceAll("\\)", "\\u0029");
return vertex;
ComponentNameProvider<String> vertexNameProvider = new ComponentNameProvider<String>() {
@Override
public String getName(String vertex) {
// TODO Auto-generated method stub
return vertex;
}
};
ComponentNameProvider<DefaultEdge> edgeIDProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
String source = g.getEdgeSource(edge).replaceAll("\\s+", "");
source = source.replaceAll("\\(", "\\u0028");
source = source.replaceAll("\\)", "\\u0029");
// .replaceAll("\\(", "");
// source.replaceAll("\\)", "");
String target = g.getEdgeTarget(edge).replaceAll("\\s+", "");
target = target.replaceAll("\\(", "\\u0028");
target = target.replaceAll("\\)", "\\u0029");
// target.replaceAll("\\(", "");
// target.replaceAll("\\)", "");
// TODO Auto-generated method stub
return source + target;
}
};
ComponentNameProvider<DefaultEdge> edgeLabelProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
// TODO Auto-generated method stub
return Double.toString(g.getEdgeWeight(edge));
}
};
GraphMLExporter<String, DefaultEdge> exporter = new GraphMLExporter<String, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
edgeLabelProvider);
Writer fileWriter;
FileWriter PS = new FileWriter(filename + ".graphml");
// gmlExporter.exportGraph(g, PS);
// FileWriter PS2 = new FileWriter(filename + "test.graphml");
exporter.exportGraph(g, PS);
// save graph frame in .png format
public void exportGraphAsImage(String filename) throws ExportException, IOException {
Container c = frame.getContentPane();
BufferedImage im = new BufferedImage(c.getWidth(), c.getHeight(), BufferedImage.TYPE_INT_ARGB);
c.paint(im.getGraphics());
ImageIO.write(im, "PNG", new File(filename + ".png"));
// return all vertices that can be checked for latency
// used to fill drop down
public Vector<String> getLatencyVertices() {
return allLatencyTasks;
}
public static boolean isNumeric(String strNum) {
try {
double d = Double.parseDouble(strNum);
} catch (NumberFormatException | NullPointerException nfe) {
return false;
}
return true;
}
// fill the main table of the latency frame by checking all the delay times
// between the selected tasks
public Object[][] latencyDetailedAnalysis(String task12ID, String task22ID, Vector<SimulationTransaction> transFile1) {
transFile = transFile1;
// AllDirectedPaths<String, DefaultEdge> allPaths = new AllDirectedPaths<String,
// DefaultEdge>(g);
String message = "";
String[] task1 = task12ID.split("__");
int task1index = task1.length;
idTask1 = task1[task1index - 1];
String[] task2 = task22ID.split("__");
int task2index = task2.length;
idTask2 = task2[task2index - 1];
String task12 = nameIDTaskList.get(idTask1);
String task22 = nameIDTaskList.get(idTask2);
Vector<SimulationTransaction> Task1Traces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> Task2Traces = new Vector<SimulationTransaction>();
GraphPath<String, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, task12, task22);
// List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(task12,
// task22, false, 100);
// int size = path.size();
times1.clear();
times2.clear();
// message = "there exists " +path.size()+" between: " + task12 + " and " +
// 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<String, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, task12, ChannelName);
GraphPath<String, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, ChannelName, task22);
if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
GraphPath<String, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, task12, ChannelName);
GraphPath<String, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, ChannelName, task22);
if ((pathTochannel != null && pathTochannel.getLength() > 0) || (pathFromChannel != null && pathFromChannel.getLength() > 0)) {
devicesToBeConsidered.addAll(busChList);
for (SimulationTransaction st : transFile1) {
if (st.id.equals(idTask1)) {
Task1Traces.add(st);
task1DeviceName = st.deviceName;
times1.add(Integer.valueOf(st.startTime));
Collections.sort(times1);
if (st.id.equals(idTask2)) {
Task2Traces.add(st);
task2DeviceName = st.deviceName;
times2.add(Integer.valueOf(st.endTime));
Collections.sort(times1);
}
}
// one to one
int minIndex = 0;
if (times1.size() != times2.size()) {
minIndex = Math.min(times1.size(), times2.size());
} else {
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>>>();
for (SimulationTransaction st : transFile1) {
Boolean onPath = false;
// if (Integer.valueOf(st.startTime) >= times1.get(i) &&
// Integer.valueOf(st.startTime) < times2.get(i)) {
if (!(Integer.valueOf(st.startTime) < times1.get(i) && Integer.valueOf(st.endTime) < times1.get(i))
&& !(Integer.valueOf(st.startTime) > times2.get(i) && Integer.valueOf(st.endTime) > times2.get(i))) {
// if (Integer.valueOf(st.startTime) >= minTime && Integer.valueOf(st.startTime)
// < maxTime) {
if (Integer.valueOf(st.endTime) > times2.get(i)) {
st.endTime = times2.get(i).toString();
st.length = Integer.valueOf(Integer.valueOf(times2.get(i)) - Integer.valueOf(st.startTime)).toString();
}
if (Integer.valueOf(st.startTime) < times1.get(i)) {
st.startTime = Integer.valueOf(times1.get(i)).toString();
st.length = Integer.valueOf(Integer.valueOf(st.endTime) - Integer.valueOf(times1.get(i))).toString();
}
if (Integer.valueOf(st.startTime) < times1.get(i) && Integer.valueOf(st.endTime) > times2.get(i)) {
st.startTime = Integer.valueOf(times1.get(i)).toString();
st.endTime = times2.get(i).toString();
st.length = Integer.valueOf(Integer.valueOf(times2.get(i)) - Integer.valueOf(times1.get(i))).toString();
}
String taskname = "";
for (String tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.replaceAll(" ", "").split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
if (isNumeric(taskToAddid)) {
if (Integer.valueOf(taskToAddid).equals(Integer.valueOf(st.id))) {
taskname = tasknameCheck;
break;
String[] name = st.deviceName.split("_");
String deviceName = name[0];
// there is a path between task 1 and task 2
if (path2 != null && path2.getLength() > 0) {
if (!taskname.equals(null) && !taskname.equals("")) {
GraphPath<String, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, task12, taskname);
GraphPath<String, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, taskname, task22);
if (taskname.equals(task12) || taskname.equals(task22) || (pathToOrigin != null && pathToOrigin.getLength() > 0
&& pathToDestination != null && pathToDestination.getLength() > 0)) {
relatedsimTraces.add(st);
ArrayList<Integer> timeValues = new ArrayList<Integer>();
timeValues.add(0, Integer.valueOf(st.runnableTime));
timeValues.add(1, Integer.valueOf(st.startTime));
if (!(st.runnableTime).equals(st.startTime)) {
if (runnableTimePerDevice.containsKey(st.deviceName)) {
if (!runnableTimePerDevice.get(st.deviceName).contains(timeValues)) {
runnableTimePerDevice.get(st.deviceName).add(timeValues);
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
runnableTimePerDevice.put(st.deviceName, timeValuesList);
} else if (((st.deviceName.equals(task2DeviceName)) || st.deviceName.equals(task1DeviceName)
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
delayDueTosimTraces.add(st);
}
}
} else {
if (!taskname.equals(null) && !taskname.equals("")) {
GraphPath<String, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, task12, taskname);
GraphPath<String, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, taskname, task22);
if (pathExistsTestwithTask1 != null && pathExistsTestwithTask1.getLength() > 0
|| pathExistsTestwithTask2 != null && pathExistsTestwithTask2.getLength() > 0) {
relatedsimTraces.add(st);
} else if (((st.deviceName.equals(task2DeviceName)) || st.deviceName.equals(task1DeviceName)
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
delayDueTosimTraces.add(st);
dataByTask[i][0] = task12;
dataByTask[i][1] = times1.get(i);
dataByTask[i][2] = task22;
dataByTask[i][3] = times2.get(i);
dataByTask[i][4] = times2.get(i) - times1.get(i);
dataByTask[i][5] = "";
dataByTaskR.put(i, relatedsimTraces);
dataBydelayedTasks.put(i, delayDueTosimTraces);
timeDelayedPerRow.put(i, runnableTimePerDevice);
// dataByTask[i][5] = list.getModel();
// dataByTask[i][6] = totalTime;
return dataByTask;
}
// fill the detailed latency table once a row is selected
public Object[][] getTaskByRowDetails(int row) {
Object[][] dataByTaskRowDetails = new Object[dataByTaskR.get(row).size()][5];
int i = 0;
for (SimulationTransaction st : dataByTaskR.get(row)) {
dataByTaskRowDetails[i][0] = st.command;
dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
dataByTaskRowDetails[i][2] = st.deviceName;
dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);
i++;
}
return dataByTaskRowDetails;
}
// fill the detailed latency table once a row is selected
public List<SimulationTransaction> getRowDetailsTaks(int row) {
return dataByTaskR.get(row);
}
// fill the detailed latency table once a row is selected
public List<SimulationTransaction> getRowDetailsByHW(int row) {
return dataBydelayedTasks.get(row);
}
// fill the detailed latency table once a row is selected
public HashMap<String, ArrayList<ArrayList<Integer>>> getRowDelayDetailsByHW(int row) {
return timeDelayedPerRow.get(row);
}
// fill the detailed latency table once a row is selected from min/max table
public Vector<SimulationTransaction> getMinMaxTasksByRow(int row) {
return relatedsimTraces;
}
// fill the tasks that run on the same hardware but don't belong to the path
// between selected activities
public Vector<SimulationTransaction> getTaskMinMaxHWByRowDetails(int row) {
return delayDueTosimTraces;
}
// get the details of the delay for a selected min or max delay row
public void getRowDetailsMinMax(int row) {
String task12 = (String) dataByTaskMinMax[row][0];
int minTime = (int) dataByTaskMinMax[row][1];
String task22 = (String) dataByTaskMinMax[row][2];
int maxTime = (int) dataByTaskMinMax[row][3];
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>>>();
// 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<String, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, task12, 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<String, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, task12, ChannelName);
GraphPath<String, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, ChannelName, task22);
if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
}
}
} else {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
GraphPath<String, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, task12, ChannelName);
GraphPath<String, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, ChannelName, task22);
if ((pathTochannel != null && pathTochannel.getLength() > 0) || (pathFromChannel != null && pathFromChannel.getLength() > 0)) {
devicesToBeConsidered.addAll(busChList);
}
}
}
for (SimulationTransaction st : transFile) {
Boolean onPath = false;
if (!(Integer.valueOf(st.startTime) < minTime && Integer.valueOf(st.endTime) < minTime)
&& !(Integer.valueOf(st.startTime) > maxTime && Integer.valueOf(st.endTime) > maxTime)) {
// if (Integer.valueOf(st.startTime) >= minTime && Integer.valueOf(st.startTime)
// < maxTime) {
if (Integer.valueOf(st.endTime) > maxTime) {
st.endTime = Integer.valueOf(maxTime).toString();
st.length = Integer.valueOf(Integer.valueOf(maxTime) - Integer.valueOf(st.startTime)).toString();
}
if (Integer.valueOf(st.startTime) < minTime) {
st.startTime = Integer.valueOf(minTime).toString();
st.length = Integer.valueOf(Integer.valueOf(st.endTime) - Integer.valueOf(minTime)).toString();
if (Integer.valueOf(st.startTime) < minTime && Integer.valueOf(st.endTime) > maxTime) {
st.startTime = Integer.valueOf(minTime).toString();
st.endTime = Integer.valueOf(maxTime).toString();
st.length = Integer.valueOf(Integer.valueOf(maxTime) - Integer.valueOf(minTime)).toString();
}
String taskname = "";
for (String tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
if (isNumeric(taskToAddid)) {
if (Integer.valueOf(taskToAddid).equals(Integer.valueOf(st.id))) {
taskname = tasknameCheck;
break;
}
}
}
String[] name = st.deviceName.split("_");
String deviceName = name[0];
// there is a path between task 1 and task 2
if (path2 != null && path2.getLength() > 0) {
if (!taskname.equals(null) && !taskname.equals("")) {
GraphPath<String, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, task12, taskname);
GraphPath<String, DefaultEdge> pathToDestination = DijkstraShortestPath.findPathBetween(g, taskname, task22);
if (taskname.equals(task12) || taskname.equals(task22) || (pathToOrigin != null && pathToOrigin.getLength() > 0
&& pathToDestination != null && pathToDestination.getLength() > 0)) {
relatedsimTraces.add(st);
2393
2394
2395
2396
2397
2398
2399
2400
2401
2402
2403
2404
2405
2406
2407
2408
2409
2410
2411
2412
2413
2414
ArrayList<Integer> timeValues = new ArrayList<Integer>();
timeValues.add(0, Integer.valueOf(st.runnableTime));
timeValues.add(1, Integer.valueOf(st.startTime));
if (!(st.runnableTime).equals(st.startTime)) {
if (runnableTimePerDevice.containsKey(st.deviceName)) {
if (!runnableTimePerDevice.get(st.deviceName).contains(timeValues)) {
runnableTimePerDevice.get(st.deviceName).add(timeValues);
}
} else {
ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
timeValuesList.add(timeValues);
runnableTimePerDevice.put(st.deviceName, timeValuesList);
}
}
} else if (((st.deviceName.equals(task2DeviceName)) || st.deviceName.equals(task1DeviceName)
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
delayDueTosimTraces.add(st);
}
}
timeDelayedPerRow.put(row, runnableTimePerDevice);
} else {
if (!taskname.equals(null) && !taskname.equals("")) {
GraphPath<String, DefaultEdge> pathExistsTestwithTask1 = DijkstraShortestPath.findPathBetween(g, task12, taskname);
GraphPath<String, DefaultEdge> pathExistsTestwithTask2 = DijkstraShortestPath.findPathBetween(g, taskname, task22);
if (pathExistsTestwithTask1 != null && pathExistsTestwithTask1.getLength() > 0
|| pathExistsTestwithTask2 != null && pathExistsTestwithTask2.getLength() > 0) {
relatedsimTraces.add(st);
} else if (((st.deviceName.equals(task2DeviceName)) || st.deviceName.equals(task1DeviceName)
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
delayDueTosimTraces.add(st);
}
}
}
}
}
}
// fill the tasks that run on the same hardware but don't belong to the path
// between selected activities
public Object[][] getTaskHWByRowDetails(int row) {
Object[][] dataByTaskRowDetails = new Object[dataBydelayedTasks.get(row).size()][6];
int i = 0;
for (SimulationTransaction st : dataBydelayedTasks.get(row)) {
dataByTaskRowDetails[i][0] = st.command;
dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
dataByTaskRowDetails[i][2] = st.deviceName;
dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);
HashMap<String, ArrayList<ArrayList<Integer>>> delayTime = timeDelayedPerRow.get(row);
boolean causeDelay = false;
if (delayTime.containsKey(st.deviceName)) {
for (Entry<String, ArrayList<ArrayList<Integer>>> entry : delayTime.entrySet()) {
if (entry.getKey().equals(st.deviceName)) {
ArrayList<ArrayList<Integer>> timeList = entry.getValue();
for (int j = 0; j < timeList.size(); j++) {
if (Integer.valueOf(st.startTime) > timeList.get(j).get(0) && Integer.valueOf(st.startTime) < timeList.get(j).get(1)) {
causeDelay = true;
dataByTaskRowDetails[i][5] = causeDelay;
return dataByTaskRowDetails;
// fill the Min max delay table on main latency analysis frame
public Object[][] latencyMinMaxAnalysis(String task12ID, String task22ID, Vector<SimulationTransaction> transFile1) {
List<Integer> times1MinMAx = new ArrayList<Integer>();
List<Integer> times2MinMAx = new ArrayList<Integer>();
String[] task1 = task12ID.split("__");
int task1index = task1.length;
idTask1 = task1[task1index - 1];
String[] task2 = task22ID.split("__");
int task2index = task2.length;
idTask2 = task2[task2index - 1];
String task12 = nameIDTaskList.get(idTask1);
String task22 = nameIDTaskList.get(idTask2);
times1MinMAx = times1;
times2MinMAx = times2;
HashMap<Integer, ArrayList<Integer>> minTimes = new HashMap<Integer, ArrayList<Integer>>();
for (int time1 : times1MinMAx) {
int match = Integer.MAX_VALUE;
// Find the first subsequent transaction
int time = Integer.MAX_VALUE;
for (int time2 : times2MinMAx) {
int diff = time2 - time1;
if (diff < time && diff >= 0) {
time = diff;
match = time2;
}
}
try {
if (times2MinMAx.contains(match)) {
times2MinMAx.remove(Integer.valueOf(match));
}
} catch (Exception e) {
}
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555
2556
2557
2558
2559
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591
2592
2593
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
if (time != Integer.MAX_VALUE) {
ArrayList<Integer> startEndT = new ArrayList<Integer>();
startEndT.add(time1);
startEndT.add(match);
minTimes.put(time, startEndT);
}
}
dataByTaskMinMax = new Object[2][5];
if (minTimes.size() > 0) {
Integer min = Collections.min(minTimes.keySet());
Integer max = Collections.max(minTimes.keySet());
dataByTaskMinMax = new Object[2][5];
ArrayList<Integer> numMax = minTimes.get(max);
ArrayList<Integer> numMin = minTimes.get(min);
dataByTaskMinMax[0][0] = task12;
dataByTaskMinMax[0][1] = numMin.get(0);
dataByTaskMinMax[0][2] = task22;
dataByTaskMinMax[0][3] = numMin.get(1);
dataByTaskMinMax[0][4] = min;
dataByTaskMinMax[1][0] = task12;
dataByTaskMinMax[1][1] = numMax.get(0);
dataByTaskMinMax[1][2] = task22;
dataByTaskMinMax[1][3] = numMax.get(1);
dataByTaskMinMax[1][4] = max;
}
return dataByTaskMinMax;
}
// fill the detailed latency table once a row is selected from min/max table
public Object[][] getTasksByRowMinMax(int row) {
Object[][] dataByTaskRowDetails = new Object[relatedsimTraces.size()][5];
int i = 0;
for (SimulationTransaction st : relatedsimTraces) {
dataByTaskRowDetails[i][0] = st.command;
dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
dataByTaskRowDetails[i][2] = st.deviceName;
dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);
i++;
}
return dataByTaskRowDetails;
}
// fill the tasks that run on the same hardware but don't belong to the path
// between selected activities
public Object[][] getTaskHWByRowDetailsMinMax(int row) {
Object[][] dataByTaskRowDetails = new Object[delayDueTosimTraces.size()][5];
int i = 0;
for (SimulationTransaction st : delayDueTosimTraces) {
dataByTaskRowDetails[i][0] = st.command;
dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
dataByTaskRowDetails[i][2] = st.deviceName;
dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
i++;
}
return dataByTaskRowDetails;
}
// import graph in .graphml format
public void importGraph(String filename) throws ExportException, IOException, ImportException {
FileReader ps = new FileReader(filename + ".graphml");
// gmlExporter.exportGraph(g, PS);
// FileWriter PS2 = new FileWriter(filename + "test.graphml");
VertexProvider<String> vertexProvider = (id, attributes) -> {
String cv = new String(id);
return cv;
};
EdgeProvider<String, DefaultEdge> edgeProvider = (from, to, label, attributes) -> new DefaultEdge();
GraphMLImporter<String, DefaultEdge> importer = new GraphMLImporter<String, DefaultEdge>(vertexProvider, edgeProvider);
Graph<String, DefaultEdge> importedGraph = null;
importer.importGraph(importedGraph, ps);
}
public List<TMLComponentDesignPanel> getCpanels() {
return cpanels;
}
public void setCpanels(List<TMLComponentDesignPanel> cpanels) {
this.cpanels = cpanels;
}