/*******************************************************************************
- * Copyright (c) 2011, 2013 Ericsson, Ecole Polytechnique de Montreal and others
+ * Copyright (c) 2011, 2014 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
/**
* The trace to read from.
*/
- private final CTFTrace trace;
+ private final CTFTrace fTrace;
/**
* Vector of all the trace file readers.
*/
- private final List<StreamInputReader> streamInputReaders = new ArrayList<>();
+ private final List<StreamInputReader> fStreamInputReaders = new ArrayList<>();
/**
* Priority queue to order the trace file readers by timestamp.
*/
- private PriorityQueue<StreamInputReader> prio;
+ private PriorityQueue<StreamInputReader> fPrio;
/**
* Array to count the number of event per trace file.
*/
- private long[] eventCountPerTraceFile;
+ private long[] fEventCountPerTraceFile;
/**
* Timestamp of the first event in the trace
*/
- private long startTime;
+ private long fStartTime;
/**
* Timestamp of the last event read so far
*/
- private long endTime;
+ private long fEndTime;
// ------------------------------------------------------------------------
// Constructors
* if an error occurs
*/
public CTFTraceReader(CTFTrace trace) throws CTFReaderException {
- this.trace = trace;
- streamInputReaders.clear();
+ fTrace = trace;
+ fStreamInputReaders.clear();
/**
* Create the trace file readers.
* Get the start Time of this trace bear in mind that the trace could be
* empty.
*/
- this.startTime = 0;
+ fStartTime = 0;
if (hasMoreEvents()) {
- this.startTime = prio.peek().getCurrentEvent().getTimestamp();
- this.setEndTime(this.startTime);
+ fStartTime = fPrio.peek().getCurrentEvent().getTimestamp();
+ setEndTime(fStartTime);
}
}
public CTFTraceReader copyFrom() throws CTFReaderException {
CTFTraceReader newReader = null;
- newReader = new CTFTraceReader(this.trace);
- newReader.startTime = this.startTime;
- newReader.setEndTime(this.endTime);
+ newReader = new CTFTraceReader(fTrace);
+ newReader.fStartTime = fStartTime;
+ newReader.setEndTime(fEndTime);
return newReader;
}
* @since 2.0
*/
public void dispose() {
- for (StreamInputReader reader : streamInputReaders) {
+ for (StreamInputReader reader : fStreamInputReaders) {
if (reader != null) {
reader.dispose();
}
}
- streamInputReaders.clear();
+ fStreamInputReaders.clear();
}
// ------------------------------------------------------------------------
* @return the trace start time
*/
public long getStartTime() {
- return this.startTime;
+ return fStartTime;
}
/**
* The end time to use
*/
protected final void setEndTime(long endTime) {
- this.endTime = endTime;
+ fEndTime = endTime;
}
/**
* @since 2.0
*/
protected PriorityQueue<StreamInputReader> getPrio() {
- return prio;
+ return fPrio;
}
// ------------------------------------------------------------------------
/*
* For each stream.
*/
- for (Stream stream : this.trace.getStreams()) {
+ for (Stream stream : fTrace.getStreams()) {
Set<StreamInput> streamInputs = stream.getStreamInputs();
/*
/*
* Add it to the group.
*/
- this.streamInputReaders.add(streamInputReader);
+ fStreamInputReaders.add(streamInputReader);
}
}
/*
* Create the array to count the number of event per trace file.
*/
- this.eventCountPerTraceFile = new long[this.streamInputReaders.size()];
+ fEventCountPerTraceFile = new long[fStreamInputReaders.size()];
}
/**
* if an error occurs
*/
private void populateStreamInputReaderHeap() throws CTFReaderException {
- if (this.streamInputReaders.isEmpty()) {
- this.prio = new PriorityQueue<>();
+ if (fStreamInputReaders.isEmpty()) {
+ fPrio = new PriorityQueue<>();
return;
}
* Create the priority queue with a size twice as bigger as the number
* of reader in order to avoid constant resizing.
*/
- this.prio = new PriorityQueue<>(
- this.streamInputReaders.size() * 2,
+ fPrio = new PriorityQueue<>(
+ fStreamInputReaders.size() * 2,
new StreamInputReaderTimestampComparator());
int pos = 0;
- for (StreamInputReader reader : this.streamInputReaders) {
+ for (StreamInputReader reader : fStreamInputReaders) {
/*
* Add each trace file reader in the priority queue, if we are able
* to read an event from it.
*/
reader.setParent(this);
if (reader.readNextEvent()) {
- this.prio.add(reader);
+ fPrio.add(reader);
- this.eventCountPerTraceFile[pos] = 0;
+ fEventCountPerTraceFile[pos] = 0;
reader.setName(pos);
pos++;
/*
* Remove the reader from the top of the priority queue.
*/
- StreamInputReader top = this.prio.poll();
+ StreamInputReader top = fPrio.poll();
/*
* If the queue was empty.
/*
* Add it back in the queue.
*/
- this.prio.add(top);
- final long topEnd = this.trace.timestampCyclesToNanos(top.getCurrentEvent().getTimestamp());
- this.setEndTime(Math.max(topEnd, this.getEndTime()));
- this.eventCountPerTraceFile[top.getName()]++;
+ fPrio.add(top);
+ final long topEnd = fTrace.timestampCyclesToNanos(top.getCurrentEvent().getTimestamp());
+ setEndTime(Math.max(topEnd, getEndTime()));
+ fEventCountPerTraceFile[top.getName()]++;
if (top.getCurrentEvent() != null) {
- this.endTime = Math.max(top.getCurrentEvent().getTimestamp(),
- this.endTime);
+ fEndTime = Math.max(top.getCurrentEvent().getTimestamp(),
+ fEndTime);
}
}
/*
* if an error occurs
*/
public void goToLastEvent() throws CTFReaderException {
- seek(this.getEndTime());
- while (this.prio.size() > 1) {
- this.advance();
+ seek(getEndTime());
+ while (fPrio.size() > 1) {
+ advance();
}
}
/*
* Remove all the trace readers from the priority queue
*/
- this.prio.clear();
- for (StreamInputReader streamInputReader : this.streamInputReaders) {
+ fPrio.clear();
+ for (StreamInputReader streamInputReader : fStreamInputReaders) {
/*
* Seek the trace reader.
*/
* Add it to the priority queue if there is a current event.
*/
if (streamInputReader.getCurrentEvent() != null) {
- this.prio.add(streamInputReader);
+ fPrio.add(streamInputReader);
}
}
return hasMoreEvents();
* @return the stream with the oldest event
*/
public StreamInputReader getTopStream() {
- return this.prio.peek();
+ return fPrio.peek();
}
/**
* @return true if yes.
*/
public final boolean hasMoreEvents() {
- return this.prio.size() > 0;
+ return fPrio.size() > 0;
}
/**
return;
}
- for (long i : this.eventCountPerTraceFile) {
+ for (long i : fEventCountPerTraceFile) {
numEvents += i;
}
- for (int j = 0; j < this.eventCountPerTraceFile.length; j++) {
- StreamInputReader se = this.streamInputReaders.get(j);
+ for (int j = 0; j < fEventCountPerTraceFile.length; j++) {
+ StreamInputReader se = fStreamInputReaders.get(j);
- long len = (width * this.eventCountPerTraceFile[se.getName()])
+ long len = (width * fEventCountPerTraceFile[se.getName()])
/ numEvents;
StringBuilder sb = new StringBuilder(se.getFilename());
sb.append(' ');
}
- sb.append("]\t" + this.eventCountPerTraceFile[se.getName()] + " Events"); //$NON-NLS-1$//$NON-NLS-2$
+ sb.append("]\t" + fEventCountPerTraceFile[se.getName()] + " Events"); //$NON-NLS-1$//$NON-NLS-2$
Activator.log(sb.toString());
}
}
* @return the last event
*/
public long getEndTime() {
- return this.endTime;
+ return fEndTime;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + (int) (startTime ^ (startTime >>> 32));
- result = (prime * result) + streamInputReaders.hashCode();
- result = (prime * result) + ((trace == null) ? 0 : trace.hashCode());
+ result = (prime * result) + (int) (fStartTime ^ (fStartTime >>> 32));
+ result = (prime * result) + fStreamInputReaders.hashCode();
+ result = (prime * result) + ((fTrace == null) ? 0 : fTrace.hashCode());
return result;
}
return false;
}
CTFTraceReader other = (CTFTraceReader) obj;
- if (!streamInputReaders.equals(other.streamInputReaders)) {
+ if (!fStreamInputReaders.equals(other.fStreamInputReaders)) {
return false;
}
- if (trace == null) {
- if (other.trace != null) {
+ if (fTrace == null) {
+ if (other.fTrace != null) {
return false;
}
- } else if (!trace.equals(other.trace)) {
+ } else if (!fTrace.equals(other.fTrace)) {
return false;
}
return true;
@Override
public String toString() {
/* Only for debugging, shouldn't be externalized */
- return "CTFTraceReader [trace=" + trace + ']'; //$NON-NLS-1$
+ return "CTFTraceReader [trace=" + fTrace + ']'; //$NON-NLS-1$
}
/**
* @return the parent trace
*/
public CTFTrace getTrace() {
- return trace;
+ return fTrace;
}
}
/**
* The StreamInput we are reading.
*/
- private final StreamInput streamInput;
+ private final StreamInput fStreamInput;
/**
* The packet reader used to read packets from this trace file.
*/
- private final StreamInputPacketReader packetReader;
+ private final StreamInputPacketReader fPacketReader;
/**
* Iterator on the packet index
*/
- private int packetIndex;
+ private int fPacketIndex;
/**
* Reference to the current event of this trace file (iow, the last on that
* was read, the next one to be returned)
*/
- private EventDefinition currentEvent = null;
+ private EventDefinition fCurrentEvent = null;
- private int name;
+ private int fId;
- private CTFTraceReader parent;
+ private CTFTraceReader fParent;
/** Map of all the event types */
- private final Map<Long, EventDefinition> eventDefs = new HashMap<>();
+ private final Map<Long, EventDefinition> fEventDefs = new HashMap<>();
// ------------------------------------------------------------------------
// Constructors
* @since 2.0
*/
public StreamInputReader(StreamInput streamInput) throws CTFReaderException {
- this.streamInput = streamInput;
- this.packetReader = new StreamInputPacketReader(this);
+ fStreamInput = streamInput;
+ fPacketReader = new StreamInputPacketReader(this);
/*
* Get the iterator on the packet index.
*/
- this.packetIndex = 0;
+ fPacketIndex = 0;
/*
* Make first packet the current one.
*/
* @since 2.0
*/
public void dispose() {
- packetReader.dispose();
+ fPacketReader.dispose();
}
// ------------------------------------------------------------------------
* finished/empty/malformed
*/
public EventDefinition getCurrentEvent() {
- return this.currentEvent;
+ return fCurrentEvent;
}
/**
* @return the current packet context (size, lost events and such)
*/
public StructDefinition getCurrentPacketContext() {
- return this.packetReader.getStreamPacketContextDef();
+ return fPacketReader.getStreamPacketContextDef();
}
/**
* @return the trace byte order
*/
public ByteOrder getByteOrder() {
- return streamInput.getStream().getTrace().getByteOrder();
+ return fStreamInput.getStream().getTrace().getByteOrder();
}
/**
* @return gets the stream name (it's a number)
*/
public int getName() {
- return this.name;
+ return fId;
}
/**
* the name of the stream, (it's a number)
*/
public void setName(int name) {
- this.name = name;
+ fId = name;
}
/**
* @return The CPU id (a number)
*/
public int getCPU() {
- return this.packetReader.getCPU();
+ return fPacketReader.getCPU();
}
/**
* @return The filename of the stream being read
*/
public String getFilename() {
- return streamInput.getFilename();
+ return fStreamInput.getFilename();
}
/*
* for internal use only
*/
StreamInput getStreamInput() {
- return streamInput;
+ return fStreamInput;
}
/**
* @since 2.1
*/
public Map<Long, EventDefinition> getEventDefinitions() {
- return Collections.unmodifiableMap(eventDefs);
+ return Collections.unmodifiableMap(fEventDefs);
}
/**
* @since 2.1
*/
public void addEventDefinition(Long id, EventDefinition def) {
- eventDefs.put(id, def);
+ fEventDefs.put(id, def);
}
// ------------------------------------------------------------------------
/*
* Change packet if needed
*/
- if (!this.packetReader.hasMoreEvents()) {
- final StreamInputPacketIndexEntry prevPacket = this.packetReader
+ if (!fPacketReader.hasMoreEvents()) {
+ final StreamInputPacketIndexEntry prevPacket = fPacketReader
.getCurrentPacket();
if (prevPacket != null) {
goToNextPacket();
/*
* If an event is available, read it.
*/
- if (this.packetReader.hasMoreEvents()) {
- this.setCurrentEvent(this.packetReader.readNextEvent());
+ if (fPacketReader.hasMoreEvents()) {
+ this.setCurrentEvent(fPacketReader.readNextEvent());
return true;
}
this.setCurrentEvent(null);
* if an error occurs
*/
private void goToNextPacket() throws CTFReaderException {
- packetIndex++;
- if (getPacketSize() >= (packetIndex + 1)) {
- this.packetReader.setCurrentPacket(getPacket());
+ fPacketIndex++;
+ if (getPacketSize() >= (fPacketIndex + 1)) {
+ fPacketReader.setCurrentPacket(getPacket());
} else {
- if (this.streamInput.addPacketHeaderIndex()) {
- packetIndex = getPacketSize() - 1;
- this.packetReader.setCurrentPacket(getPacket());
+ if (fStreamInput.addPacketHeaderIndex()) {
+ fPacketIndex = getPacketSize() - 1;
+ fPacketReader.setCurrentPacket(getPacket());
} else {
- this.packetReader.setCurrentPacket(null);
+ fPacketReader.setCurrentPacket(null);
}
}
}
* @return
*/
private int getPacketSize() {
- return streamInput.getIndex().getEntries().size();
+ return fStreamInput.getIndex().getEntries().size();
}
/**
/*
* index up to the desired timestamp.
*/
- while ((this.packetReader.getCurrentPacket() != null)
- && (this.packetReader.getCurrentPacket().getTimestampEnd() < timestamp)) {
+ while ((fPacketReader.getCurrentPacket() != null)
+ && (fPacketReader.getCurrentPacket().getTimestampEnd() < timestamp)) {
try {
- this.streamInput.addPacketHeaderIndex();
+ fStreamInput.addPacketHeaderIndex();
goToNextPacket();
} catch (CTFReaderException e) {
// do nothing here
}
}
- if (this.packetReader.getCurrentPacket() == null) {
+ if (fPacketReader.getCurrentPacket() == null) {
gotoPacket(timestamp);
}
* if an error occurs
*/
private void gotoPacket(long timestamp) throws CTFReaderException {
- this.packetIndex = this.streamInput.getIndex().search(timestamp)
+ fPacketIndex = fStreamInput.getIndex().search(timestamp)
.previousIndex();
/*
* Switch to this packet.
/*
* Search in the index for the packet to search in.
*/
- final int len = this.streamInput.getIndex().getEntries().size();
+ final int len = fStreamInput.getIndex().getEntries().size();
/*
* Go to beginning of trace.
/*
* if the trace is empty.
*/
- if ((len == 0) || (this.packetReader.hasMoreEvents() == false)) {
+ if ((len == 0) || (fPacketReader.hasMoreEvents() == false)) {
/*
* This means the trace is empty. abort.
*/
* Go to the last packet that contains events.
*/
for (int pos = len - 1; pos > 0; pos--) {
- packetIndex = pos;
- this.packetReader.setCurrentPacket(getPacket());
- if (this.packetReader.hasMoreEvents()) {
+ fPacketIndex = pos;
+ fPacketReader.setCurrentPacket(getPacket());
+ if (fPacketReader.hasMoreEvents()) {
break;
}
}
* Go until the end of that packet
*/
EventDefinition prevEvent = null;
- while (this.currentEvent != null) {
- prevEvent = this.currentEvent;
+ while (fCurrentEvent != null) {
+ prevEvent = fCurrentEvent;
this.readNextEvent();
}
/*
* @return the parent
*/
public CTFTraceReader getParent() {
- return parent;
+ return fParent;
}
/**
* the parent to set
*/
public void setParent(CTFTraceReader parent) {
- this.parent = parent;
+ fParent = parent;
}
/**
* the event to set
*/
public void setCurrentEvent(EventDefinition currentEvent) {
- this.currentEvent = currentEvent;
+ fCurrentEvent = currentEvent;
}
/**
* @return the packetIndexIt
*/
private int getPacketIndex() {
- return packetIndex;
+ return fPacketIndex;
}
private StreamInputPacketIndexEntry getPacket() {
- return streamInput.getIndex().getEntries().get(getPacketIndex());
+ return fStreamInput.getIndex().getEntries().get(getPacketIndex());
}
/**
* @return the packetReader
*/
public StreamInputPacketReader getPacketReader() {
- return packetReader;
+ return fPacketReader;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + name;
+ result = (prime * result) + fId;
result = (prime * result)
- + ((streamInput == null) ? 0 : streamInput.hashCode());
+ + ((fStreamInput == null) ? 0 : fStreamInput.hashCode());
return result;
}
return false;
}
StreamInputReader other = (StreamInputReader) obj;
- if (name != other.name) {
+ if (fId != other.fId) {
return false;
}
- if (streamInput == null) {
- if (other.streamInput != null) {
+ if (fStreamInput == null) {
+ if (other.fStreamInput != null) {
return false;
}
- } else if (!streamInput.equals(other.streamInput)) {
+ } else if (!fStreamInput.equals(other.fStreamInput)) {
return false;
}
return true;
@Override
public String toString() {
// this helps debugging
- return this.name + ' ' + this.currentEvent.toString();
+ return fId + ' ' + fCurrentEvent.toString();
}
}
projects / deliverable / tracecompass.git / commitdiff
