Newer
Older
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
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 (vertex vertex : g.vertexSet()) {
String[] vertexName = vertex.toString().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.toString());
if (sendEventWaitEventEdges.containsKey(eventName)) {
if (!sendEventWaitEventEdges.get(eventName).contains(vertex.toString())) {
sendEventWaitEventEdges.get(eventName).add(vertex.toString());
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
}
} else {
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 (vertex vertex : g.vertexSet()) {
String[] vertexName = vertex.toString().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.toString())) {
if (!sendEventWaitEventEdges.get(vertex.toString()).contains(eventName)) {
sendEventWaitEventEdges.get(vertex.toString()).add(eventName);
}
} else {
sendEventWaitEventEdges.put(vertex.toString(), waitEventVertex);
}
}
}
}
}
}
}
if (currentElement.getReferenceObject() instanceof TMLADWriteChannel) {
writeChannelTransactions.add(eventName);
String[] name = eventName.split("__");
String[] removewrite = name[2].split(":");
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (sendData.containsKey(portNameNoSpaces)) {
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
if (((TMLWriteChannel) currentElement).getChannel(0).getName().contains("FORKCHANNEL")
|| ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("FORKTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("FORKTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getName().contains("JOINCHANNEL")
|| ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("JOINTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("JOINTASK")
) {
sendDatachannels = sendData.get(portNameNoSpaces);
} else {
// sendDatachannels = name[0] + "__" + sendData.get(portNameNoSpaces) + "__" +
// name[0] + "__" + portNameNoSpaces;
sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces);
}
// String sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0]
// + "__" + sendData.get(portNameNoSpaces);
// if (sendDatachannels.contains("FORKPORTORIGIN")) {
// sendDatachannels= sendDatachannels.replace("FORKPORTORIGIN", "FORKCHANNEL");
//
// }
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(sendDatachannels);
if (writeReadChannelEdges.containsKey(eventName)) {
if (!writeReadChannelEdges.get(eventName).contains(sendDatachannels)) {
writeReadChannelEdges.get(eventName).add(sendDatachannels);
}
} else {
writeReadChannelEdges.put(eventName, writeChVertex);
// getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).getTaintFixedNumber()
// + 1);
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(chwriteName);
if (writeReadChannelEdges.containsKey(eventName)) {
if (!writeReadChannelEdges.get(eventName).contains(chwriteName)) {
writeReadChannelEdges.get(eventName).add(chwriteName);
}
} else {
writeReadChannelEdges.put(eventName, writeChVertex);
// getvertex(chwriteName).setTaintFixedNumber(getvertex(chwriteName).getTaintFixedNumber()
// + 1);
}
}
if (currentElement.getReferenceObject() instanceof TMLADReadChannel) {
readChannelTransactions.add(eventName);
String[] name = eventName.split("__");
String[] removewrite = name[2].split(":");
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (receiveData.containsKey(portNameNoSpaces)) {
String sendDatachannels;
if (((TMLReadChannel) currentElement).getChannel(0).getName().contains("FORKCHANNEL")
|| ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("FORKTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("FORKTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getName().contains("JOINCHANNEL")
|| ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("JOINTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("JOINTASK")) {
sendDatachannels = receiveData.get(portNameNoSpaces);
} else {
sendDatachannels = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__" + name[0] + "__" + portNameNoSpaces;
HashSet<String> readChVertex = new HashSet<String>();
if (readWriteChannelEdges.containsKey(sendDatachannels)) {
if (!readWriteChannelEdges.get(sendDatachannels).contains(eventName)) {
readWriteChannelEdges.get(sendDatachannels).add(eventName);
}
} else {
readWriteChannelEdges.put(sendDatachannels, readChVertex);
// getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).getTaintFixedNumber()
// + 1);
/*
* if (g.containsVertex(chwriteName))
* { g.addEdge(chwriteName, eventName); }
*/
} else {
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(eventName);
if (readWriteChannelEdges.containsKey(chwriteName)) {
if (!readWriteChannelEdges.get(chwriteName).contains(eventName)) {
readWriteChannelEdges.get(chwriteName).add(eventName);
}
} else {
readWriteChannelEdges.put(chwriteName, readChVertex);
}
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
}
}
}
// 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());
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
getOutputConnectors = ((TMLADForStaticLoop) (currentElement.getReferenceObject())).getOutputConnectors();
String loopValue = ((TMLADForStaticLoop) (currentElement.getReferenceObject())).getValue();
getvertex(eventName).setType(vertex.TYPE_STATIC_FOR_LOOP);
if ((loopValue != null) && (loopValue.length() > 0)) {
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
} else {
for (TMLAttribute att : task.getAttributes()) {
if (loopValue.contains(att.getName())) {
loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
}
}
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
}
}
} else if (currentElement.getReferenceObject() instanceof TMLADForLoop) {
points = Arrays.asList(((TMLADForLoop) (currentElement.getReferenceObject())).getConnectingPoints());
2300
2301
2302
2303
2304
2305
2306
2307
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
getOutputConnectors = ((TMLADForLoop) (currentElement.getReferenceObject())).getOutputConnectors();
// String loopValue = ((TMLADForLoop)
// (currentElement.getReferenceObject())).getValue();
getvertex(eventName).setType(vertex.TYPE_FOR_LOOP);
String cond = ((TMLADForLoop) (currentElement.getReferenceObject())).getCondition();
if (cond.contains("<=")) {
String[] val = cond.split("<=");
String loopValue = val[2].toString();
if ((loopValue != null) && (loopValue.length() > 0)) {
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
} else {
for (TMLAttribute att : task.getAttributes()) {
if (loopValue.contains(att.getName())) {
loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
}
}
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
}
}
} else if (cond.contains("<")) {
String[] val = cond.split("<");
String loopValue = val[1].toString();
if ((loopValue != null) && (loopValue.length() > 0)) {
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
} else {
for (TMLAttribute att : task.getAttributes()) {
if (loopValue.contains(att.getName())) {
loopValue = loopValue.replace(att.getName(), (att.getInitialValue()));
}
}
if ((loopValue.matches("\\d*"))) {
getvertex(eventName).setTaintFixedNumber(Integer.valueOf(loopValue));
}
{
frameLatencyDetailedAnalysis
.error(loopValue + " Expression in For Loop is not supported by Tainting");
}
}
}
}
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
}
TGConnector inputConnector = null, outputConnector = null;
for (TGConnector connector : getOutputConnectors) {
if (connector.getTGConnectingPointP1() == points.get(1)) {
inputConnector = connector;
} else if (connector.getTGConnectingPointP1() == points.get(2)) {
outputConnector = connector;
}
}
List<String> afterloopActivity = new ArrayList<String>(2);
String insideLoop = "", outsideLoop = "";
for (TMLActivityElement ae : currentElement.getNexts()) {
List<TGConnector> cg = (((TGComponent) ae.getReferenceObject()).getInputConnectors());
for (TGConnector afterloopcg : cg) {
if (afterloopcg == inputConnector) {
if (ae.getReferenceObject() instanceof TMLADRandom) {
insideLoop = task.getName() + "__" + ae.getName() + "__" + ae.getID();
} else {
insideLoop = task.getName() + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
}
} else if (afterloopcg == outputConnector) {
if (ae.getReferenceObject() instanceof TMLADRandom) {
outsideLoop = task.getName() + "__" + ae.getName() + "__" + ae.getID();
} else {
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) {
getvertex(eventName).setType(vertex.TYPE_SEQ);
getvertex(eventName).setTaintFixedNumber(1);
2425
2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
2447
2448
2449
2450
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) {
getvertex(eventName).setType(vertex.TYPE_UNORDER_SEQ);
getvertex(eventName).setTaintFixedNumber(1);
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
2467
2468
2469
2470
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
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);
}
allForLoopNextValues.putAll(forLoopNextValues);
}
}
}
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<vertex, DefaultEdge> graphAdapter = new JGraphXAdapter<vertex, 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<vertex> vertexIDProvider = new ComponentNameProvider<vertex>() {
public String getName(vertex vertex) {
String name;
for (vertex v : g.vertexSet()) {
if (v.getId().equals(vertex.getId())) {
name = vertex.getId().toString().replaceAll("\\s+", "");
name = vertex.getId().replaceAll("\\(", "\\u0028");
name = vertex.getId().replaceAll("\\)", "\\u0029");
return name;
}
}
return null;
}
};
ComponentNameProvider<vertex> vertexNameProvider = new ComponentNameProvider<vertex>() {
public String getName(vertex arg0) {
for (vertex v : g.vertexSet()) {
if (v.getId().equals(arg0.getId())) {
return arg0.getId();
}
}
return null;
};
ComponentNameProvider<DefaultEdge> edgeIDProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
String source = g.getEdgeSource(edge).toString().replaceAll("\\s+", "");
source = source.replaceAll("\\(", "\\u0028");
source = source.replaceAll("\\)", "\\u0029");
// .replaceAll("\\(", "");
// source.replaceAll("\\)", "");
String target = g.getEdgeTarget(edge).toString().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<vertex, DefaultEdge> exporter = new GraphMLExporter<vertex, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
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
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
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, Boolean taint,
Boolean considerAddedRules) {
for (vertex v : g.vertexSet()) {
v.setLabel(new ArrayList<String>());
v.setMaxTaintFixedNumber(new HashMap<String, Integer>());
v.setTaintConsideredNumber(new HashMap<String, Integer>());
v.setVirtualLengthAdded(0);
v.setSampleNumber(0);
}
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);
vertex v1 = getvertex(task12);
Vector<SimulationTransaction> Task1Traces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> Task2Traces = new Vector<SimulationTransaction>();
HashMap<String, Vector<String>> Task1TaintedTraces = new LinkedHashMap<String, Vector<String>>();
HashMap<String, Vector<String>> Task2TaintedTraces = new LinkedHashMap<String, Vector<String>>();
GraphPath<vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(task22));
// 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<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
}
}
} else {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
GraphPath<vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
GraphPath<vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName), getvertex(task22));
if ((pathTochannel != null && pathTochannel.getLength() > 0) || (pathFromChannel != null && pathFromChannel.getLength() > 0)) {
devicesToBeConsidered.addAll(busChList);
}
}
}
Collections.sort(transFile1, new Comparator<SimulationTransaction>() {
public int compare(SimulationTransaction o1, SimulationTransaction o2) {
BigDecimal t1 = new BigDecimal(o1.startTime);
BigDecimal t2 = new BigDecimal(o2.startTime);
int startTimeEq = t1.compareTo(t2);
if (startTimeEq == 0) {
BigDecimal t1End = new BigDecimal(o1.endTime);
BigDecimal t2End = new BigDecimal(o2.endTime);
return t1End.compareTo(t2End);
}
return startTimeEq;
if (taint) {
for (SimulationTransaction st : transFile1) {
if (task1DeviceName.isEmpty()) {
if (st.id.equals(idTask1)) {
task1DeviceName = st.deviceName;
}
}
if (task2DeviceName.isEmpty()) {
if (st.id.equals(idTask2)) {
task2DeviceName = st.deviceName;
}
}
if (!task1DeviceName.isEmpty() && !task2DeviceName.isEmpty()) {
break;
for (SimulationTransaction st : transFile1) {
// ADD rules as edges
if (considerAddedRules) {
if (ruleAddedEdges.size() > 0) {
for (Entry<vertex, List<vertex>> rulevertex : ruleAddedEdges.entrySet()) {
vertex fromVertex = rulevertex.getKey();
List<vertex> listOfToV = rulevertex.getValue();
for (vertex toVertex : listOfToV) {
if (g.containsVertex(toVertex) && g.containsVertex(fromVertex)) {
g.addEdge(fromVertex, toVertex);
}
}
// if st started and ended before the first call of operator- don't consider it
// if (!(Integer.valueOf(st.startTime) < times1.get(0) &&
// Integer.valueOf(st.endTime) < times1.get(0))) {
for (Entry<String, ArrayList<String>> entry : channelPaths.entrySet()) {
String ChannelName = entry.getKey();
ArrayList<String> busChList = entry.getValue();
String bus1 = "";
for (String busName : busChList) {
String[] bus = st.deviceName.split("_");
if (bus.length > 2) {
for (int i = 0; i < bus.length - 1; i++) {
if (i == 0) {
bus1 = bus[i];
} else {
bus1 = bus1 + "_" + bus[i];
}
if (bus1.equals(busName) && st.channelName.equals(ChannelName)) {
tasknameCheckID = ChannelName;
taskname = getvertex(ChannelName).getId();
}
for (vertex tasknameCheck : g.vertexSet()) {
String[] taskToAdd = tasknameCheck.toString().replaceAll(" ", "").split("__");
int taskToAddindex = taskToAdd.length;
String taskToAddid = taskToAdd[taskToAddindex - 1];
if (Integer.valueOf(taskToAddid).equals(Integer.valueOf(st.id))) {
taskname = tasknameCheck.toString();
tasknameCheckID = tasknameCheck.getId();
if (taskname.equals(task12) && task1DeviceName.equals(st.deviceName)) {
if (Task1TaintedTraces.containsKey(tasknameCheck.getLastLabel())) {
Task1TaintedTraces.get(tasknameCheck.getLastLabel()).add(st.startTime);
} else {
Vector<String> Task1TracesTD = new Vector<String>();
Task1TaintedTraces.put(tasknameCheck.getLastLabel(), Task1TracesTD);
times1.add(Integer.valueOf(st.startTime));
Collections.sort(times1);
}
}
}
}
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
if (Graphs.vertexHasSuccessors(g, getvertex(tasknameCheckID)) && !getvertex(tasknameCheckID).getLabel().isEmpty()) {
for (vertex v : Graphs.successorListOf(g, getvertex(tasknameCheckID))) {
String labelToaAddtoV = getfirstCommonLabel(v, getvertex(tasknameCheckID));
// removed after testing in for loop/ action/choice
/*
* if (Graphs.vertexHasPredecessors(g, getvertex(tasknameCheckID))) { for
* (vertex previousV : Graphs.predecessorListOf(g, getvertex(tasknameCheckID)))
* { if (previousV.getType() == vertex.TYPE_CHOICE) {
*
* for (Entry<vertex, List<vertex>> vChoice : allChoiceValues.entrySet()) {
*
* if (previousV.equals(vChoice.getKey())) {
*
* if (previousV.getLabel().contains(labelToaAddtoV)) {
*
* for (vertex cVertex : allChoiceValues.get(vChoice.getKey())) {
*
* if (!cVertex.equals(getvertex(tasknameCheckID))) {
*
* if (cVertex.getLabel().contains(labelToaAddtoV)) {
* cVertex.getLabel().remove(labelToaAddtoV);
*
* }
*
* if (cVertex.getMaxTaintFixedNumber().containsKey(labelToaAddtoV)) {
* cVertex.getMaxTaintFixedNumber().remove(labelToaAddtoV);
*
* }
*
* if (cVertex.getTaintConsideredNumber().containsKey(labelToaAddtoV)) {
* cVertex.getTaintConsideredNumber().remove(labelToaAddtoV);
*
* } } }
*
* }
*
* }
*
* }
*
* } } }
*/
if (v.getType() == vertex.TYPE_CHANNEL || v.getType() == vertex.TYPE_TRANSACTION) {
if (v.getLabel().contains(labelToaAddtoV)) {
if (v.getMaxTaintFixedNumber().containsKey(labelToaAddtoV)) {
if (v.getMaxTaintFixedNumber().get(labelToaAddtoV) != v.getTaintFixedNumber()) {
v.getMaxTaintFixedNumber().put(labelToaAddtoV,
v.getMaxTaintFixedNumber().get(labelToaAddtoV) * v.getTaintFixedNumber());
}
}
} else {
v.addLabel(labelToaAddtoV);
v.getMaxTaintFixedNumber().put(labelToaAddtoV, v.getTaintFixedNumber());
}
for (vertex subV : Graphs.successorListOf(g, v)) {
if (!(subV.getType() == vertex.TYPE_TRANSACTION || subV.getType() == vertex.TYPE_CHANNEL)) {
HashMap<vertex, List<vertex>> NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
HashMap<vertex, List<vertex>> NonTransVertexes2 = new LinkedHashMap<vertex, List<vertex>>();
HashMap<vertex, List<vertex>> NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
NonTransVertexes.putAll(taintingNonTransVertexes(v, getvertex(tasknameCheckID), v1));
for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
vertex vet = e.getKey();
List<vertex> vl = e.getValue();
NonTransVertexes2 = taintingNonTransVertexes(ver, vet, v1);
NonTransVertexesAdded.putAll(NonTransVertexes2);
// NonTransVertexes.putAll(taintingNonTransVertexes(ver, vet, v1));
addeditems = addeditems + NonTransVertexes2.size();
NonTransVertexes = new LinkedHashMap<vertex, List<vertex>>();
NonTransVertexes.putAll(NonTransVertexesAdded);
NonTransVertexesAdded = new LinkedHashMap<vertex, List<vertex>>();
for (Entry<vertex, List<vertex>> e : NonTransVertexes.entrySet()) {
vertex vet = e.getKey();
List<vertex> vl = e.getValue();