1 /*******************************************************************************
2 * Copyright (c) 2012 Ericsson
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * Francois Chouinard - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.core
.trace
;
15 import java
.util
.ArrayList
;
16 import java
.util
.Collections
;
17 import java
.util
.List
;
19 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
20 import org
.eclipse
.core
.runtime
.IStatus
;
21 import org
.eclipse
.core
.runtime
.Status
;
22 import org
.eclipse
.core
.runtime
.jobs
.Job
;
23 import org
.eclipse
.linuxtools
.internal
.tmf
.core
.trace
.TmfExperimentContext
;
24 import org
.eclipse
.linuxtools
.tmf
.core
.component
.TmfDataProvider
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfEvent
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.event
.ITmfTimestamp
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfDataRequest
;
29 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfEventRequest
;
30 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfDataRequest
;
31 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfEventRequest
;
32 import org
.eclipse
.linuxtools
.tmf
.core
.signal
.TmfTraceUpdatedSignal
;
35 * A simple indexer that manages the trace index as an array of trace
36 * checkpoints. Checkpoints are stored at fixed intervals (event rank) in
37 * ascending timestamp order.
39 * The goal being to access a random trace event reasonably fast from the user's
40 * standpoint, picking the right interval value becomes a trade-off between speed
41 * and memory usage (a shorter inter-event interval is faster but requires more
44 * Locating a specific checkpoint is trivial for both rank (rank % interval) and
45 * timestamp (bsearch in the array).
48 * @author Francois Chouinard
53 public class TmfCheckpointIndexer
implements ITmfTraceIndexer
{
55 // ------------------------------------------------------------------------
57 // ------------------------------------------------------------------------
59 // The event trace to index
60 protected final ITmfTrace fTrace
;
62 // The interval between checkpoints
63 private final int fCheckpointInterval
;
65 // The event trace to index
66 private boolean fIsIndexing
;
69 * The trace index. It is composed of checkpoints taken at intervals of
70 * fCheckpointInterval events.
72 protected final List
<ITmfCheckpoint
> fTraceIndex
;
75 * The indexing request
77 private ITmfEventRequest fIndexingRequest
= null;
79 // ------------------------------------------------------------------------
81 // ------------------------------------------------------------------------
84 * Basic constructor that uses the default trace block size as checkpoints
87 * @param trace the trace to index
89 public TmfCheckpointIndexer(final ITmfTrace trace
) {
90 this(trace
, TmfDataProvider
.DEFAULT_BLOCK_SIZE
);
96 * @param trace the trace to index
97 * @param interval the checkpoints interval
99 public TmfCheckpointIndexer(final ITmfTrace trace
, final int interval
) {
101 fCheckpointInterval
= interval
;
102 fTraceIndex
= new ArrayList
<ITmfCheckpoint
>();
107 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#dispose()
110 public void dispose() {
111 if ((fIndexingRequest
!= null) && !fIndexingRequest
.isCompleted()) {
112 fIndexingRequest
.cancel();
117 // ------------------------------------------------------------------------
118 // ITmfTraceIndexer - isIndexing
119 // ------------------------------------------------------------------------
122 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#isIndexing()
125 public boolean isIndexing() {
129 // ------------------------------------------------------------------------
130 // ITmfTraceIndexer - buildIndex
131 // ------------------------------------------------------------------------
135 * The index is a list of contexts that point to events at regular interval
136 * (rank-wise) in the trace. After it is built, the index can be used to
137 * quickly access any event by rank or timestamp (using seekIndex()).
139 * The index is built simply by reading the trace
141 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#buildIndex(long, org.eclipse.linuxtools.tmf.core.event.TmfTimeRange, boolean)
144 public void buildIndex(final long offset
, final TmfTimeRange range
, final boolean waitForCompletion
) {
146 // Don't do anything if we are already indexing
147 synchronized (fTraceIndex
) {
154 // The monitoring job
155 final Job job
= new Job("Indexing " + fTrace
.getName() + "...") { //$NON-NLS-1$ //$NON-NLS-2$
157 protected IStatus
run(final IProgressMonitor monitor
) {
158 while (!monitor
.isCanceled()) {
161 } catch (final InterruptedException e
) {
162 return Status
.OK_STATUS
;
166 return Status
.OK_STATUS
;
171 // Build a background request for all the trace data. The index is
172 // updated as we go by readNextEvent().
173 fIndexingRequest
= new TmfEventRequest(ITmfEvent
.class,
174 range
, offset
, TmfDataRequest
.ALL_DATA
, fCheckpointInterval
, ITmfDataRequest
.ExecutionType
.BACKGROUND
)
176 private ITmfTimestamp startTime
= null;
177 private ITmfTimestamp lastTime
= null;
180 public void handleData(final ITmfEvent event
) {
181 super.handleData(event
);
183 final ITmfTimestamp timestamp
= event
.getTimestamp();
184 if (startTime
== null) {
185 startTime
= timestamp
.clone();
187 lastTime
= timestamp
.clone();
189 // Update the trace status at regular intervals
190 if ((getNbRead() % fCheckpointInterval
) == 0) {
197 public void handleSuccess() {
202 public void handleCompleted() {
204 super.handleCompleted();
208 private void updateTraceStatus() {
209 if (getNbRead() != 0) {
210 signalNewTimeRange(startTime
, lastTime
);
215 // Submit the request and wait for completion if required
216 fTrace
.sendRequest(fIndexingRequest
);
217 if (waitForCompletion
) {
219 fIndexingRequest
.waitForCompletion();
220 } catch (final InterruptedException e
) {
226 * Notify the interested parties that the trace time range has changed
228 * @param startTime the new start time
229 * @param endTime the new end time
231 private void signalNewTimeRange(final ITmfTimestamp startTime
, final ITmfTimestamp endTime
) {
232 fTrace
.broadcast(new TmfTraceUpdatedSignal(fTrace
, fTrace
, new TmfTimeRange(startTime
, endTime
)));
235 // ------------------------------------------------------------------------
236 // ITmfTraceIndexer - updateIndex
237 // ------------------------------------------------------------------------
240 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#updateIndex(org.eclipse.linuxtools.tmf.core.trace.ITmfContext, org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp)
243 public synchronized void updateIndex(final ITmfContext context
, final ITmfTimestamp timestamp
) {
244 final long rank
= context
.getRank();
245 if ((rank
% fCheckpointInterval
) == 0) {
246 // Determine the table position
247 final long position
= rank
/ fCheckpointInterval
;
248 // Add new entry at proper location (if empty)
249 if (fTraceIndex
.size() == position
) {
250 fTraceIndex
.add(new TmfCheckpoint(timestamp
.clone(), saveContext(context
)));
255 // ------------------------------------------------------------------------
256 // ITmfTraceIndexer - seekIndex
257 // ------------------------------------------------------------------------
260 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#seekIndex(org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp)
263 public synchronized ITmfContext
seekIndex(final ITmfTimestamp timestamp
) {
265 // A null timestamp indicates to seek the first event
266 if (timestamp
== null) {
267 return fTrace
.seekEvent(0);
270 // Find the checkpoint at or before the requested timestamp.
271 // In the very likely event that the timestamp is not at a checkpoint
272 // boundary, bsearch will return index = (- (insertion point + 1)).
273 // It is then trivial to compute the index of the previous checkpoint.
274 int index
= Collections
.binarySearch(fTraceIndex
, new TmfCheckpoint(timestamp
, null));
276 index
= Math
.max(0, -(index
+ 2));
279 // Position the trace at the checkpoint
280 return restoreCheckpoint(index
);
284 * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTraceIndexer#seekIndex(long)
287 public ITmfContext
seekIndex(final long rank
) {
289 // A rank < 0 indicates to seek the first event
291 return fTrace
.seekEvent(0);
294 // Find the checkpoint at or before the requested rank.
295 final int index
= (int) rank
/ fCheckpointInterval
;
297 // Position the trace at the checkpoint
298 return restoreCheckpoint(index
);
302 * Position the trace at the given checkpoint
304 * @param checkpoint the checkpoint index
305 * @return the corresponding context
307 private ITmfContext
restoreCheckpoint(final int checkpoint
) {
308 ITmfLocation
<?
> location
= null;
310 synchronized (fTraceIndex
) {
311 if (!fTraceIndex
.isEmpty()) {
313 if (index
>= fTraceIndex
.size()) {
314 index
= fTraceIndex
.size() - 1;
316 return restoreContext(fTraceIndex
.get(index
).getContext());
319 final ITmfContext context
= fTrace
.seekEvent(location
);
320 context
.setRank((long) index
* fCheckpointInterval
);
324 // ------------------------------------------------------------------------
326 // ------------------------------------------------------------------------
329 * @return the trace index
331 protected List
<ITmfCheckpoint
> getTraceIndex() {
335 // ------------------------------------------------------------------------
336 // Context conversion functions
337 // ------------------------------------------------------------------------
339 private static ITmfContext
saveContext(ITmfContext context
) {
340 if (context
instanceof TmfExperimentContext
) {
341 return saveExpContext(context
);
343 TmfContext ctx
= new TmfContext(context
.getLocation().clone(), context
.getRank());
347 private static ITmfContext
saveExpContext(ITmfContext context
) {
348 TmfExperimentContext expContext
= (TmfExperimentContext
) context
;
349 int size
= expContext
.getContexts().length
;
350 ITmfContext
[] trcCtxts
= new TmfContext
[size
];
351 for (int i
= 0; i
< size
; i
++) {
352 ITmfContext ctx
= expContext
.getContexts()[i
];
353 trcCtxts
[i
] = (ctx
!= null) ?
new TmfContext(ctx
.getLocation().clone(), ctx
.getRank()) : null;
355 TmfExperimentContext expCtx
= new TmfExperimentContext(trcCtxts
);
356 expCtx
.setLocation(context
.getLocation().clone());
357 expCtx
.setRank(context
.getRank());
358 ITmfEvent
[] trcEvts
= expCtx
.getEvents();
359 for (int i
= 0; i
< size
; i
++) {
360 ITmfEvent event
= expContext
.getEvents()[i
];
361 trcEvts
[i
] = (event
!= null) ? event
.clone() : null;
366 private ITmfContext
restoreContext(ITmfContext context
) {
367 if (context
instanceof TmfExperimentContext
) {
368 return restoreExpContext(context
);
370 ITmfContext ctx
= fTrace
.seekEvent(context
.getLocation());
371 ctx
.setRank(context
.getRank());
375 private ITmfContext
restoreExpContext(ITmfContext context
) {
376 TmfExperimentContext expContext
= (TmfExperimentContext
) context
;
377 int size
= expContext
.getContexts().length
;
378 ITmfContext
[] trcCtxts
= new ITmfContext
[size
];
379 for (int i
= 0; i
< size
; i
++) {
380 ITmfTrace trace
= ((TmfExperiment
) fTrace
).getTraces()[i
];
381 ITmfContext ctx
= expContext
.getContexts()[i
];
382 trcCtxts
[i
] = trace
.seekEvent(ctx
.getLocation().clone());
383 trcCtxts
[i
].setRank(ctx
.getRank());
385 TmfExperimentContext ctx
= new TmfExperimentContext(trcCtxts
);
386 ctx
.setLocation(context
.getLocation().clone());
387 ctx
.setRank(context
.getRank());
388 ITmfEvent
[] trcEvts
= expContext
.getEvents();
389 for (int i
= 0; i
< size
; i
++) {
390 ITmfEvent event
= trcEvts
[i
];
391 ctx
.getEvents()[i
] = (event
!= null) ? event
.clone() : null;