* 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.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.Arrays;
-import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
-import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
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.CTFCallsiteComparator;
import org.eclipse.linuxtools.internal.ctf.core.event.metadata.exceptions.ParseException;
import org.eclipse.linuxtools.internal.ctf.core.trace.StreamInputPacketIndex;
*/
private final File path;
- /**
- * The metadata parsing object.
- */
- private final Metadata metadata;
-
/**
* Major CTF version number
*/
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 Map<Long,HashMap<Long, IEventDeclaration>> eventDecs = new HashMap<Long, HashMap<Long,IEventDeclaration>>();
private final Map<StreamInput, StreamInputPacketIndex> indexes = new HashMap<StreamInput, StreamInputPacketIndex>();
/** Callsite helpers */
- private Map<String, LinkedList<CTFCallsite>> callsitesByName = new HashMap<String, LinkedList<CTFCallsite>>();
+ 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>();
*/
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 */
if (!this.path.exists()) {
}
/* List files not called metadata and not hidden. */
- File[] files = path.listFiles(metadataFileFilter);
- Arrays.sort(files, metadataComparator);
+ File[] files = path.listFiles(METADATA_FILE_FILTER);
+ Arrays.sort(files, METADATA_COMPARATOR);
/* Try to open each file */
for (File streamFile : files) {
openStreamInput(streamFile);
* @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, IEventDeclaration> getEvents(Long streamId) {
+ public Map<Long, IEventDeclaration> getEvents(Long streamId) {
return eventDecs.get(streamId);
}
* @return the hashmap with the event definitions
* @since 2.0
*/
- public HashMap<Long, EventDefinition> getEventDefs(StreamInput id) {
+ public Map<Long, EventDefinition> getEventDefs(StreamInput id) {
if(! eventDefs.containsKey(id)){
eventDefs.put(id, new HashMap<Long, EventDefinition>());
}
* 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;
}
byteBuffer = fc.map(MapMode.READ_ONLY, 0, Math.min((int)fc.size(), 4096));
} 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 */
*
* @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;
}
* Add an event declaration map to the events map.
* @param id the id of a stream
* @return the hashmap containing events.
+ * @since 2.0
*/
- public HashMap<Long, IEventDeclaration> createEvents(Long id){
+ public Map<Long, IEventDeclaration> createEvents(Long id){
HashMap<Long, IEventDeclaration> value = eventDecs.get(id);
if( value == null ) {
value = new HashMap<Long, IEventDeclaration>();
String fileName, long lineNumber) {
final CTFCallsite cs = new CTFCallsite(eventName, funcName, ip,
fileName, lineNumber);
- LinkedList<CTFCallsite> csl = callsitesByName.get(eventName);
+ TreeSet<CTFCallsite> csl = callsitesByName.get(eventName);
if (csl == null) {
- csl = new LinkedList<CTFCallsite>();
+ csl = new TreeSet<CTFCallsite>(ctfCallsiteComparator);
callsitesByName.put(eventName, csl);
}
- ListIterator<CTFCallsite> iter = csl.listIterator();
- int index = 0;
- for (; index < csl.size(); index++) {
- if (iter.next().compareTo(cs) < 0) {
- break;
- }
- }
-
- csl.add(index, cs);
+ csl.add(cs);
callsitesByIP.add(cs);
}
/**
- * Gets the list of callsites associated to an event name. O(1)
+ * Gets the set of callsites associated to an event name. O(1)
*
* @param eventName
* the event name
- * @return the callsite list can be empty
- * @since 1.2
+ * @return the callsite set can be empty
+ * @since 3.0
*/
- public List<CTFCallsite> getCallsiteCandidates(String eventName) {
- LinkedList<CTFCallsite> retVal = callsitesByName.get(eventName);
- if( retVal == null ) {
- retVal = new LinkedList<CTFCallsite>();
+ public TreeSet<CTFCallsite> getCallsiteCandidates(String eventName) {
+ TreeSet<CTFCallsite> retVal = callsitesByName.get(eventName);
+ if (retVal == null) {
+ retVal = new TreeSet<CTFCallsite>(ctfCallsiteComparator);
}
return retVal;
}
* @since 1.2
*/
public CTFCallsite getCallsite(String eventName) {
- LinkedList<CTFCallsite> callsites = callsitesByName.get(eventName);
+ TreeSet<CTFCallsite> callsites = callsitesByName.get(eventName);
if (callsites != null) {
- return callsites.getFirst();
+ return callsites.first();
}
return null;
}
* @return the closest matching callsite, can be null
*/
public CTFCallsite getCallsite(String eventName, long ip) {
- final LinkedList<CTFCallsite> candidates = callsitesByName.get(eventName);
+ final TreeSet<CTFCallsite> candidates = callsitesByName.get(eventName);
final CTFCallsite dummyCs = new CTFCallsite(null, null, ip, null, -1);
- final int pos = Collections.binarySearch(candidates, dummyCs)+1;
- if( pos >= candidates.size()) {
- return null;
+ final CTFCallsite callsite = candidates.ceiling(dummyCs);
+ if (callsite == null) {
+ return candidates.floor(dummyCs);
}
- return candidates.get(pos);
+ return callsite;
}
-
}
class MetadataFileFilter implements FileFilter {
projects / deliverable / tracecompass.git / blobdiff