/*******************************************************************************
- * Copyright (c) 2011-2012 Ericsson, Ecole Polytechnique de Montreal and others
+ * Copyright (c) 2011, 2013 Ericsson, Ecole Polytechnique de Montreal and others
*
* 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
*
- * Contributors: Matthew Khouzam - Initial API and implementation
- * Contributors: Alexandre Montplaisir - Initial API and implementation
+ * Contributors:
+ * Matthew Khouzam - Initial API and implementation
+ * Alexandre Montplaisir - Initial API and implementation
+ * Simon Delisle - Replace LinkedList by TreeSet in callsitesByName attribute
*******************************************************************************/
package org.eclipse.linuxtools.ctf.core.trace;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
+import java.util.TreeSet;
import java.util.UUID;
+import org.eclipse.linuxtools.ctf.core.event.CTFCallsite;
import org.eclipse.linuxtools.ctf.core.event.CTFClock;
-import org.eclipse.linuxtools.ctf.core.event.EventDeclaration;
import org.eclipse.linuxtools.ctf.core.event.EventDefinition;
+import org.eclipse.linuxtools.ctf.core.event.IEventDeclaration;
+import org.eclipse.linuxtools.ctf.core.event.io.BitBuffer;
import org.eclipse.linuxtools.ctf.core.event.types.ArrayDefinition;
import org.eclipse.linuxtools.ctf.core.event.types.Definition;
import org.eclipse.linuxtools.ctf.core.event.types.IDefinitionScope;
import org.eclipse.linuxtools.ctf.core.event.types.IntegerDefinition;
import org.eclipse.linuxtools.ctf.core.event.types.StructDeclaration;
import org.eclipse.linuxtools.ctf.core.event.types.StructDefinition;
-import org.eclipse.linuxtools.internal.ctf.core.event.io.BitBuffer;
+import org.eclipse.linuxtools.internal.ctf.core.event.CTFCallsiteComparator;
import org.eclipse.linuxtools.internal.ctf.core.event.metadata.exceptions.ParseException;
-import org.eclipse.linuxtools.internal.ctf.core.trace.Stream;
-import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInput;
-import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInputPacketIndex;
/**
* A CTF trace on the file system.
*/
public class CTFTrace implements IDefinitionScope {
- /*
- * (non-Javadoc)
- *
- * @see java.lang.Object#toString()
- */
@SuppressWarnings("nls")
@Override
public String toString() {
*/
private final File path;
- /**
- * The metadata parsing object.
- */
- private final Metadata metadata;
-
/**
* Major CTF version number
*/
/**
* Collection of streams contained in the trace.
*/
- private final HashMap<Long, Stream> streams;
+ private final Map<Long, Stream> streams = new HashMap<Long, Stream>();
/**
* Collection of environment variables set by the tracer
*/
- private final HashMap<String, String> environment;
+ private final Map<String, String> environment = new HashMap<String, String>();
/**
* Collection of all the clocks in a system.
*/
- private final HashMap<String, CTFClock> clocks;
+ private final Map<String, CTFClock> clocks = new HashMap<String, CTFClock>();
- /** FileChannels to the streams */
- private final List<FileChannel> streamFileChannels;
+ /** FileInputStreams to the streams */
+ private final List<FileInputStream> fileInputStreams = new LinkedList<FileInputStream>();
/** Handlers for the metadata files */
- private final static FileFilter metadataFileFilter = new MetadataFileFilter();
- private final static Comparator<File> metadataComparator = new MetadataComparator(); // $codepro.audit.disable
- // fieldJavadoc
+ private static final FileFilter METADATA_FILE_FILTER = new MetadataFileFilter();
+ private static final Comparator<File> METADATA_COMPARATOR = new MetadataComparator();
/** map of all the event types */
- private final HashMap<Long,HashMap<Long, EventDeclaration>> eventDecs;
- /** map of all the event types */
- private final HashMap<StreamInput,HashMap<Long, EventDefinition>> eventDefs;
- /** map of all the indexes */
- private final HashMap<StreamInput, StreamInputPacketIndex> indexes;
+ private final Map<Long, HashMap<Long, IEventDeclaration>> eventDecs = new HashMap<Long, HashMap<Long, IEventDeclaration>>();
+
+ /** Callsite helpers */
+ private CTFCallsiteComparator ctfCallsiteComparator = new CTFCallsiteComparator();
+ private Map<String, TreeSet<CTFCallsite>> callsitesByName = new HashMap<String, TreeSet<CTFCallsite>>();
+ /** Callsite helpers */
+ private TreeSet<CTFCallsite> callsitesByIP = new TreeSet<CTFCallsite>();
// ------------------------------------------------------------------------
// Constructors
*/
public CTFTrace(File path) throws CTFReaderException {
this.path = path;
- this.metadata = new Metadata(this);
+ final Metadata metadata = new Metadata(this);
/* Set up the internal containers for this trace */
- streams = new HashMap<Long, Stream>();
- environment = new HashMap<String, String>();
- clocks = new HashMap<String, CTFClock>();
- streamFileChannels = new LinkedList<FileChannel>();
- eventDecs = new HashMap<Long, HashMap<Long, EventDeclaration>>();
- eventDefs = new HashMap<StreamInput, HashMap<Long, EventDefinition>>();
+ if (!this.path.exists()) {
+ throw new CTFReaderException("Trace (" + path.getPath() + ") doesn't exist. Deleted or moved?"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
if (!this.path.isDirectory()) {
throw new CTFReaderException("Path must be a valid directory"); //$NON-NLS-1$
/* Open all the trace files */
/* Create the definitions needed to read things from the files */
if (packetHeaderDecl != null) {
- packetHeaderDef = packetHeaderDecl.createDefinition(this,
- "packet.header"); //$NON-NLS-1$
+ packetHeaderDef = packetHeaderDecl.createDefinition(this, "packet.header"); //$NON-NLS-1$
}
/* List files not called metadata and not hidden. */
- File[] files = path.listFiles(metadataFileFilter);
- Arrays.sort(files, metadataComparator);
- indexes = new HashMap<StreamInput, StreamInputPacketIndex>();
+ File[] files = path.listFiles(METADATA_FILE_FILTER);
+ Arrays.sort(files, METADATA_COMPARATOR);
/* Try to open each file */
for (File streamFile : files) {
openStreamInput(streamFile);
/*
* Copy the events
*/
- Iterator<Entry<Long, EventDeclaration>> it = s.getStream()
+ Iterator<Entry<Long, IEventDeclaration>> it = s.getStream()
.getEvents().entrySet().iterator();
while (it.hasNext()) {
- Map.Entry<Long, EventDeclaration> pairs = it.next();
+ Entry<Long, IEventDeclaration> pairs = it.next();
Long eventNum = pairs.getKey();
- EventDeclaration eventDec = pairs.getValue();
+ IEventDeclaration eventDec = pairs.getValue();
getEvents(s.getStream().getId()).put(eventNum, eventDec);
}
}
}
- @Override
- protected void finalize() throws Throwable {
- /* If this trace gets closed, release the descriptors to the streams */
- for (FileChannel fc : streamFileChannels) {
- if (fc != null) {
+ /**
+ * Dispose the trace
+ *
+ * @since 2.0
+ */
+ public void dispose() {
+ for (FileInputStream fis : fileInputStreams) {
+ if (fis != null) {
try {
- fc.close();
+ fis.close();
} catch (IOException e) {
// do nothing it's ok, we tried to close it.
}
}
}
- super.finalize();
-
+ // Invoke GC to release MappedByteBuffer objects (Java bug JDK-4724038)
+ System.gc();
}
// ------------------------------------------------------------------------
* @param streamId
* The ID of the stream from which to read
* @return The Hash map with the event declarations
+ * @since 2.0
*/
- public HashMap<Long, EventDeclaration> getEvents(Long streamId) {
+ public Map<Long, IEventDeclaration> getEvents(Long streamId) {
return eventDecs.get(streamId);
}
- /**
- * Gets an index for a given StreamInput
- * @param id the StreamInput
- * @return The index
- */
- public StreamInputPacketIndex getIndex(StreamInput id){
- if(! indexes.containsKey(id)){
- indexes.put(id, new StreamInputPacketIndex());
- }
- return indexes.get(id);
- }
-
/**
* Gets an event Declaration hashmap for a given StreamInput
- * @param id the StreamInput
- * @return the hashmap with the event definitions
+ *
+ * @param id
+ * the StreamInput
+ * @return an empty hashmap, please see deprecated
+ * @since 2.0
+ * @deprecated You should be using
+ * {@link StreamInputReader#getEventDefinitions()} instead.
*/
- public HashMap<Long, EventDefinition> getEventDefs(StreamInput id) {
- if(! eventDefs.containsKey(id)){
- eventDefs.put(id, new HashMap<Long, EventDefinition>());
- }
- return eventDefs.get(id);
+ @Deprecated
+ public Map<Long, EventDefinition> getEventDefs(StreamInput id) {
+ return new HashMap<Long, EventDefinition>();
}
/**
* @param id
* the ID of the event
* @return the event declaration
+ * @since 2.0
*/
- public EventDeclaration getEventType(long streamId, long id) {
+ public IEventDeclaration getEventType(long streamId, long id) {
return getEvents(streamId).get(id);
}
* @param id
* Long the id of the stream
* @return Stream the stream that we need
+ * @since 2.0
*/
public Stream getStream(Long id) {
return streams.get(id);
}
/**
- * Method majortIsSet is the major version number set?
+ * Method majorIsSet is the major version number set?
*
* @return boolean is the major set?
*/
- public boolean majortIsSet() {
+ public boolean majorIsSet() {
return major != null;
}
* Method UUIDIsSet is the UUID set?
*
* @return boolean is the UUID set?
+ * @since 2.0
*/
- public boolean UUIDIsSet() {
+ public boolean uuidIsSet() {
return uuid != null;
}
*
* @return ByteOrder gets the trace byte order
*/
- public ByteOrder getByteOrder() {
+ public final ByteOrder getByteOrder() {
return byteOrder;
}
try {
/* Open the file and get the FileChannel */
- fc = new FileInputStream(streamFile).getChannel();
- streamFileChannels.add(fc);
+ FileInputStream fis = new FileInputStream(streamFile);
+ fileInputStreams.add(fis);
+ fc = fis.getChannel();
/* Map one memory page of 4 kiB */
- byteBuffer = fc.map(MapMode.READ_ONLY, 0, 4096);
+ byteBuffer = fc.map(MapMode.READ_ONLY, 0, (int) Math.min(fc.size(), 4096L));
} catch (IOException e) {
/* Shouldn't happen at this stage if every other check passed */
- throw new CTFReaderException();
+ throw new CTFReaderException(e);
}
/* Create a BitBuffer with this mapping and the trace byte order */
/* Read the stream ID */
Definition streamIDDef = packetHeaderDef.lookupDefinition("stream_id"); //$NON-NLS-1$
- if (streamIDDef instanceof IntegerDefinition) { //this doubles as a null check
+ if (streamIDDef instanceof IntegerDefinition) { // this doubles as a
+ // null check
long streamID = ((IntegerDefinition) streamIDDef).getValue();
stream = streams.get(streamID);
} else {
stream = streams.get(null);
}
+ if (stream == null) {
+ throw new CTFReaderException("Unexpected end of stream"); //$NON-NLS-1$
+ }
+
/* Create the stream input */
StreamInput streamInput = new StreamInput(stream, fc, streamFile);
* A stream object.
* @throws ParseException
* If there was some problem reading the metadata
+ * @since 2.0
*/
public void addStream(Stream stream) throws ParseException {
/* It should be ok now. */
streams.put(stream.getId(), stream);
- eventDecs.put(stream.getId(), new HashMap<Long,EventDeclaration>());
+ eventDecs.put(stream.getId(), new HashMap<Long, IEventDeclaration>());
}
/**
* gets the Environment variables from the trace metadata (See CTF spec)
- * @return the environment variables in a hashmap form (key value)
+ *
+ * @return the environment variables in a map form (key value)
+ * @since 2.0
*/
- public HashMap<String, String> getEnvironment() {
+ public Map<String, String> getEnvironment() {
return environment;
}
/**
* Look up a specific environment variable
- * @param key the key to look for
+ *
+ * @param key
+ * the key to look for
* @return the value of the variable, can be null.
*/
public String lookupEnvironment(String key) {
/**
* Add a variable to the environment variables
- * @param varName the name of the variable
- * @param varValue the value of the variable
+ *
+ * @param varName
+ * the name of the variable
+ * @param varValue
+ * the value of the variable
*/
public void addEnvironmentVar(String varName, String varValue) {
environment.put(varName, varValue);
/**
* Add a clock to the clock list
- * @param nameValue the name of the clock (full name with scope)
- * @param ctfClock the clock
+ *
+ * @param nameValue
+ * the name of the clock (full name with scope)
+ * @param ctfClock
+ * the clock
*/
public void addClock(String nameValue, CTFClock ctfClock) {
clocks.put(nameValue, ctfClock);
/**
* gets the clock with a specific name
- * @param name the name of the clock.
+ *
+ * @param name
+ * the name of the clock.
* @return the clock
*/
public CTFClock getClock(String name) {
return clocks.get(name);
}
-
-
-
/**
* gets the clock if there is only one. (this is 100% of the use cases as of
* June 2012)
*
* @return the time offset of a clock with respect to UTC in nanoseconds
*/
- private final double getTimeScale() {
+ private double getTimeScale() {
if (getClock() == null) {
return 1.0;
}
*
* @return if the trace is in ns or cycles.
*/
- private final boolean clockNeedsScale() {
+ private boolean clockNeedsScale() {
if (getClock() == null) {
return false;
}
*
* @return 1.0 / scale
*/
- private final double getInverseTimeScale() {
+ private double getInverseTimeScale() {
if (getClock() == null) {
return 1.0;
}
* @param cycles
* clock cycles since boot
* @return time in nanoseconds UTC offset
+ * @since 2.0
*/
public long timestampCyclesToNanos(long cycles) {
long retVal = cycles + getOffset();
* @param nanos
* time in nanoseconds UTC offset
* @return clock cycles since boot.
+ * @since 2.0
*/
public long timestampNanoToCycles(long nanos) {
long retVal;
/**
* Does a given stream contain any events?
- * @param id the stream ID
+ *
+ * @param id
+ * the stream ID
* @return true if the stream has events.
*/
- public boolean hasEvents(Long id){
+ public boolean hasEvents(Long id) {
return eventDecs.containsKey(id);
}
/**
* Add an event declaration map to the events map.
- * @param id the id of a stream
+ *
+ * @param id
+ * the id of a stream
* @return the hashmap containing events.
+ * @since 2.0
*/
- public HashMap<Long, EventDeclaration> createEvents(Long id){
- HashMap<Long, EventDeclaration> value = eventDecs.get(id);
- if( value == null ) {
- value = new HashMap<Long, EventDeclaration>();
+ public Map<Long, IEventDeclaration> createEvents(Long id) {
+ HashMap<Long, IEventDeclaration> value = eventDecs.get(id);
+ if (value == null) {
+ value = new HashMap<Long, IEventDeclaration>();
eventDecs.put(id, value);
}
return value;
}
+ /**
+ * Adds a callsite
+ *
+ * @param eventName
+ * the event name of the callsite
+ * @param funcName
+ * the name of the callsite function
+ * @param ip
+ * the ip of the callsite
+ * @param fileName
+ * the filename of the callsite
+ * @param lineNumber
+ * the line number of the callsite
+ */
+ public void addCallsite(String eventName, String funcName, long ip,
+ String fileName, long lineNumber) {
+ final CTFCallsite cs = new CTFCallsite(eventName, funcName, ip,
+ fileName, lineNumber);
+ TreeSet<CTFCallsite> csl = callsitesByName.get(eventName);
+ if (csl == null) {
+ csl = new TreeSet<CTFCallsite>(ctfCallsiteComparator);
+ callsitesByName.put(eventName, csl);
+ }
+
+ csl.add(cs);
+
+ callsitesByIP.add(cs);
+ }
+
+ /**
+ * Gets the set of callsites associated to an event name. O(1)
+ *
+ * @param eventName
+ * the event name
+ * @return the callsite set can be empty
+ * @since 3.0
+ */
+ public TreeSet<CTFCallsite> getCallsiteCandidates(String eventName) {
+ TreeSet<CTFCallsite> retVal = callsitesByName.get(eventName);
+ if (retVal == null) {
+ retVal = new TreeSet<CTFCallsite>(ctfCallsiteComparator);
+ }
+ return retVal;
+ }
+
+ /**
+ * The I'm feeling lucky of getCallsiteCandidates O(1)
+ *
+ * @param eventName
+ * the event name
+ * @return the first callsite that has that event name, can be null
+ * @since 1.2
+ */
+ public CTFCallsite getCallsite(String eventName) {
+ TreeSet<CTFCallsite> callsites = callsitesByName.get(eventName);
+ if (callsites != null) {
+ return callsites.first();
+ }
+ return null;
+ }
+
+ /**
+ * Gets a callsite from the instruction pointer O(log(n))
+ *
+ * @param ip
+ * the instruction pointer to lookup
+ * @return the callsite just before that IP in the list remember the IP is
+ * backwards on X86, can be null if no callsite is before the IP.
+ * @since 1.2
+ */
+ public CTFCallsite getCallsite(long ip) {
+ CTFCallsite cs = new CTFCallsite(null, null, ip, null, 0L);
+ return callsitesByIP.ceiling(cs);
+ }
+
+ /**
+ * Gets a callsite using the event name and instruction pointer O(log(n))
+ *
+ * @param eventName
+ * the name of the event
+ * @param ip
+ * the instruction pointer
+ * @return the closest matching callsite, can be null
+ */
+ public CTFCallsite getCallsite(String eventName, long ip) {
+ final TreeSet<CTFCallsite> candidates = callsitesByName.get(eventName);
+ final CTFCallsite dummyCs = new CTFCallsite(null, null, ip, null, -1);
+ final CTFCallsite callsite = candidates.ceiling(dummyCs);
+ if (callsite == null) {
+ return candidates.floor(dummyCs);
+ }
+ return callsite;
+ }
}
class MetadataFileFilter implements FileFilter {
projects / deliverable / tracecompass.git / blobdiff