import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel.MapMode;
import java.util.Collection;
-import java.util.HashMap;
+import org.eclipse.linuxtools.ctf.core.CTFStrings;
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;
/** Stream event header definition. */
private final StructDefinition streamEventHeaderDef;
- /** Stream event context definition.*/
+ /** Stream event context definition. */
private final StructDefinition streamEventContextDef;
- /** Maps event ID to event definitions. */
- private final HashMap<Long, EventDefinition> events;
-
/** Reference to the index entry of the current packet. */
private StreamInputPacketIndexEntry currentPacket = null;
/** CPU id of current packet. */
private int currentCpu = 0;
- /** number of lost events in this packet */
- private int lostSoFar;
-
private int lostEventsInThisPacket;
+ private long lostEventsDuration;
+
+ private boolean hasLost = false;
+
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
bitBuffer = new BitBuffer();
bitBuffer.setByteOrder(streamInputReader.getByteOrder());
- events = streamInputReader.getStreamInput().getStream().getTrace().getEventDefs(streamInputReader.getStreamInput());
- lostSoFar = 0;
-
/* Create trace packet header definition. */
final Stream currentStream = streamInputReader.getStreamInput().getStream();
StructDeclaration tracePacketHeaderDecl = currentStream.getTrace().getPacketHeader();
Collection<IEventDeclaration> eventDecls = streamInputReader.getStreamInput().getStream().getEvents().values();
for (IEventDeclaration event : eventDecls) {
- if (!events.containsKey(event.getId())) {
+ if (!streamInputReader.getEventDefinitions().containsKey(event.getId())) {
EventDefinition eventDef = event.createDefinition(streamInputReader);
- events.put(event.getId(), eventDef);
+ streamInputReader.addEventDefinition(event.getId(), eventDef);
}
}
}
/**
* Dispose the StreamInputPacketReader
+ *
* @since 2.0
*/
public void dispose() {
*
* @param currentPacket
* The index entry of the packet to switch to.
+ * @throws CTFReaderException
+ * If we get an error reading the packet
*/
- void setCurrentPacket(StreamInputPacketIndexEntry currentPacket) {
+ void setCurrentPacket(StreamInputPacketIndexEntry currentPacket) throws CTFReaderException {
+ StreamInputPacketIndexEntry prevPacket = null;
this.currentPacket = currentPacket;
if (this.currentPacket != null) {
this.currentPacket.getOffsetBytes(),
(this.currentPacket.getPacketSizeBits() + 7) / 8);
} catch (IOException e) {
- /*
- * The streamInputReader object is already allocated, so this
- * shouldn't fail bar some very bad kernel or RAM errors...
- */
- e.printStackTrace();
+ throw new CTFReaderException(e.getMessage(), e);
}
bitBuffer.setByteBuffer(bb);
/* Read number of lost events */
lostEventsInThisPacket = (int) this.getCurrentPacket().getLostEvents();
- lostSoFar = 0;
-
+ if (lostEventsInThisPacket != 0) {
+ hasLost = true;
+ /*
+ * Compute the duration of the lost event time range. If the
+ * current packet is the first packet, duration will be set
+ * to 1.
+ */
+ long lostEventsStartTime;
+ int index = this.streamInputReader.getStreamInput().getIndex().getEntries().indexOf(currentPacket);
+ if (index == 0) {
+ lostEventsStartTime = currentPacket.getTimestampBegin() + 1;
+ } else {
+ prevPacket = this.streamInputReader.getStreamInput().getIndex().getEntries().get(index - 1);
+ lostEventsStartTime = prevPacket.getTimestampEnd();
+ }
+ lostEventsDuration = Math.abs(lostEventsStartTime - currentPacket.getTimestampBegin());
+ }
}
/*
*/
public boolean hasMoreEvents() {
if (currentPacket != null) {
- return bitBuffer.position() < currentPacket.getContentSizeBits();
+ return hasLost || (bitBuffer.position() < currentPacket.getContentSizeBits());
}
return false;
}
*/
public EventDefinition readNextEvent() throws CTFReaderException {
/* Default values for those fields */
- long eventID = 0;
+ long eventID = EventDeclaration.UNSET_EVENT_ID;
long timestamp = 0;
-
- if (lostEventsInThisPacket > lostSoFar) {
+ if (hasLost) {
+ hasLost = false;
EventDefinition eventDef = EventDeclaration.getLostEventDeclaration().createDefinition(streamInputReader);
+ ((IntegerDefinition) eventDef.getFields().getDefinitions().get(CTFStrings.LOST_EVENTS_FIELD)).setValue(lostEventsInThisPacket);
+ ((IntegerDefinition) eventDef.getFields().getDefinitions().get(CTFStrings.LOST_EVENTS_DURATION)).setValue(lostEventsDuration);
eventDef.setTimestamp(this.lastTimestamp);
- ++lostSoFar;
return eventDef;
}
final StructDefinition sehd = streamEventHeaderDef;
final BitBuffer currentBitBuffer = bitBuffer;
-
+ final long posStart = currentBitBuffer.position();
/* Read the stream event header. */
if (sehd != null) {
sehd.read(currentBitBuffer);
Definition idDef = sehd.lookupDefinition("id"); //$NON-NLS-1$
if (idDef instanceof SimpleDatatypeDefinition) {
eventID = ((SimpleDatatypeDefinition) idDef).getIntegerValue();
- } // else, eventID remains 0
+ } else if (idDef != null) {
+ throw new CTFReaderException("Incorrect event id : " + eventID); //$NON-NLS-1$
+ }
- /* Get the timestamp from the event header (may be overridden later on) */
- Definition timestampDef = sehd.lookupInteger("timestamp"); //$NON-NLS-1$
- if (timestampDef instanceof IntegerDefinition) {
- timestamp = calculateTimestamp((IntegerDefinition) timestampDef);
+ /*
+ * Get the timestamp from the event header (may be overridden later
+ * on)
+ */
+ IntegerDefinition timestampDef = sehd.lookupInteger("timestamp"); //$NON-NLS-1$
+ if (timestampDef != null) {
+ timestamp = calculateTimestamp(timestampDef);
} // else timestamp remains 0
/* Check for the variant v. */
eventID = ((IntegerDefinition) idIntegerDef).getValue();
}
- /* Get the timestamp. This would overwrite any previous timestamp definition */
- timestampDef = variantCurrentField.lookupDefinition("timestamp"); //$NON-NLS-1$
- if (timestampDef instanceof IntegerDefinition) {
- timestamp = calculateTimestamp((IntegerDefinition) timestampDef);
+ /*
+ * Get the timestamp. This would overwrite any previous
+ * timestamp definition
+ */
+ Definition def = variantCurrentField.lookupDefinition("timestamp"); //$NON-NLS-1$
+ if (def instanceof IntegerDefinition) {
+ timestamp = calculateTimestamp((IntegerDefinition) def);
}
}
}
}
/* Get the right event definition using the event id. */
- EventDefinition eventDef = events.get(eventID);
+ EventDefinition eventDef = streamInputReader.getEventDefinitions().get(eventID);
if (eventDef == null) {
throw new CTFReaderException("Incorrect event id : " + eventID); //$NON-NLS-1$
}
/* Read the event context. */
- if (eventDef.getContext() != null) {
- eventDef.getContext().read(currentBitBuffer);
+ if (eventDef.getEventContext() != null) {
+ eventDef.getEventContext().read(currentBitBuffer);
}
/* Read the event fields. */
*/
eventDef.setTimestamp(timestamp);
+ if (posStart == currentBitBuffer.position()) {
+ throw new CTFReaderException("Empty event not allowed, event: " + eventDef.getDeclaration().getName()); //$NON-NLS-1$
+ }
+
return eventDef;
}
@Override
public Definition lookupDefinition(String lookupPath) {
- // TODO Auto-generated method stub
return null;
}
}
projects / deliverable / tracecompass.git / blobdiff