/*******************************************************************************
- * 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
import java.io.File;
import java.io.IOException;
-import java.nio.MappedByteBuffer;
+import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.UUID;
* <b><u>StreamInput</u></b>
* <p>
* Represents a trace file that belongs to a certain stream.
+ *
* @since 2.0
*/
public class StreamInput implements IDefinitionScope {
/**
* The associated Stream
*/
- private final Stream stream;
+ private final Stream fStream;
/**
* FileChannel to the trace file
*/
- private final FileChannel fileChannel;
+ private final FileChannel fFileChannel;
/**
* Information on the file (used for debugging)
*/
- private final File file;
+ private final File fFile;
/**
* The packet index of this input
*/
- private final StreamInputPacketIndex index;
+ private final StreamInputPacketIndex fIndex;
- private long timestampEnd;
+ private long fTimestampEnd;
/*
* Definition of trace packet header
*/
- private StructDefinition tracePacketHeaderDef = null;
+ private StructDefinition fTracePacketHeaderDef = null;
/*
* Definition of trace stream packet context
*/
- private StructDefinition streamPacketContextDef = null;
+ private StructDefinition fStreamPacketContextDef = null;
/*
* Total number of lost events in this stream
*/
- private long lostSoFar = 0;
+ private long fLostSoFar = 0;
// ------------------------------------------------------------------------
// Constructors
* Information about the trace file (for debugging purposes).
*/
public StreamInput(Stream stream, FileChannel fileChannel, File file) {
- this.stream = stream;
- this.fileChannel = fileChannel;
- this.file = file;
- this.index = stream.getTrace().getIndex(this);
+ fStream = stream;
+ fFileChannel = fileChannel;
+ fFile = file;
+ fIndex = new StreamInputPacketIndex();
}
// ------------------------------------------------------------------------
* @return the stream the streamInput wrapper is wrapping
*/
public Stream getStream() {
- return stream;
+ return fStream;
}
/**
- * the common streamInput Index
+ * The common streamInput Index
*
* @return the stream input Index
*/
StreamInputPacketIndex getIndex() {
- return index;
- }
-
- /**
- * Gets the filechannel of the streamInput. This is a limited Java
- * ressource.
- *
- * @return the filechannel
- */
- public FileChannel getFileChannel() {
- return fileChannel;
+ return fIndex;
}
/**
* @return the filename of the streaminput file.
*/
public String getFilename() {
- return file.getName();
+ return fFile.getName();
}
/**
- * gets the last read timestamp of a stream. (this is not necessarily the
+ * Gets the last read timestamp of a stream. (this is not necessarily the
* last time in the stream.)
*
* @return the last read timestamp
*/
public long getTimestampEnd() {
- return timestampEnd;
+ return fTimestampEnd;
}
/**
* the last read timestamp
*/
public void setTimestampEnd(long timestampEnd) {
- this.timestampEnd = timestampEnd;
+ fTimestampEnd = timestampEnd;
}
/**
- * useless for streaminputs
+ * Useless for streaminputs
*/
@Override
public String getPath() {
* The BitBuffer to extract data from the StreamInput
*/
BitBuffer bitBuffer = new BitBuffer();
- bitBuffer.setByteOrder(this.getStream().getTrace().getByteOrder());
+ bitBuffer.setByteOrder(getStream().getTrace().getByteOrder());
/*
* Create the definitions we need to read the packet headers + contexts
*/
if (getStream().getTrace().getPacketHeader() != null) {
- tracePacketHeaderDef = getStream().getTrace().getPacketHeader()
+ fTracePacketHeaderDef = getStream().getTrace().getPacketHeader()
.createDefinition(this, "trace.packet.header"); //$NON-NLS-1$
}
if (getStream().getPacketContextDecl() != null) {
- streamPacketContextDef = getStream().getPacketContextDecl()
+ fStreamPacketContextDef = getStream().getPacketContextDecl()
.createDefinition(this, "stream.packet.context"); //$NON-NLS-1$
}
*/
public boolean addPacketHeaderIndex() throws CTFReaderException {
long currentPos = 0L;
- if (!index.getEntries().isEmpty()) {
- StreamInputPacketIndexEntry pos = index.getEntries().lastElement();
+ if (!fIndex.getEntries().isEmpty()) {
+ StreamInputPacketIndexEntry pos = fIndex.getEntries().lastElement();
currentPos = computeNextOffset(pos);
}
long fileSize = getStreamSize();
if (currentPos < fileSize) {
BitBuffer bitBuffer = new BitBuffer();
- bitBuffer.setByteOrder(this.getStream().getTrace().getByteOrder());
+ bitBuffer.setByteOrder(getStream().getTrace().getByteOrder());
StreamInputPacketIndexEntry packetIndex = new StreamInputPacketIndexEntry(
currentPos);
createPacketIndexEntry(fileSize, currentPos, packetIndex,
- tracePacketHeaderDef, streamPacketContextDef, bitBuffer);
- index.addEntry(packetIndex);
+ fTracePacketHeaderDef, fStreamPacketContextDef, bitBuffer);
+ fIndex.addEntry(packetIndex);
return true;
}
return false;
}
private long getStreamSize() {
- return file.length();
+ return fFile.length();
}
private long createPacketIndexEntry(long fileSizeBytes,
StructDefinition streamPacketContextDef, BitBuffer bitBuffer)
throws CTFReaderException {
- /* Ignoring the return value, but this call is needed to initialize the input */
+ /*
+ * Ignoring the return value, but this call is needed to initialize the
+ * input
+ */
createPacketBitBuffer(fileSizeBytes, packetOffsetBytes, packetIndex, bitBuffer);
/*
if (packetIndex.getPacketSizeBits() > ((fileSizeBytes - packetIndex
.getOffsetBytes()) * 8)) {
- throw new CTFReaderException(
- "Not enough data remaining in the file for the size of this packet"); //$NON-NLS-1$
+ throw new CTFReaderException("Not enough data remaining in the file for the size of this packet"); //$NON-NLS-1$
}
/*
+ ((packetIndex.getPacketSizeBits() + 7) / 8);
}
+ ByteBuffer getByteBufferAt(long position, long size) throws IOException {
+ return fFileChannel.map(MapMode.READ_ONLY, position, size);
+ }
+
/**
* @param fileSizeBytes
* @param packetOffsetBytes
* @return
* @throws CTFReaderException
*/
- private MappedByteBuffer createPacketBitBuffer(long fileSizeBytes,
+ private ByteBuffer createPacketBitBuffer(long fileSizeBytes,
long packetOffsetBytes, StreamInputPacketIndexEntry packetIndex,
BitBuffer bitBuffer) throws CTFReaderException {
/*
/*
* Map the packet.
*/
- MappedByteBuffer bb;
+ ByteBuffer bb;
try {
- bb = fileChannel.map(MapMode.READ_ONLY, packetOffsetBytes, mapSize);
+ bb = getByteBufferAt(packetOffsetBytes, mapSize);
} catch (IOException e) {
throw new CTFReaderException(e);
}
throw new CTFReaderException(
"CTF magic mismatch " + Integer.toHexString(magic) + " vs " + Integer.toHexString(Utils.CTF_MAGIC)); //$NON-NLS-1$//$NON-NLS-2$
}
-
}
/*
long streamID = streamIDDef.getValue();
if (streamID != getStream().getId()) {
- throw new CTFReaderException(
- "Stream ID changing within a StreamInput"); //$NON-NLS-1$
+ throw new CTFReaderException("Stream ID changing within a StreamInput"); //$NON-NLS-1$
}
}
}
private void parsePacketContext(long fileSizeBytes,
StructDefinition streamPacketContextDef, BitBuffer bitBuffer,
- StreamInputPacketIndexEntry packetIndex) {
+ StreamInputPacketIndexEntry packetIndex) throws CTFReaderException {
streamPacketContextDef.read(bitBuffer);
for (String field : streamPacketContextDef.getDeclaration()
String device = (String) packetIndex.lookupAttribute("device"); //$NON-NLS-1$
// LTTng Specific
Long cpuId = (Long) packetIndex.lookupAttribute("cpu_id"); //$NON-NLS-1$
- Long lostEvents = (Long) packetIndex.lookupAttribute("events_discarded"); //$NON-NLS-1$
+ Long lostEvents = (Long) packetIndex.lookupAttribute("events_discarded"); //$NON-NLS-1$
/* Read the content size in bits */
if (contentSize != null) {
packetIndex.setContentSizeBits(contentSize.intValue());
+ } else if (packetSize != null) {
+ packetIndex.setContentSizeBits(packetSize.longValue());
} else {
packetIndex.setContentSizeBits((int) (fileSizeBytes * 8));
}
+
/* Read the packet size in bits */
if (packetSize != null) {
packetIndex.setPacketSizeBits(packetSize.intValue());
+ } else if (packetIndex.getContentSizeBits() != 0) {
+ packetIndex.setPacketSizeBits(packetIndex.getContentSizeBits());
} else {
- if (packetIndex.getContentSizeBits() != 0) {
- packetIndex.setPacketSizeBits(packetIndex.getContentSizeBits());
- } else {
- packetIndex.setPacketSizeBits((int) (fileSizeBytes * 8));
- }
+ packetIndex.setPacketSizeBits((int) (fileSizeBytes * 8));
}
+
/* Read the begin timestamp */
if (tsBegin != null) {
packetIndex.setTimestampBegin(tsBegin.longValue());
/* Read the end timestamp */
if (tsEnd != null) {
- if( tsEnd == -1 ) {
+ if (tsEnd == -1) {
tsEnd = Long.MAX_VALUE;
}
packetIndex.setTimestampEnd(tsEnd.longValue());
}
if (lostEvents != null) {
- packetIndex.setLostEvents(lostEvents - lostSoFar);
- this.lostSoFar = lostEvents;
+ packetIndex.setLostEvents(lostEvents - fLostSoFar);
+ fLostSoFar = lostEvents;
}
}
public int hashCode() {
final int prime = 31;
int result = 1;
- result = (prime * result) + ((file == null) ? 0 : file.hashCode());
+ result = (prime * result) + ((fFile == null) ? 0 : fFile.hashCode());
return result;
}
return false;
}
StreamInput other = (StreamInput) obj;
- if (file == null) {
- if (other.file != null) {
+ if (fFile == null) {
+ if (other.fFile != null) {
return false;
}
- } else if (!file.equals(other.file)) {
+ } else if (!fFile.equals(other.fFile)) {
return false;
}
return true;
projects / deliverable / tracecompass.git / blobdiff