public void testConstructorExistingFile() {
if (isPersistableCollection()) {
assertTrue(fFile.exists());
- fCheckpointCollection.setIndexComplete();
fCheckpointCollection.dispose();
fCheckpointCollection = createCollection();
@Test
public void testIsCreatedFromScratch() {
assertTrue(fCheckpointCollection.isCreatedFromScratch());
- fCheckpointCollection.setIndexComplete();
if (isPersistableCollection()) {
fCheckpointCollection.dispose();
}
/**
- * Test setSize, size
+ * Test get size
*/
@Test
- public void testSetGetSize() {
+ public void testGetSize() {
assertEquals(0, fCheckpointCollection.size());
int expected = CHECKPOINTS_INSERT_NUM;
for (int i = 0; i < expected; ++i) {
- fCheckpointCollection.insert(new TmfCheckpoint(new TmfTimestamp(0), new TmfLongLocation(0L), 0));
+ fCheckpointCollection.insert(new TmfCheckpoint(new TmfTimestamp(i), new TmfLongLocation(i), i));
}
assertEquals(expected, fCheckpointCollection.size());
}
*/
@Test
public void testVersionChange() throws IOException {
- fCheckpointCollection.setIndexComplete();
fCheckpointCollection.dispose();
try (RandomAccessFile f = new RandomAccessFile(fFile, "rw");) {
f.writeInt(-1);
long found = fCheckpointCollection.binarySearch(checkpoint);
assertEquals(0, found);
+ assertEquals(1, fCheckpointCollection.size());
}
/**
fCheckpointCollection.insert(checkpoint);
}
- fCheckpointCollection.setIndexComplete();
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
if (isPersistableCollection()) {
fCheckpointCollection.dispose();
}
if (isPersistableCollection()) {
fCheckpointCollection = createCollection();
}
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
for (int i = 0; i < CHECKPOINTS_INSERT_NUM; i++) {
Integer randomCheckpoint = list.get(i);
long found = fCheckpointCollection.binarySearch(checkpoint);
assertEquals(randomCheckpoint.intValue(), found);
}
+
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
}
/**
TmfCheckpoint checkpoint = new TmfCheckpoint(new TmfTimestamp(12345), new TmfLongLocation(123456L + i), i);
fCheckpointCollection.insert(checkpoint);
}
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
- fCheckpointCollection.setIndexComplete();
if (isPersistableCollection()) {
fCheckpointCollection.dispose();
}
if (isPersistableCollection()) {
fCheckpointCollection = createCollection();
}
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
for (int i = 0; i < CHECKPOINTS_INSERT_NUM; i++) {
Integer randomCheckpoint = list.get(i);
TmfCheckpoint checkpoint = new TmfCheckpoint(new TmfTimestamp(2 * i), new TmfLongLocation(2 * i), i);
fCheckpointCollection.insert(checkpoint);
}
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
TmfCheckpoint searchedCheckpoint = new TmfCheckpoint(new TmfTimestamp(123), new TmfLongLocation(123L), 123);
int expectedInsertionPoint = 61;
@Test
public void testBinarySearchInBetweenSameTimestamp() {
int checkpointNum = 0;
- for (; checkpointNum < 100; checkpointNum++) {
+ for (; checkpointNum < CHECKPOINTS_INSERT_NUM / 2; checkpointNum++) {
TmfCheckpoint checkpoint = new TmfCheckpoint(new TmfTimestamp(0), new TmfLongLocation(checkpointNum), checkpointNum);
fCheckpointCollection.insert(checkpoint);
}
- for (; checkpointNum < 200; checkpointNum++) {
+ for (; checkpointNum < CHECKPOINTS_INSERT_NUM; checkpointNum++) {
TmfCheckpoint checkpoint = new TmfCheckpoint(new TmfTimestamp(1), new TmfLongLocation(checkpointNum), checkpointNum);
fCheckpointCollection.insert(checkpoint);
}
+ assertEquals(CHECKPOINTS_INSERT_NUM, fCheckpointCollection.size());
final TmfCheckpoint searchedCheckpoint = new TmfCheckpoint(new TmfTimestamp(1), null, 0);
long found = fCheckpointCollection.binarySearch(searchedCheckpoint);
- int expectedInsertionPoint = 99;
+ int expectedInsertionPoint = CHECKPOINTS_INSERT_NUM / 2 - 1;
int expectedRank = -(expectedInsertionPoint + 2);
assertEquals(expectedRank, found);
}
+
+ /**
+ * Test checkpoint insertions after reopening the file.
+ */
+ @Test
+ public void testInsertAfterReopen() {
+ if (!isPersistableCollection()) {
+ return;
+ }
+
+ fCheckpointCollection.insert(new TmfCheckpoint(new TmfTimestamp(12345), new TmfLongLocation(123456L), 0));
+
+ assertEquals(1, fCheckpointCollection.size());
+
+ fCheckpointCollection.dispose();
+ fCheckpointCollection = createCollection();
+ assertEquals(1, fCheckpointCollection.size());
+
+ TmfCheckpoint checkpoint = new TmfCheckpoint(new TmfTimestamp(12345), new TmfLongLocation(123456L), 0);
+ long found = fCheckpointCollection.binarySearch(checkpoint);
+ assertEquals(0, found);
+
+ fCheckpointCollection.insert(new TmfCheckpoint(new TmfTimestamp(12345 + 1), new TmfLongLocation(123456L + 1), 1));
+ assertEquals(2, fCheckpointCollection.size());
+
+ fCheckpointCollection.dispose();
+ fCheckpointCollection = createCollection();
+ assertEquals(2, fCheckpointCollection.size());
+ }
}
}
time += (System.currentTimeMillis() - old);
- bTree.setIndexComplete();
bTree.dispose();
if (j != REPEAT - 1) {
file.delete();
}
time += (System.currentTimeMillis() - old);
- array.setIndexComplete();
array.dispose();
if (j != REPEAT - 1) {
file.delete();
assertEquals(checkpoint, treeVisitor.getCheckpoint());
}
}
-
- /**
- * Test setSize, size
- */
- @Override
- @Test
- public void testSetGetSize() {
- assertEquals(0, fBTree.size());
- int expected = CHECKPOINTS_INSERT_NUM;
- for (int i = 0; i < expected; ++i) {
- fBTree.insert(new TmfCheckpoint(new TmfTimestamp(0), new TmfLongLocation(0L), 0));
- fBTree.setSize(fBTree.size() + 1);
- }
- assertEquals(expected, fBTree.size());
- }
-
}
import org.eclipse.core.runtime.Path;
import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
import org.eclipse.tracecompass.tmf.core.exceptions.TmfTraceException;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
+import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.tests.TmfCoreTestPlugin;
import org.eclipse.tracecompass.tmf.core.tests.shared.TmfTestTrace;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
*
*/
protected static final int BLOCK_SIZE = 100;
- private static final int NB_EVENTS = 10000;
+ /**
+ * The expected number of events in the test trace.
+ */
+ protected static final int NB_EVENTS = 10000;
+ /**
+ * Used to dispose the trace once the desired number of events has been
+ * reached in the trace. This has the wanted side effect of stopping the
+ * indexing once a number of events has been reached.
+ */
+ protected long fNbEventsLimit;
/**
* The trace being tested
*/
*/
@Before
public void setUp() {
+ fNbEventsLimit = Long.MAX_VALUE;
setupTrace(getTracePath());
}
public ITestIndexer getIndexer() {
return (ITestIndexer) super.getIndexer();
}
+
+ /**
+ * Track the number of events in the trace in order to stop when the
+ * limit has been reached (fNbEventsLimit).
+ *
+ * @param signal
+ * the TmfTraceUpdatedSignal
+ */
+ @TmfSignalHandler
+ public void testTraceUpdated(final TmfTraceUpdatedSignal signal) {
+ if (getNbEvents() >= fNbEventsLimit) {
+ dispose();
+ }
+ }
}
private class EmptyTestTrace extends TmfEmptyTraceStub {
ITmfCheckpointIndex checkpoints = fTrace.getIndexer().getCheckpoints();
int pageSize = fTrace.getCacheSize();
assertTrue(checkpoints != null);
+ assertEquals(NB_EVENTS, checkpoints.getNbEvents());
assertEquals(NB_EVENTS / BLOCK_SIZE, checkpoints.size());
// Validate that each checkpoint points to the right event
package org.eclipse.tracecompass.tmf.core.tests.trace.indexer.checkpoint;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import java.io.File;
+
+import org.eclipse.tracecompass.internal.tmf.core.trace.indexer.BTree;
+import org.eclipse.tracecompass.internal.tmf.core.trace.indexer.FlatArray;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
import org.eclipse.tracecompass.tmf.core.trace.indexer.TmfBTreeTraceIndexer;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpointIndex;
import org.junit.Test;
verifyIndexContent();
}
+ /**
+ * Test that the indexer can resume from a partially built index reloaded
+ * from disk
+ *
+ * @throws Exception
+ * when error occurs
+ */
+ @Test
+ public void testInsertAfterReopenIndex() throws Exception {
+ // Make sure we start from a completely non-existing index
+ fTrace.dispose();
+ String directory = TmfTraceManager.getSupplementaryFileDir(fTrace);
+ new File(directory + BTree.INDEX_FILE_NAME).delete();
+ new File(directory + FlatArray.INDEX_FILE_NAME).delete();
+
+ // Index half of the trace
+ fNbEventsLimit = NB_EVENTS / 2;
+ fTrace = createTrace(getTracePath());
+ assertTrue(fTrace.getIndexer().getCheckpoints().isCreatedFromScratch());
+ // The trace should not have been indexed completely
+ assertEquals(fNbEventsLimit, fTrace.getNbEvents());
+
+ // Finish indexing the trace
+ fNbEventsLimit = Long.MAX_VALUE;
+ fTrace = createTrace(getTracePath());
+ assertFalse(fTrace.getIndexer().getCheckpoints().isCreatedFromScratch());
+
+ verifyIndexContent();
+ }
+
}
\ No newline at end of file
*/
public abstract class AbstractFileCheckpointCollection implements ICheckpointCollection {
- private static final int VERSION = 2;
+ private static final int INVALID_VERSION = -1;
+ private static final int VERSION = 3;
private static final int SUB_VERSION_NONE = -1;
/**
private static final int SIZE = INT_SIZE +
INT_SIZE +
LONG_SIZE +
- LONG_SIZE;
+ LONG_SIZE +
+ MAX_TIME_RANGE_SERIALIZE_SIZE;
/**
* Get the size of the header in bytes. This should be overridden if the
fVersion = randomAccessFile.readInt();
fSize = randomAccessFile.readInt();
fNbEvents = randomAccessFile.readLong();
- fTimeRangeOffset = randomAccessFile.readLong();
+ ByteBuffer b = ByteBuffer.allocate(MAX_TIME_RANGE_SERIALIZE_SIZE);
+ b.clear();
+ fFileChannel.read(b);
+ b.flip();
+ fTimeRange = new TmfTimeRange(new TmfTimestamp(b), new TmfTimestamp(b));
}
/**
*/
public void serialize(RandomAccessFile randomAccessFile) throws IOException {
randomAccessFile.seek(0);
- randomAccessFile.writeInt(getVersion());
+ // Version is written at the very last on dispose
+ randomAccessFile.writeInt(INVALID_VERSION);
randomAccessFile.writeInt(fSize);
randomAccessFile.writeLong(fNbEvents);
- randomAccessFile.writeLong(fTimeRangeOffset);
+
+ ByteBuffer b = ByteBuffer.allocate(MAX_TIME_RANGE_SERIALIZE_SIZE);
+ b.clear();
+ new TmfTimestamp(fTimeRange.getStartTime()).serialize(b);
+ new TmfTimestamp(fTimeRange.getEndTime()).serialize(b);
+ b.rewind();
+ fFileChannel.write(b);
}
/**
* The size of the collection expressed in a number of checkpoints.
*/
protected int fSize = 0;
- /**
- * Offset in bytes where the time range is store
- */
- protected long fTimeRangeOffset;
/**
* The total number of events in the trace
*/
protected long fNbEvents;
+
+ /**
+ * The time range of the trace.
+ */
+ protected TmfTimeRange fTimeRange = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.ZERO);
}
/**
/**
* The maximum size of the serialize buffer when writing the time range
*/
- protected static final int MAX_TIME_RANGE_SERIALIZE_SIZE = 1024;
+ protected static final int MAX_TIME_RANGE_SERIALIZE_SIZE = 128;
/**
* The originating trace
// Cached values
private FileChannel fFileChannel;
- private TmfTimeRange fTimeRange;
/**
* Constructs a checkpoint collection for a given trace from scratch or from
// Reserve space for header
fRandomAccessFile.setLength(header.getSize());
-
- fTimeRange = new TmfTimeRange(new TmfTimestamp(0), new TmfTimestamp(0));
- TmfCoreTracer.traceIndexer(CheckpointCollectionFileHeader.class.getSimpleName() + " initialize " + "nbEvents: " + header.fNbEvents + " fTimeRangeOffset: " + header.fTimeRangeOffset + " fTimeRange: " + fTimeRange); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ TmfCoreTracer.traceIndexer(CheckpointCollectionFileHeader.class.getSimpleName() + " initialize " + "nbEvents: " + header.fNbEvents + " fTimeRange: " + header.fTimeRange); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
} catch (IOException e) {
Activator.logError(MessageFormat.format(Messages.ErrorOpeningIndex, fFile), e);
return null;
CheckpointCollectionFileHeader header = null;
try {
- fRandomAccessFile = new RandomAccessFile(fFile, "r"); //$NON-NLS-1$
+ fRandomAccessFile = new RandomAccessFile(fFile, "rw"); //$NON-NLS-1$
fFileChannel = fRandomAccessFile.getChannel();
} catch (FileNotFoundException e) {
Activator.logError(MessageFormat.format(Messages.ErrorOpeningIndex, fFile), e);
if (header.fVersion != VERSION || header.getSubVersion() != getSubVersion()) {
return null;
}
- serializeInTimeRange(header);
- TmfCoreTracer.traceIndexer(CheckpointCollectionFileHeader.class.getSimpleName() + " read " + fFile + " nbEvents: " + header.fNbEvents + " fTimeRangeOffset: " + header.fTimeRangeOffset + " fTimeRange: " + fTimeRange); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
+ TmfCoreTracer.traceIndexer(CheckpointCollectionFileHeader.class.getSimpleName() + " read " + fFile + " nbEvents: " + header.fNbEvents + " fTimeRange: " + header.fTimeRange); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ // Write an invalid version until the very last moment when dispose
+ // the index. This is how we know if it's corrupted or not.
+ fRandomAccessFile.seek(0);
+ fRandomAccessFile.writeInt(INVALID_VERSION);
} catch (IOException e) {
Activator.logError(MessageFormat.format(Messages.IOErrorReadingHeader, fFile), e);
return null;
return header;
}
- private void serializeInTimeRange(CheckpointCollectionFileHeader header) throws IOException {
- ByteBuffer b = ByteBuffer.allocate(MAX_TIME_RANGE_SERIALIZE_SIZE);
- b.clear();
- fFileChannel.read(b, header.fTimeRangeOffset);
- b.flip();
- fTimeRange = new TmfTimeRange(new TmfTimestamp(b), new TmfTimestamp(b));
- }
-
- private void serializeOutTimeRange() throws IOException {
- fHeader.fTimeRangeOffset = fRandomAccessFile.length();
- ByteBuffer b = ByteBuffer.allocate(MAX_TIME_RANGE_SERIALIZE_SIZE);
- b.clear();
- new TmfTimestamp(fTimeRange.getStartTime()).serialize(b);
- new TmfTimestamp(fTimeRange.getEndTime()).serialize(b);
- b.flip();
- fFileChannel.write(b, fHeader.fTimeRangeOffset);
- }
-
- /**
- * Set the index as complete. No more checkpoints will be inserted.
- */
- @Override
- public void setIndexComplete() {
- try {
- serializeOutTimeRange();
-
- fHeader.serialize(fRandomAccessFile);
- } catch (IOException e) {
- Activator.logError(MessageFormat.format(Messages.IOErrorWritingHeader, fFile), e);
- }
- }
-
/**
*
* @return true if the checkpoint collection was created from scratch, false
*/
@Override
public void setTimeRange(TmfTimeRange timeRange) {
- fTimeRange = timeRange;
+ fHeader.fTimeRange = timeRange;
}
/**
*/
@Override
public TmfTimeRange getTimeRange() {
- return fTimeRange;
+ return fHeader.fTimeRange;
}
/**
*/
public CheckpointCollectionFileHeader getHeader() {
return fHeader;
- }/**
+ }
+
+ /**
* Dispose and delete the checkpoint collection
*/
@Override
public void dispose() {
try {
if (fRandomAccessFile != null) {
+ if (fHeader != null) {
+ fHeader.serialize(fRandomAccessFile);
+ }
+
+ fRandomAccessFile.seek(0);
+ fRandomAccessFile.writeInt(getVersion());
+
fRandomAccessFile.close();
}
setCreatedFromScratch(true);
fRandomAccessFile = null;
- String headerTrace = fHeader == null ? "" : "nbEvents: " + fHeader.fNbEvents + " timerange:" + fTimeRange; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ String headerTrace = fHeader == null ? "" : "nbEvents: " + fHeader.fNbEvents + " timerange:" + fHeader.fTimeRange; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
TmfCoreTracer.traceIndexer(this.getClass().getSimpleName() + " disposed. " + headerTrace); //$NON-NLS-1$
} catch (IOException e) {
Activator.logError(MessageFormat.format(Messages.IOErrorClosingIndex, fFile), e);
}
}
node.setEntry(i, checkpoint);
+ CheckpointCollectionFileHeader header = getHeader();
+ ++header.fSize;
return;
}
}
return;
}
- /**
- * Set the index as complete. No more checkpoints will be inserted.
- */
- @Override
- public void setIndexComplete() {
- super.setIndexComplete();
-
- fNodeCache.serialize();
- }
-
/**
* Get the maximum number of entries in a node
*
return fMaxNumEntries;
}
- /**
- * Set the size of the BTree, expressed as a number of checkpoints
- *
- * @param size
- * the size of the BTree
- */
- public void setSize(int size) {
- fBTreeHeader.fSize = size;
- }
-
/**
* Get the maximum number of children in a node
*
ByteBuffer getNodeByteBuffer() {
return fNodeByteBuffer;
}
+
+ @Override
+ public void dispose() {
+ if (fNodeCache != null) {
+ fNodeCache.serialize();
+ }
+
+ super.dispose();
+ }
}
*/
long getNbEvents();
- /**
- * Set the index as complete. No more checkpoints will be inserted.
- */
- void setIndexComplete();
-
/**
* Dispose the collection and delete persistent data (file)
*/
import java.util.List;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpoint;
import org.eclipse.tracecompass.tmf.core.trace.indexer.checkpoint.ITmfCheckpointIndex;
public class TmfMemoryIndex implements ITmfCheckpointIndex, ICheckpointCollection {
private final List<ITmfCheckpoint> fCheckpoints;
+ private TmfTimeRange fTimeRange;
+ private long fNbEvents;
/**
* Creates an index for the given trace
*/
public TmfMemoryIndex(ITmfTrace trace) {
fCheckpoints = new ArrayList<>();
+ fTimeRange = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.ZERO);
+ fNbEvents = 0;
}
@Override
@Override
public void setTimeRange(TmfTimeRange timeRange) {
+ fTimeRange = timeRange;
}
@Override
public void setNbEvents(long nbEvents) {
+ fNbEvents = nbEvents;
}
@Override
public TmfTimeRange getTimeRange() {
- return null;
+ return fTimeRange;
}
@Override
public long getNbEvents() {
- return 0;
- }
-
- @Override
- public void setIndexComplete() {
+ return fNbEvents;
}
@Override
public void insert(ITmfCheckpoint checkpoint) {
fCheckpoints.insert(checkpoint);
fCheckpointRanks.insert(checkpoint);
- fCheckpoints.setSize(fCheckpoints.size() + 1);
}
@Override
public long getNbEvents() {
return fCheckpoints.getNbEvents();
}
-
- @Override
- public void setIndexComplete() {
- fCheckpoints.setIndexComplete();
- fCheckpointRanks.setIndexComplete();
- }
-
}
public long getNbEvents() {
return fCheckpoints.getNbEvents();
}
-
- @Override
- public void setIndexComplete() {
- fCheckpoints.setIndexComplete();
- }
-
}
* @return the total number of events
*/
long getNbEvents();
-
- /**
- * Set the index as complete. No more checkpoints will be inserted.
- */
- void setIndexComplete();
}
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
-import org.eclipse.tracecompass.tmf.core.trace.ITmfTraceCompleteness;
import org.eclipse.tracecompass.tmf.core.trace.indexer.ITmfTraceIndexer;
import org.eclipse.tracecompass.tmf.core.trace.location.ITmfLocation;
*/
private ITmfEventRequest fIndexingRequest = null;
+ /** Whether or not the index was built once */
+ private boolean fBuiltOnce;
+
// ------------------------------------------------------------------------
// Construction
// ------------------------------------------------------------------------
@Override
public void buildIndex(final long offset, final TmfTimeRange range, final boolean waitForCompletion) {
+ long indexingOffset = offset;
+ TmfTimeRange indexingTimeRange = range;
+
// Don't do anything if we are already indexing
synchronized (fTraceIndex) {
if (fIsIndexing) {
fIsIndexing = true;
}
- // No need to build the index, it has been restored
- if (!fTraceIndex.isCreatedFromScratch()) {
+ // Restore previously built index values
+ if (!fTraceIndex.isCreatedFromScratch() && !fBuiltOnce && fTraceIndex.getNbEvents() > 0) {
+ indexingOffset = fTraceIndex.getNbEvents();
+ indexingTimeRange = new TmfTimeRange(fTraceIndex.getTimeRange().getStartTime(), TmfTimestamp.BIG_CRUNCH);
+ TmfCoreTracer.traceIndexer("restoring index. nbEvents: " + fTraceIndex.getNbEvents() + " time range: " + fTraceIndex.getTimeRange()); //$NON-NLS-1$ //$NON-NLS-2$
// Set some trace attributes that depends on indexing
- TmfCoreTracer.traceIndexer("Restoring index. nbEvents: " + fTraceIndex.getNbEvents() + " time range: " + fTraceIndex.getTimeRange()); //$NON-NLS-1$ //$NON-NLS-2$
- TmfTraceUpdatedSignal signal = new TmfTraceUpdatedSignal(this, fTrace, new TmfTimeRange(fTraceIndex.getTimeRange().getStartTime(), fTraceIndex.getTimeRange().getEndTime()), fTraceIndex.getNbEvents());
- if (waitForCompletion) {
- fTrace.broadcast(signal);
- } else {
- fTrace.broadcastAsync(signal);
- }
- fIsIndexing = false;
- return;
+ TmfTraceUpdatedSignal signal = new TmfTraceUpdatedSignal(this, fTrace, new TmfTimeRange(fTraceIndex.getTimeRange().getStartTime(), fTraceIndex.getTimeRange().getEndTime()), indexingOffset);
+ fTrace.broadcast(signal);
}
- TmfCoreTracer.traceIndexer("buildIndex. offset: " + offset + " time range: " + range); //$NON-NLS-1$ //$NON-NLS-2$
+ TmfCoreTracer.traceIndexer("buildIndex. offset: " + indexingOffset + " (requested " + offset + ")" + " time range: " + range); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
// The monitoring job
final Job job = new Job("Indexing " + fTrace.getName() + "...") { //$NON-NLS-1$ //$NON-NLS-2$
return Status.OK_STATUS;
}
};
- job.setSystem(!isCompleteTrace(fTrace));
+ job.setSystem(fBuiltOnce);
+ fBuiltOnce = true;
job.schedule();
// Build a background request for all the trace data. The index is
// updated as we go by readNextEvent().
fIndexingRequest = new TmfEventRequest(ITmfEvent.class,
- range, offset, ITmfEventRequest.ALL_DATA,
+ indexingTimeRange, indexingOffset, ITmfEventRequest.ALL_DATA,
ITmfEventRequest.ExecutionType.BACKGROUND) {
@Override
public void handleData(final ITmfEvent event) {
@Override
public void handleSuccess() {
- fTraceIndex.setTimeRange(fTrace.getTimeRange());
- fTraceIndex.setNbEvents(fTrace.getNbEvents());
- if (isCompleteTrace(fTrace)) {
- fTraceIndex.setIndexComplete();
- }
updateTraceStatus();
}
@Override
public void handleCompleted() {
job.cancel();
+ fTraceIndex.setTimeRange(fTrace.getTimeRange());
+ fTraceIndex.setNbEvents(fTrace.getNbEvents());
super.handleCompleted();
fIsIndexing = false;
- TmfCoreTracer.traceIndexer("Build index request done. nbEvents: " + fTraceIndex.getNbEvents() + " time range: " + fTraceIndex.getTimeRange()); //$NON-NLS-1$ //$NON-NLS-2$
+ TmfCoreTracer.traceIndexer("Build index request completed. nbEvents: " + fTraceIndex.getNbEvents() + " time range: " + fTraceIndex.getTimeRange()); //$NON-NLS-1$ //$NON-NLS-2$
}
private void updateTraceStatus() {
protected ITmfCheckpointIndex getTraceIndex() {
return fTraceIndex;
}
-
- private static boolean isCompleteTrace(ITmfTrace trace) {
- return !(trace instanceof ITmfTraceCompleteness) || ((ITmfTraceCompleteness)trace).isComplete();
- }
}
projects / deliverable / tracecompass.git / commitdiff
