| /******************************************************************************* |
| * CHESS monitoring plugin |
| * |
| * Copyright (C) 2015-2016 |
| * Mälardalen University, Sweden |
| * |
| * |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License |
| * v1.0 which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| *******************************************************************************/ |
| |
| package org.polarsys.chess.monitoring.traceanalyser; |
| |
| import java.io.BufferedReader; |
| import java.io.BufferedWriter; |
| import java.io.File; |
| import java.io.FileReader; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.util.ArrayList; |
| |
| import javax.xml.parsers.DocumentBuilderFactory; |
| import javax.xml.parsers.DocumentBuilder; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.polarsys.chess.core.util.CHESSProjectSupport; |
| import org.polarsys.chess.monitoring.traceanalyser.Event; |
| import org.w3c.dom.Document; |
| import org.w3c.dom.NodeList; |
| import org.w3c.dom.Node; |
| import org.w3c.dom.Element; |
| |
| |
| /** |
| * The Class TraceReader. |
| */ |
| public class TraceReader |
| { |
| |
| /** The time stamp column. */ |
| private int time_Stamp_Column = 0; |
| |
| /** The event I D column. */ |
| private int event_ID_Column = 1; |
| |
| /** The thread I D column. */ |
| private int thread_ID_Column = 2; |
| |
| /** The clockrate. */ |
| private double clockrate = 1; |
| |
| /** The trace file name. */ |
| private String traceFileName; |
| |
| /** The thread specific events. */ |
| private ArrayList<ArrayList<Event>> threadSpecificEvents; |
| |
| /** The thread I ds. */ |
| private ArrayList<String> threadIDs; |
| |
| /** The analysis context. */ |
| private String analysisContext; |
| |
| /** |
| * Instantiates a new trace reader. |
| * |
| * @param traceFile the trace file |
| * @param threadIDsFile the thread I ds file |
| * @param delimiter the delimiter |
| */ |
| public TraceReader(IFile traceFile, IFile threadIDsFile, String delimiter) |
| { |
| traceFileName = traceFile.getLocation().toOSString(); |
| analysisContext = GetAnalysisContext(threadIDsFile.getLocation().toOSString()); |
| threadIDs = new ArrayList<String>(); |
| threadIDs = GetThreadIDs(threadIDsFile.getLocation().toOSString()); // the order in which threadIDs are provide will be used to maintain the events related that threadid in threadSpecificEvents |
| |
| if(threadIDs.size() == 0) |
| { |
| CHESSProjectSupport.printlnToCHESSConsole("Error: No thread ID to analyze."); |
| System.exit(0); |
| } |
| |
| threadSpecificEvents = new ArrayList<ArrayList<Event>>(); |
| |
| for(int i=0; i<threadIDs.size(); i++) |
| { |
| threadSpecificEvents.add(new ArrayList<Event>()); |
| } |
| ReadTraceFile(delimiter); |
| } |
| |
| /** |
| * Gets the analysis context. |
| * |
| * @param fileName the file name |
| * @return the string |
| */ |
| private String GetAnalysisContext(String fileName) |
| { |
| String analContext = null; |
| try |
| { |
| File fXmlFile = new File(fileName); |
| DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); |
| Document doc = dBuilder.parse(fXmlFile); |
| |
| doc.getDocumentElement().normalize(); |
| |
| NodeList contexts = doc.getElementsByTagName("analysisContext"); |
| Node context = contexts.item(0); |
| if(context.getNodeType() == Node.ELEMENT_NODE) |
| { |
| Element elem = (Element)context; |
| analContext = elem.getAttribute("name"); |
| } |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| return analContext; |
| } |
| |
| /** |
| * Gets the thread I ds. |
| * |
| * @param fileName the file name |
| * @return the array list |
| */ |
| private ArrayList<String> GetThreadIDs(String fileName) |
| { |
| ArrayList<String> threadNames = new ArrayList<String>(); |
| try |
| { |
| File fXmlFile = new File(fileName); |
| DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); |
| DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); |
| Document doc = dBuilder.parse(fXmlFile); |
| |
| doc.getDocumentElement().normalize(); |
| |
| NodeList contexts = doc.getElementsByTagName("analysisContext"); |
| Node context = contexts.item(0); |
| if(context.getNodeType() == Node.ELEMENT_NODE) |
| { |
| Element elem = (Element)context; |
| this.analysisContext = elem.getAttribute("name"); |
| } |
| |
| NodeList allthreads = doc.getElementsByTagName("ThreadNames"); |
| |
| for (int i = 0; i < allthreads.getLength(); i++) |
| { |
| Node thread = allthreads.item(i); |
| if (thread.getNodeType() == Node.ELEMENT_NODE) |
| { |
| Element eElement = (Element) thread; |
| threadNames.add(eElement.getAttribute("name"));//.getElementsByTagName("name").item(0).getTextContent()); |
| } |
| } |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| } |
| return threadNames; |
| } |
| |
| |
| /** |
| * Read trace file. |
| * |
| * @param delimiter the delimiter |
| */ |
| private void ReadTraceFile(String delimiter) |
| { |
| try |
| { |
| FileReader file = new FileReader(traceFileName); |
| BufferedReader br = new BufferedReader(file); |
| String strLine; |
| Event event ; |
| Boolean firstLine = true; |
| |
| // strLine = br.readLine(); |
| // if(strLine != null) |
| // { |
| // strLine = strLine.trim(); |
| // String[] strEvent = strLine.split(delimiter); |
| // |
| // if(strEvent.length == 2 && strEvent[0].equals("clockrate")) |
| // { |
| // clockrate=Double.parseDouble(strEvent[1]); |
| // } |
| // else |
| // { |
| // //assume rate=1 |
| // clockrate=1; |
| // CHESSProjectSupport.printlnToCHESSConsole("Clockrate is not available: 1 will be assumed"); |
| // br.close(); |
| // return; |
| // } |
| // } |
| |
| while ((strLine = br.readLine()) != null) |
| { |
| |
| strLine = strLine.trim(); |
| String[] strEvent = strLine.split(delimiter); |
| |
| if (firstLine){ |
| if(strEvent.length == 2 && strEvent[0].equals("clockrate")) |
| { |
| clockrate=Double.parseDouble(strEvent[1]); |
| continue; |
| } |
| else |
| { |
| //assume rate=1 |
| clockrate=1; |
| CHESSProjectSupport.printlnToCHESSConsole("Clockrate is not available: 1 will be assumed"); |
| } |
| firstLine = false; |
| } |
| |
| if(strEvent.length ==3) |
| { |
| event = new Event(Long.parseLong(strEvent[time_Stamp_Column]), Integer.parseInt(strEvent[event_ID_Column]), strEvent[thread_ID_Column]); |
| |
| if(threadIDs.contains(event.GetThreadID())) |
| threadSpecificEvents.get(threadIDs.indexOf(event.GetThreadID())).add(event); |
| } |
| else |
| { |
| CHESSProjectSupport.printlnToCHESSConsole("Error: Some events do not follow the expected trace format."); |
| br.close(); |
| return; |
| } |
| } |
| br.close(); |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * Prints the thread specific events. |
| * |
| * @param tid the tid |
| */ |
| public void PrintThreadSpecificEvents(String tid) |
| { |
| int indexOfThread = threadIDs.indexOf(tid); |
| |
| CHESSProjectSupport.printlnToCHESSConsole("Time Stamp \t EventID \t ThreadID"); |
| for(Event event : threadSpecificEvents.get(indexOfThread)) |
| CHESSProjectSupport.printlnToCHESSConsole(event.GetTimeStamp()+"\t"+event.GetEventID() +"\t"+ event.GetThreadID()); |
| } |
| |
| /** |
| * Write thread specific events into file. |
| * |
| * @param tid the tid |
| */ |
| public void WriteThreadSpecificEventsIntoFile(String tid) |
| { |
| int indexOfThread = threadIDs.indexOf(tid); |
| |
| FileWriter filewrite; |
| try { |
| filewrite = new FileWriter(tid.concat(".txt"), false); |
| BufferedWriter out = new BufferedWriter(filewrite); |
| |
| for(Event event : threadSpecificEvents.get(indexOfThread)) |
| out.write(event.GetTimeStamp()+"\t"+event.GetEventID() +"\t"+ event.GetThreadID()+"\n"); |
| |
| out.close(); |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(); |
| } |
| } |
| |
| /** |
| * *********** |
| * Getters |
| * **********. |
| * |
| * @return the array list |
| */ |
| public ArrayList<String> GetThreadIDs() |
| { |
| return threadIDs; |
| } |
| |
| /** |
| * Gets the analysis context. |
| * |
| * @return the string |
| */ |
| public String GetAnalysisContext() |
| { |
| return this.analysisContext; |
| } |
| |
| /** |
| * Gets the thread specific events. |
| * |
| * @return the array list |
| */ |
| public ArrayList<ArrayList<Event>> GetThreadSpecificEvents() |
| { |
| return threadSpecificEvents; |
| } |
| |
| /** |
| * Gets the thread id of given events. |
| * |
| * @param eventsList the events list |
| * @return the string |
| */ |
| public String GetThreadIdOfGivenEvents(ArrayList<ArrayList<Integer>> eventsList) |
| { |
| if(threadSpecificEvents.contains(eventsList)) |
| return threadIDs.get(threadSpecificEvents.indexOf(eventsList)); |
| else |
| return null; |
| } |
| |
| /** |
| * Gets the thread ID column. |
| * |
| * @return the int |
| */ |
| public int GetThreadIDColumn() |
| { |
| return thread_ID_Column; |
| } |
| |
| /** |
| * Gets the event ID column. |
| * |
| * @return the int |
| */ |
| public int GetEventIDColumn() |
| { |
| return event_ID_Column; |
| } |
| |
| /** |
| * Gets the time stamp column. |
| * |
| * @return the int |
| */ |
| public int GetTimeStampColumn() |
| { |
| return time_Stamp_Column; |
| } |
| |
| /** |
| * Gets the clock rate. |
| * |
| * @return the double |
| */ |
| public double GetClockRate() |
| { |
| return clockrate; |
| } |
| } |
| |
| |
| |
| |
| |