Commit | Line | Data |
---|---|---|
8c8bf09f | 1 | /******************************************************************************* |
0316808c | 2 | * Copyright (c) 2009, 2010, 2012 Ericsson |
ce2388e0 | 3 | * |
8c8bf09f ASL |
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 | |
ce2388e0 | 8 | * |
8c8bf09f ASL |
9 | * Contributors: |
10 | * Francois Chouinard - Initial API and implementation | |
0316808c | 11 | * Francois Chouinard - Updated as per TMF Trace Model 1.0 |
8c8bf09f ASL |
12 | *******************************************************************************/ |
13 | ||
6c13869b | 14 | package org.eclipse.linuxtools.tmf.core.experiment; |
8c8bf09f | 15 | |
a1091415 | 16 | import org.eclipse.core.resources.IFile; |
12c155f5 | 17 | import org.eclipse.core.resources.IProject; |
828e5592 | 18 | import org.eclipse.core.resources.IResource; |
72f1e62a | 19 | import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; |
4df4581d | 20 | import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp; |
6c13869b FC |
21 | import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange; |
22 | import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; | |
0316808c | 23 | import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException; |
6c13869b FC |
24 | import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest; |
25 | import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest; | |
1b70b6dc | 26 | import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal; |
6c13869b FC |
27 | import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentDisposedSignal; |
28 | import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentRangeUpdatedSignal; | |
29 | import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal; | |
30 | import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal; | |
31 | import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler; | |
6c13869b | 32 | import org.eclipse.linuxtools.tmf.core.trace.ITmfContext; |
0316808c | 33 | import org.eclipse.linuxtools.tmf.core.trace.ITmfEventParser; |
6c13869b FC |
34 | import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation; |
35 | import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace; | |
0316808c FC |
36 | import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer; |
37 | import org.eclipse.linuxtools.tmf.core.trace.TmfTrace; | |
8c8bf09f ASL |
38 | |
39 | /** | |
cbdacf03 FC |
40 | * TmfExperiment presents a time-ordered, unified view of a set of TmfTraces |
41 | * that are part of a tracing experiment. | |
8c8bf09f | 42 | */ |
0316808c | 43 | public class TmfExperiment<T extends ITmfEvent> extends TmfTrace<T> implements ITmfEventParser<T> { |
8c8bf09f ASL |
44 | |
45 | // ------------------------------------------------------------------------ | |
46 | // Attributes | |
47 | // ------------------------------------------------------------------------ | |
48 | ||
a79913eb | 49 | // The currently selected experiment |
0316808c | 50 | private static TmfExperiment<?> fCurrentExperiment = null; |
e31e01e8 | 51 | |
a79913eb | 52 | // The set of traces that constitute the experiment |
0316808c | 53 | private ITmfTrace<T>[] fTraces; |
8c8bf09f | 54 | |
828e5592 PT |
55 | // Flag to initialize only once |
56 | private boolean fInitialized = false; | |
57 | ||
a1091415 PT |
58 | // The experiment bookmarks file |
59 | private IFile fBookmarksFile; | |
60 | ||
07671572 FC |
61 | // // The properties resource |
62 | // private IResource fResource; | |
828e5592 | 63 | |
8c8bf09f ASL |
64 | // ------------------------------------------------------------------------ |
65 | // Constructors | |
66 | // ------------------------------------------------------------------------ | |
67 | ||
12c155f5 | 68 | @Override |
cbdacf03 | 69 | public boolean validate(final IProject project, final String path) { |
12c155f5 FC |
70 | return true; |
71 | } | |
72 | ||
73 | @Override | |
07671572 FC |
74 | public void initTrace(final IResource resource, final String path, final Class<T> type) { |
75 | // fResource = resource; | |
76 | try { | |
77 | super.initTrace(resource, path, type); | |
78 | } catch (TmfTraceException e) { | |
79 | // TODO Auto-generated catch block | |
80 | e.printStackTrace(); | |
81 | } | |
96c6806f PT |
82 | } |
83 | ||
8c8bf09f ASL |
84 | /** |
85 | * @param type | |
86 | * @param id | |
87 | * @param traces | |
88 | * @param epoch | |
89 | * @param indexPageSize | |
0316808c | 90 | * @throws TmfTraceException |
8c8bf09f | 91 | */ |
cbdacf03 | 92 | public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces, final ITmfTimestamp epoch, |
0316808c FC |
93 | final int indexPageSize) |
94 | { | |
a4115405 | 95 | this(type, id, traces, TmfTimestamp.ZERO, indexPageSize, false); |
a79913eb | 96 | } |
cb866e08 | 97 | |
0316808c FC |
98 | @SuppressWarnings({ "unchecked", "rawtypes" }) |
99 | public TmfExperiment(final Class<T> type, final String path, final ITmfTrace<T>[] traces, final ITmfTimestamp epoch, | |
100 | final int indexPageSize, final boolean preIndexExperiment) | |
101 | { | |
102 | setCacheSize(indexPageSize); | |
103 | setStreamingInterval(0); | |
07671572 | 104 | setIndexer(new TmfCheckpointIndexer(this, indexPageSize)); |
0316808c FC |
105 | setParser(this); |
106 | try { | |
107 | super.initialize(null, path, type); | |
108 | } catch (TmfTraceException e) { | |
109 | e.printStackTrace(); | |
110 | } | |
8c8bf09f | 111 | |
a79913eb | 112 | fTraces = traces; |
a87cc4ef | 113 | setTimeRange(TmfTimeRange.NULL_RANGE); |
8c8bf09f | 114 | |
a87cc4ef FC |
115 | if (preIndexExperiment) { |
116 | getIndexer().buildIndex(true); | |
a87cc4ef | 117 | } |
a79913eb | 118 | } |
8c8bf09f ASL |
119 | |
120 | /** | |
121 | * @param type | |
122 | * @param id | |
123 | * @param traces | |
0316808c | 124 | * @throws TmfTraceException |
8c8bf09f | 125 | */ |
cbdacf03 | 126 | public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces) { |
a4115405 | 127 | this(type, id, traces, TmfTimestamp.ZERO, DEFAULT_INDEX_PAGE_SIZE); |
8c8bf09f ASL |
128 | } |
129 | ||
130 | /** | |
131 | * @param type | |
132 | * @param id | |
133 | * @param traces | |
134 | * @param indexPageSize | |
0316808c | 135 | * @throws TmfTraceException |
8c8bf09f | 136 | */ |
cbdacf03 | 137 | public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces, final int indexPageSize) { |
a4115405 | 138 | this(type, id, traces, TmfTimestamp.ZERO, indexPageSize); |
8c8bf09f | 139 | } |
a79913eb | 140 | |
8c8bf09f | 141 | /** |
ff4ed569 | 142 | * Clears the experiment |
8c8bf09f ASL |
143 | */ |
144 | @Override | |
12c155f5 | 145 | @SuppressWarnings("rawtypes") |
a79913eb FC |
146 | public synchronized void dispose() { |
147 | ||
cbdacf03 | 148 | final TmfExperimentDisposedSignal<T> signal = new TmfExperimentDisposedSignal<T>(this, this); |
a79913eb | 149 | broadcast(signal); |
cbdacf03 | 150 | if (fCurrentExperiment == this) |
09d11238 | 151 | fCurrentExperiment = null; |
a79913eb FC |
152 | |
153 | if (fTraces != null) { | |
cbdacf03 | 154 | for (final ITmfTrace trace : fTraces) |
a79913eb | 155 | trace.dispose(); |
a79913eb FC |
156 | fTraces = null; |
157 | } | |
2fb2eb37 | 158 | super.dispose(); |
8c8bf09f ASL |
159 | } |
160 | ||
161 | // ------------------------------------------------------------------------ | |
e31e01e8 | 162 | // Accessors |
8c8bf09f ASL |
163 | // ------------------------------------------------------------------------ |
164 | ||
cbdacf03 FC |
165 | public static void setCurrentExperiment(final TmfExperiment<?> experiment) { |
166 | if (fCurrentExperiment != null && fCurrentExperiment != experiment) | |
09d11238 | 167 | fCurrentExperiment.dispose(); |
a79913eb | 168 | fCurrentExperiment = experiment; |
f6b14ce2 FC |
169 | } |
170 | ||
e31e01e8 | 171 | public static TmfExperiment<?> getCurrentExperiment() { |
a79913eb | 172 | return fCurrentExperiment; |
8c8bf09f ASL |
173 | } |
174 | ||
12c155f5 | 175 | public ITmfTrace<T>[] getTraces() { |
a79913eb | 176 | return fTraces; |
8c8bf09f ASL |
177 | } |
178 | ||
8c8bf09f | 179 | /** |
cbdacf03 FC |
180 | * Returns the timestamp of the event at the requested index. If none, |
181 | * returns null. | |
a79913eb | 182 | * |
0d9a6d76 FC |
183 | * @param index the event index (rank) |
184 | * @return the corresponding event timestamp | |
8c8bf09f | 185 | */ |
cbdacf03 | 186 | public ITmfTimestamp getTimestamp(final int index) { |
0316808c | 187 | final ITmfContext context = seekEvent(index); |
b4f71e4a | 188 | final ITmfEvent event = readNextEvent(context); |
a79913eb | 189 | return (event != null) ? event.getTimestamp() : null; |
8c8bf09f ASL |
190 | } |
191 | ||
8c8bf09f ASL |
192 | // ------------------------------------------------------------------------ |
193 | // TmfProvider | |
194 | // ------------------------------------------------------------------------ | |
a79913eb | 195 | |
a79913eb | 196 | @Override |
cbdacf03 | 197 | public ITmfContext armRequest(final ITmfDataRequest<T> request) { |
ce2388e0 | 198 | ITmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ? ((ITmfEventRequest<T>) request).getRange().getStartTime() : null; |
07671572 FC |
199 | if (TmfTimestamp.BIG_BANG.equals(timestamp) || request.getIndex() > 0) { |
200 | timestamp = null; | |
201 | } | |
202 | ||
0316808c | 203 | ITmfContext context = null; |
07671572 | 204 | if (timestamp != null) { // Seek by timestamp |
a79913eb FC |
205 | context = seekEvent(timestamp); |
206 | ((ITmfEventRequest<T>) request).setStartIndex((int) context.getRank()); | |
07671572 FC |
207 | } else { // Seek by rank |
208 | context = seekEvent(request.getIndex()); | |
209 | } | |
210 | ||
a79913eb FC |
211 | return context; |
212 | } | |
213 | ||
a79913eb | 214 | // ------------------------------------------------------------------------ |
9f584e4c FC |
215 | // ITmfTrace trace positioning |
216 | // ------------------------------------------------------------------------ | |
217 | ||
a79913eb FC |
218 | // Returns a brand new context based on the location provided |
219 | // and initializes the event queues | |
220 | @Override | |
7e6347b0 | 221 | public synchronized TmfExperimentContext seekEvent(final ITmfLocation<?> location) { |
a79913eb | 222 | // Validate the location |
cbdacf03 | 223 | if (location != null && !(location instanceof TmfExperimentLocation)) |
a79913eb | 224 | return null; // Throw an exception? |
8f50c396 | 225 | |
cbdacf03 | 226 | if (fTraces == null) |
a79913eb | 227 | return null; |
8f50c396 | 228 | |
a79913eb | 229 | // Instantiate the location |
cbdacf03 | 230 | final TmfExperimentLocation expLocation = (location == null) ? new TmfExperimentLocation(new TmfLocationArray( |
0316808c | 231 | new ITmfLocation<?>[fTraces.length])) : (TmfExperimentLocation) location.clone(); |
8f50c396 | 232 | |
a79913eb | 233 | // Create and populate the context's traces contexts |
0316808c | 234 | final TmfExperimentContext context = new TmfExperimentContext(new ITmfContext[fTraces.length]); |
9b635e61 | 235 | |
a79913eb FC |
236 | for (int i = 0; i < fTraces.length; i++) { |
237 | // Get the relevant trace attributes | |
0316808c | 238 | final ITmfLocation<?> traceLocation = expLocation.getLocation().getLocations()[i]; |
7e6347b0 | 239 | context.getContexts()[i] = fTraces[i].seekEvent(traceLocation); |
0316808c | 240 | expLocation.getLocation().getLocations()[i] = context.getContexts()[i].getLocation().clone(); |
b4f71e4a | 241 | context.getEvents()[i] = fTraces[i].readNextEvent(context.getContexts()[i]); |
a79913eb | 242 | } |
8f50c396 | 243 | |
a79913eb FC |
244 | // Finalize context |
245 | context.setLocation(expLocation); | |
246 | context.setLastTrace(TmfExperimentContext.NO_TRACE); | |
0316808c | 247 | context.setRank(ITmfContext.UNKNOWN_RANK); |
a79913eb FC |
248 | return context; |
249 | } | |
9f584e4c | 250 | |
c76c54bb | 251 | @Override |
0316808c FC |
252 | public ITmfContext seekEvent(final double ratio) { |
253 | final ITmfContext context = seekEvent((long) (ratio * getNbEvents())); | |
c76c54bb FC |
254 | return context; |
255 | } | |
256 | ||
a79913eb | 257 | @Override |
cbdacf03 FC |
258 | public double getLocationRatio(final ITmfLocation<?> location) { |
259 | if (location instanceof TmfExperimentLocation) | |
7e6347b0 | 260 | return (double) seekEvent(location).getRank() / getNbEvents(); |
c76c54bb FC |
261 | return 0; |
262 | } | |
263 | ||
a79913eb FC |
264 | @Override |
265 | public ITmfLocation<?> getCurrentLocation() { | |
a87cc4ef FC |
266 | ITmfLocation<?>[] locations = new ITmfLocation<?>[fTraces.length]; |
267 | for (int i = 0; i < fTraces.length; i++) { | |
268 | locations[i] = fTraces[i].getCurrentLocation(); | |
269 | } | |
270 | return new TmfExperimentLocation(new TmfLocationArray(locations)); | |
a79913eb | 271 | } |
c76c54bb | 272 | |
07671572 FC |
273 | /* (non-Javadoc) |
274 | * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#readNextEvent(org.eclipse.linuxtools.tmf.core.trace.ITmfContext) | |
275 | */ | |
276 | @Override | |
277 | public synchronized ITmfEvent readNextEvent(final ITmfContext context) { | |
a0a4901e | 278 | final ITmfContext previousContext = (TmfExperimentContext) context.clone(); |
07671572 FC |
279 | final ITmfEvent event = parseEvent(context); |
280 | if (event != null) { | |
a0a4901e | 281 | updateAttributes(previousContext, event.getTimestamp()); |
07671572 FC |
282 | |
283 | TmfExperimentContext expContext = (TmfExperimentContext) context; | |
284 | int trace = expContext.getLastTrace(); | |
285 | if (trace != TmfExperimentContext.NO_TRACE) { | |
286 | TmfExperimentLocation location = (TmfExperimentLocation) expContext.getLocation(); | |
287 | location.getLocation().getLocations()[trace] = expContext.getContexts()[trace].getLocation(); | |
288 | } | |
289 | ||
290 | context.increaseRank(); | |
291 | processEvent(event); | |
292 | } | |
293 | return event; | |
294 | } | |
a79913eb | 295 | |
ce2388e0 FC |
296 | /* (non-Javadoc) |
297 | * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools .tmf.trace.TmfContext) | |
a79913eb | 298 | */ |
0316808c FC |
299 | @SuppressWarnings("unchecked") |
300 | @Override | |
a87cc4ef | 301 | public T parseEvent(ITmfContext context) { |
a79913eb FC |
302 | |
303 | // Validate the context | |
cbdacf03 | 304 | if (!(context instanceof TmfExperimentContext)) |
a79913eb | 305 | return null; // Throw an exception? |
a79913eb | 306 | |
a87cc4ef | 307 | TmfExperimentContext expContext = (TmfExperimentContext) context; |
a79913eb | 308 | |
a87cc4ef | 309 | // If an event was consumed previously, first get the next one from that trace |
cbdacf03 | 310 | final int lastTrace = expContext.getLastTrace(); |
a79913eb | 311 | if (lastTrace != TmfExperimentContext.NO_TRACE) { |
cbdacf03 | 312 | final ITmfContext traceContext = expContext.getContexts()[lastTrace]; |
0316808c | 313 | expContext.getEvents()[lastTrace] = fTraces[lastTrace].readNextEvent(traceContext); |
a79913eb | 314 | expContext.setLastTrace(TmfExperimentContext.NO_TRACE); |
a79913eb FC |
315 | } |
316 | ||
317 | // Scan the candidate events and identify the "next" trace to read from | |
318 | int trace = TmfExperimentContext.NO_TRACE; | |
a4115405 | 319 | ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH; |
0316808c | 320 | for (int i = 0; i < fTraces.length; i++) { |
cbdacf03 | 321 | final ITmfEvent event = expContext.getEvents()[i]; |
a79913eb | 322 | if (event != null && event.getTimestamp() != null) { |
cbdacf03 | 323 | final ITmfTimestamp otherTS = event.getTimestamp(); |
a79913eb FC |
324 | if (otherTS.compareTo(timestamp, true) < 0) { |
325 | trace = i; | |
326 | timestamp = otherTS; | |
327 | } | |
328 | } | |
329 | } | |
a87cc4ef FC |
330 | |
331 | T event = null; | |
07671572 | 332 | if (trace != TmfExperimentContext.NO_TRACE) { |
a87cc4ef | 333 | event = (T) expContext.getEvents()[trace]; |
07671572 | 334 | } |
a87cc4ef | 335 | |
a87cc4ef FC |
336 | expContext.setLastTrace(trace); |
337 | return event; | |
a79913eb FC |
338 | } |
339 | ||
bcbea6a6 | 340 | /* (non-Javadoc) |
a79913eb FC |
341 | * @see java.lang.Object#toString() |
342 | */ | |
343 | @Override | |
3b38ea61 | 344 | @SuppressWarnings("nls") |
a79913eb FC |
345 | public String toString() { |
346 | return "[TmfExperiment (" + getName() + ")]"; | |
347 | } | |
8c8bf09f ASL |
348 | |
349 | // ------------------------------------------------------------------------ | |
350 | // Indexing | |
351 | // ------------------------------------------------------------------------ | |
352 | ||
1b70b6dc | 353 | private synchronized void initializeStreamingMonitor() { |
cbdacf03 | 354 | if (fInitialized) |
828e5592 | 355 | return; |
828e5592 PT |
356 | fInitialized = true; |
357 | ||
1b70b6dc | 358 | if (getStreamingInterval() == 0) { |
0316808c | 359 | final ITmfContext context = seekEvent(0); |
cbdacf03 FC |
360 | final ITmfEvent event = getNext(context); |
361 | if (event == null) | |
1b70b6dc | 362 | return; |
cbdacf03 | 363 | final TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp().clone(), TmfTimestamp.BIG_CRUNCH); |
828e5592 PT |
364 | final TmfExperimentRangeUpdatedSignal signal = new TmfExperimentRangeUpdatedSignal(this, this, timeRange); |
365 | ||
366 | // Broadcast in separate thread to prevent deadlock | |
367 | new Thread() { | |
368 | @Override | |
369 | public void run() { | |
370 | broadcast(signal); | |
371 | } | |
372 | }.start(); | |
1b70b6dc PT |
373 | return; |
374 | } | |
375 | ||
bcbea6a6 FC |
376 | final Thread thread = new Thread("Streaming Monitor for experiment " + getName()) { ////$NON-NLS-1$ |
377 | private ITmfTimestamp safeTimestamp = null; | |
378 | private TmfTimeRange timeRange = null; | |
1b70b6dc PT |
379 | |
380 | @Override | |
381 | public void run() { | |
382 | while (!fExecutor.isShutdown()) { | |
383 | if (!isIndexingBusy()) { | |
a4115405 FC |
384 | ITmfTimestamp startTimestamp = TmfTimestamp.BIG_CRUNCH; |
385 | ITmfTimestamp endTimestamp = TmfTimestamp.BIG_BANG; | |
cbdacf03 FC |
386 | for (final ITmfTrace<T> trace : fTraces) { |
387 | if (trace.getStartTime().compareTo(startTimestamp) < 0) | |
1b70b6dc | 388 | startTimestamp = trace.getStartTime(); |
cbdacf03 | 389 | if (trace.getStreamingInterval() != 0 && trace.getEndTime().compareTo(endTimestamp) > 0) |
1b70b6dc | 390 | endTimestamp = trace.getEndTime(); |
1b70b6dc | 391 | } |
cbdacf03 | 392 | if (safeTimestamp != null && safeTimestamp.compareTo(getTimeRange().getEndTime(), false) > 0) |
1b70b6dc | 393 | timeRange = new TmfTimeRange(startTimestamp, safeTimestamp); |
cbdacf03 | 394 | else |
1b70b6dc | 395 | timeRange = null; |
1b70b6dc PT |
396 | safeTimestamp = endTimestamp; |
397 | if (timeRange != null) { | |
cbdacf03 | 398 | final TmfExperimentRangeUpdatedSignal signal = |
1b70b6dc PT |
399 | new TmfExperimentRangeUpdatedSignal(TmfExperiment.this, TmfExperiment.this, timeRange); |
400 | broadcast(signal); | |
401 | } | |
402 | } | |
403 | try { | |
404 | Thread.sleep(getStreamingInterval()); | |
cbdacf03 | 405 | } catch (final InterruptedException e) { |
1b70b6dc PT |
406 | e.printStackTrace(); |
407 | } | |
408 | } | |
409 | } | |
410 | }; | |
411 | thread.start(); | |
412 | } | |
413 | ||
cbdacf03 FC |
414 | /* |
415 | * (non-Javadoc) | |
416 | * | |
1b70b6dc PT |
417 | * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#getStreamingInterval() |
418 | */ | |
419 | @Override | |
420 | public long getStreamingInterval() { | |
421 | long interval = 0; | |
cbdacf03 | 422 | for (final ITmfTrace<T> trace : fTraces) |
1b70b6dc | 423 | interval = Math.max(interval, trace.getStreamingInterval()); |
1b70b6dc PT |
424 | return interval; |
425 | } | |
426 | ||
a79913eb | 427 | /* |
cbdacf03 FC |
428 | * The experiment holds the globally ordered events of its set of traces. It |
429 | * is expected to provide access to each individual event by index i.e. it | |
430 | * must be possible to request the Nth event of the experiment. | |
a79913eb | 431 | * |
cbdacf03 FC |
432 | * The purpose of the index is to keep the information needed to rapidly |
433 | * restore the traces contexts at regular intervals (every INDEX_PAGE_SIZE | |
434 | * event). | |
a79913eb | 435 | */ |
8c8bf09f | 436 | |
a79913eb FC |
437 | // The index page size |
438 | private static final int DEFAULT_INDEX_PAGE_SIZE = 5000; | |
a87cc4ef | 439 | // protected int fIndexPageSize; |
a79913eb | 440 | protected boolean fIndexing = false; |
a4115405 | 441 | protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.NULL_RANGE; |
e31e01e8 | 442 | |
1b70b6dc PT |
443 | private Integer fEndSynchReference; |
444 | ||
a79913eb | 445 | protected boolean isIndexingBusy() { |
07671572 | 446 | return fIndexing; |
a79913eb FC |
447 | } |
448 | ||
a79913eb FC |
449 | |
450 | protected void notifyListeners() { | |
451 | broadcast(new TmfExperimentUpdatedSignal(this, this)); // , null)); | |
452 | } | |
453 | ||
8c8bf09f ASL |
454 | // ------------------------------------------------------------------------ |
455 | // Signal handlers | |
456 | // ------------------------------------------------------------------------ | |
457 | ||
458 | @TmfSignalHandler | |
cbdacf03 FC |
459 | public void experimentSelected(final TmfExperimentSelectedSignal<T> signal) { |
460 | final TmfExperiment<?> experiment = signal.getExperiment(); | |
a79913eb FC |
461 | if (experiment == this) { |
462 | setCurrentExperiment(experiment); | |
6e85c58d | 463 | fEndSynchReference = Integer.valueOf(signal.getReference()); |
a79913eb | 464 | } |
8c8bf09f ASL |
465 | } |
466 | ||
1b70b6dc | 467 | @TmfSignalHandler |
cbdacf03 | 468 | public void endSync(final TmfEndSynchSignal signal) { |
1b70b6dc PT |
469 | if (fEndSynchReference != null && fEndSynchReference.intValue() == signal.getReference()) { |
470 | fEndSynchReference = null; | |
471 | initializeStreamingMonitor(); | |
472 | } | |
1b70b6dc PT |
473 | } |
474 | ||
8c8bf09f | 475 | @TmfSignalHandler |
cbdacf03 | 476 | public void experimentUpdated(final TmfExperimentUpdatedSignal signal) { |
8c8bf09f ASL |
477 | } |
478 | ||
1b70b6dc | 479 | @TmfSignalHandler |
cbdacf03 | 480 | public void experimentRangeUpdated(final TmfExperimentRangeUpdatedSignal signal) { |
0316808c | 481 | if (signal.getExperiment() == this) { |
0316808c FC |
482 | getIndexer().buildIndex(false); |
483 | } | |
1b70b6dc PT |
484 | } |
485 | ||
12c155f5 FC |
486 | @Override |
487 | public String getPath() { | |
488 | // TODO Auto-generated method stub | |
489 | return null; | |
490 | } | |
491 | ||
828e5592 | 492 | /** |
a1091415 | 493 | * Set the file to be used for bookmarks on this experiment |
cbdacf03 | 494 | * |
a1091415 | 495 | * @param file the bookmarks file |
828e5592 | 496 | */ |
cbdacf03 | 497 | public void setBookmarksFile(final IFile file) { |
a1091415 PT |
498 | fBookmarksFile = file; |
499 | } | |
500 | ||
501 | /** | |
502 | * Get the file used for bookmarks on this experiment | |
cbdacf03 | 503 | * |
a1091415 PT |
504 | * @return the bookmarks file or null if none is set |
505 | */ | |
506 | public IFile getBookmarksFile() { | |
507 | return fBookmarksFile; | |
508 | } | |
509 | ||
07671572 FC |
510 | // /* |
511 | // * (non-Javadoc) | |
512 | // * | |
513 | // * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getResource() | |
514 | // */ | |
515 | // @Override | |
516 | // public IResource getResource() { | |
517 | // return fResource; | |
518 | // } | |
4dc47e28 | 519 | } |
07671572 FC |
520 | |
521 | ||
522 | ///******************************************************************************* | |
523 | // * Copyright (c) 2009, 2010 Ericsson | |
524 | // * | |
525 | // * All rights reserved. This program and the accompanying materials are | |
526 | // * made available under the terms of the Eclipse Public License v1.0 which | |
527 | // * accompanies this distribution, and is available at | |
528 | // * http://www.eclipse.org/legal/epl-v10.html | |
529 | // * | |
530 | // * Contributors: | |
531 | // * Francois Chouinard - Initial API and implementation | |
532 | // *******************************************************************************/ | |
533 | // | |
534 | //package org.eclipse.linuxtools.tmf.core.experiment; | |
535 | // | |
536 | //import java.util.Collections; | |
537 | //import java.util.Vector; | |
538 | // | |
539 | //import org.eclipse.core.resources.IFile; | |
540 | //import org.eclipse.core.resources.IProject; | |
541 | //import org.eclipse.core.resources.IResource; | |
542 | //import org.eclipse.core.runtime.IProgressMonitor; | |
543 | //import org.eclipse.core.runtime.IStatus; | |
544 | //import org.eclipse.core.runtime.Status; | |
545 | //import org.eclipse.core.runtime.jobs.Job; | |
546 | //import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider; | |
547 | //import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; | |
548 | //import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp; | |
549 | //import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange; | |
550 | //import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp; | |
551 | //import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest; | |
552 | //import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest; | |
553 | //import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest; | |
554 | //import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest; | |
555 | //import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal; | |
556 | //import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentDisposedSignal; | |
557 | //import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentRangeUpdatedSignal; | |
558 | //import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal; | |
559 | //import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentUpdatedSignal; | |
560 | //import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler; | |
561 | //import org.eclipse.linuxtools.tmf.core.signal.TmfTraceUpdatedSignal; | |
562 | //import org.eclipse.linuxtools.tmf.core.trace.ITmfContext; | |
563 | //import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation; | |
564 | //import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace; | |
565 | //import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpoint; | |
566 | //import org.eclipse.linuxtools.tmf.core.trace.TmfContext; | |
567 | // | |
568 | ///** | |
569 | // * <b><u>TmfExperiment</u></b> | |
570 | // * <p> | |
571 | // * TmfExperiment presents a time-ordered, unified view of a set of TmfTraces | |
572 | // * that are part of a tracing experiment. | |
573 | // * <p> | |
574 | // */ | |
575 | //public class TmfExperiment<T extends ITmfEvent> extends TmfEventProvider<T> implements ITmfTrace<T> { | |
576 | // | |
577 | // // ------------------------------------------------------------------------ | |
578 | // // Attributes | |
579 | // // ------------------------------------------------------------------------ | |
580 | // | |
581 | // // The currently selected experiment | |
582 | // protected static TmfExperiment<?> fCurrentExperiment = null; | |
583 | // | |
584 | // // The set of traces that constitute the experiment | |
585 | // protected ITmfTrace<T>[] fTraces; | |
586 | // | |
587 | // // The total number of events | |
588 | // protected long fNbEvents; | |
589 | // | |
590 | // // The experiment time range | |
591 | // protected TmfTimeRange fTimeRange; | |
592 | // | |
593 | // // The experiment reference timestamp (default: ZERO) | |
594 | // protected ITmfTimestamp fEpoch; | |
595 | // | |
596 | // // The experiment index | |
597 | // protected Vector<TmfCheckpoint> fCheckpoints = new Vector<TmfCheckpoint>(); | |
598 | // | |
599 | // // The current experiment context | |
600 | // protected TmfExperimentContext fExperimentContext; | |
601 | // | |
602 | // // Flag to initialize only once | |
603 | // private boolean fInitialized = false; | |
604 | // | |
605 | // // The experiment bookmarks file | |
606 | // private IFile fBookmarksFile; | |
607 | // | |
608 | // // The properties resource | |
609 | // private IResource fResource; | |
610 | // | |
611 | // // ------------------------------------------------------------------------ | |
612 | // // Constructors | |
613 | // // ------------------------------------------------------------------------ | |
614 | // | |
615 | // @Override | |
616 | // public TmfExperiment<T> clone() throws CloneNotSupportedException { | |
617 | // throw new CloneNotSupportedException(); | |
618 | // } | |
619 | // | |
620 | // @Override | |
621 | // public boolean validate(final IProject project, final String path) { | |
622 | // return true; | |
623 | // } | |
624 | // | |
625 | // @Override | |
626 | // public void initTrace(final IResource resource, final String path, final Class<T> eventType) { | |
627 | // fResource = resource; | |
628 | // } | |
629 | // | |
630 | // /** | |
631 | // * @param type | |
632 | // * @param id | |
633 | // * @param traces | |
634 | // * @param epoch | |
635 | // * @param indexPageSize | |
636 | // */ | |
637 | // public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces, final ITmfTimestamp epoch, | |
638 | // final int indexPageSize) { | |
639 | // this(type, id, traces, TmfTimestamp.ZERO, indexPageSize, false); | |
640 | // } | |
641 | // | |
642 | // public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces, final ITmfTimestamp epoch, | |
643 | // final int indexPageSize, final boolean preIndexExperiment) { | |
644 | // super(id, type); | |
645 | // | |
646 | // fTraces = traces; | |
647 | // fEpoch = epoch; | |
648 | // fIndexPageSize = indexPageSize; | |
649 | // fTimeRange = TmfTimeRange.NULL_RANGE; | |
650 | // | |
651 | // if (preIndexExperiment) { | |
652 | // indexExperiment(true, 0, TmfTimeRange.ETERNITY); | |
653 | // updateTimeRange(); | |
654 | // } | |
655 | // } | |
656 | // | |
657 | // protected TmfExperiment(final String id, final Class<T> type) { | |
658 | // super(id, type); | |
659 | // } | |
660 | // | |
661 | // /** | |
662 | // * @param type | |
663 | // * @param id | |
664 | // * @param traces | |
665 | // */ | |
666 | // public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces) { | |
667 | // this(type, id, traces, TmfTimestamp.ZERO, DEFAULT_INDEX_PAGE_SIZE); | |
668 | // } | |
669 | // | |
670 | // /** | |
671 | // * @param type | |
672 | // * @param id | |
673 | // * @param traces | |
674 | // * @param indexPageSize | |
675 | // */ | |
676 | // public TmfExperiment(final Class<T> type, final String id, final ITmfTrace<T>[] traces, final int indexPageSize) { | |
677 | // this(type, id, traces, TmfTimestamp.ZERO, indexPageSize); | |
678 | // } | |
679 | // | |
680 | // /** | |
681 | // * Clears the experiment | |
682 | // */ | |
683 | // @Override | |
684 | // @SuppressWarnings("rawtypes") | |
685 | // public synchronized void dispose() { | |
686 | // | |
687 | // final TmfExperimentDisposedSignal<T> signal = new TmfExperimentDisposedSignal<T>(this, this); | |
688 | // broadcast(signal); | |
689 | // if (fCurrentExperiment == this) | |
690 | // fCurrentExperiment = null; | |
691 | // | |
692 | // if (fTraces != null) { | |
693 | // for (final ITmfTrace trace : fTraces) | |
694 | // trace.dispose(); | |
695 | // fTraces = null; | |
696 | // } | |
697 | // if (fCheckpoints != null) | |
698 | // fCheckpoints.clear(); | |
699 | // super.dispose(); | |
700 | // } | |
701 | // | |
702 | // // ------------------------------------------------------------------------ | |
703 | // // ITmfTrace | |
704 | // // ------------------------------------------------------------------------ | |
705 | // | |
706 | // @Override | |
707 | // public Class<T> getEventType() { | |
708 | // return fType; | |
709 | // } | |
710 | // | |
711 | // @Override | |
712 | // public long getNbEvents() { | |
713 | // return fNbEvents; | |
714 | // } | |
715 | // | |
716 | // @Override | |
717 | // public int getCacheSize() { | |
718 | // return fIndexPageSize; | |
719 | // } | |
720 | // | |
721 | // @Override | |
722 | // public TmfTimeRange getTimeRange() { | |
723 | // return fTimeRange; | |
724 | // } | |
725 | // | |
726 | // @Override | |
727 | // public ITmfTimestamp getStartTime() { | |
728 | // return fTimeRange.getStartTime(); | |
729 | // } | |
730 | // | |
731 | // @Override | |
732 | // public ITmfTimestamp getEndTime() { | |
733 | // return fTimeRange.getEndTime(); | |
734 | // } | |
735 | // | |
736 | // public Vector<TmfCheckpoint> getCheckpoints() { | |
737 | // return fCheckpoints; | |
738 | // } | |
739 | // | |
740 | // // ------------------------------------------------------------------------ | |
741 | // // Accessors | |
742 | // // ------------------------------------------------------------------------ | |
743 | // | |
744 | // public static void setCurrentExperiment(final TmfExperiment<?> experiment) { | |
745 | // if (fCurrentExperiment != null && fCurrentExperiment != experiment) | |
746 | // fCurrentExperiment.dispose(); | |
747 | // fCurrentExperiment = experiment; | |
748 | // } | |
749 | // | |
750 | // public static TmfExperiment<?> getCurrentExperiment() { | |
751 | // return fCurrentExperiment; | |
752 | // } | |
753 | // | |
754 | // public ITmfTimestamp getEpoch() { | |
755 | // return fEpoch; | |
756 | // } | |
757 | // | |
758 | // public ITmfTrace<T>[] getTraces() { | |
759 | // return fTraces; | |
760 | // } | |
761 | // | |
762 | // /** | |
763 | // * Returns the timestamp of the event at the requested index. If none, | |
764 | // * returns null. | |
765 | // * | |
766 | // * @param index the event index (rank) | |
767 | // * @return the corresponding event timestamp | |
768 | // */ | |
769 | // public ITmfTimestamp getTimestamp(final int index) { | |
770 | // final TmfExperimentContext context = seekEvent(index); | |
771 | // final ITmfEvent event = readNextEvent(context); | |
772 | // return (event != null) ? event.getTimestamp() : null; | |
773 | // } | |
774 | // | |
775 | // // ------------------------------------------------------------------------ | |
776 | // // Operators | |
777 | // // ------------------------------------------------------------------------ | |
778 | // | |
779 | // /** | |
780 | // * Update the global time range | |
781 | // */ | |
782 | // protected void updateTimeRange() { | |
783 | // ITmfTimestamp startTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getStartTime() : TmfTimestamp.BIG_CRUNCH; | |
784 | // ITmfTimestamp endTime = fTimeRange != TmfTimeRange.NULL_RANGE ? fTimeRange.getEndTime() : TmfTimestamp.BIG_BANG; | |
785 | // | |
786 | // for (final ITmfTrace<T> trace : fTraces) { | |
787 | // final ITmfTimestamp traceStartTime = trace.getStartTime(); | |
788 | // if (traceStartTime.compareTo(startTime, true) < 0) | |
789 | // startTime = traceStartTime; | |
790 | // final ITmfTimestamp traceEndTime = trace.getEndTime(); | |
791 | // if (traceEndTime.compareTo(endTime, true) > 0) | |
792 | // endTime = traceEndTime; | |
793 | // } | |
794 | // fTimeRange = new TmfTimeRange(startTime, endTime); | |
795 | // } | |
796 | // | |
797 | // // ------------------------------------------------------------------------ | |
798 | // // TmfProvider | |
799 | // // ------------------------------------------------------------------------ | |
800 | // | |
801 | // @Override | |
802 | // public ITmfContext armRequest(final ITmfDataRequest<T> request) { | |
803 | // // Tracer.trace("Ctx: Arming request - start"); | |
804 | // ITmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ? ((ITmfEventRequest<T>) request).getRange().getStartTime() : null; | |
805 | // if (TmfTimestamp.BIG_BANG.equals(timestamp) || request.getIndex() > 0) | |
806 | // timestamp = null; // use request index | |
807 | // TmfExperimentContext context = null; | |
808 | // if (timestamp != null) { | |
809 | // // seek by timestamp | |
810 | // context = seekEvent(timestamp); | |
811 | // ((ITmfEventRequest<T>) request).setStartIndex((int) context.getRank()); | |
812 | // } else // Seek by rank | |
813 | // if ((fExperimentContext != null) && fExperimentContext.getRank() == request.getIndex()) | |
814 | // // We are already at the right context -> no need to seek | |
815 | // context = fExperimentContext; | |
816 | // else | |
817 | // context = seekEvent(request.getIndex()); | |
818 | // // Tracer.trace("Ctx: Arming request - done"); | |
819 | // return context; | |
820 | // } | |
821 | // | |
822 | // @Override | |
823 | // @SuppressWarnings("unchecked") | |
824 | // public T getNext(final ITmfContext context) { | |
825 | // if (context instanceof TmfExperimentContext) | |
826 | // return (T) readNextEvent(context); | |
827 | // return null; | |
828 | // } | |
829 | // | |
830 | // // ------------------------------------------------------------------------ | |
831 | // // ITmfTrace trace positioning | |
832 | // // ------------------------------------------------------------------------ | |
833 | // | |
834 | // // Returns a brand new context based on the location provided | |
835 | // // and initializes the event queues | |
836 | // @Override | |
837 | // public synchronized TmfExperimentContext seekEvent(final ITmfLocation<?> location) { | |
838 | // // Validate the location | |
839 | // if (location != null && !(location instanceof TmfExperimentLocation)) | |
840 | // return null; // Throw an exception? | |
841 | // | |
842 | // if (fTraces == null) | |
843 | // return null; | |
844 | // | |
845 | // // Instantiate the location | |
846 | // final TmfExperimentLocation expLocation = (location == null) ? new TmfExperimentLocation(new TmfLocationArray( | |
847 | // new ITmfLocation<?>[fTraces.length]), new long[fTraces.length]) : (TmfExperimentLocation) location.clone(); | |
848 | // | |
849 | // // Create and populate the context's traces contexts | |
850 | // final TmfExperimentContext context = new TmfExperimentContext(fTraces, new ITmfContext[fTraces.length]); | |
851 | // // Tracer.trace("Ctx: SeekLocation - start"); | |
852 | // | |
853 | // long rank = 0; | |
854 | // for (int i = 0; i < fTraces.length; i++) { | |
855 | // // Get the relevant trace attributes | |
856 | // final ITmfLocation<?> traceLocation = expLocation.getLocation().locations[i]; | |
857 | // final long traceRank = expLocation.getRanks()[i]; | |
858 | // | |
859 | // // Set the corresponding sub-context | |
860 | // context.getContexts()[i] = fTraces[i].seekEvent(traceLocation); | |
861 | // context.getContexts()[i].setRank(traceRank); | |
862 | // rank += traceRank; | |
863 | // | |
864 | // // Set the trace location and read the corresponding event | |
865 | // /* | |
866 | // * The (TmfContext) cast should be safe since we created 'context' | |
867 | // * ourselves higher up. | |
868 | // */ | |
869 | // expLocation.getLocation().locations[i] = context.getContexts()[i].getLocation().clone(); | |
870 | // context.getEvents()[i] = fTraces[i].readNextEvent(context.getContexts()[i]); | |
871 | // } | |
872 | // | |
873 | // // Tracer.trace("Ctx: SeekLocation - done"); | |
874 | // | |
875 | // // Finalize context | |
876 | // context.setLocation(expLocation); | |
877 | // context.setLastTrace(TmfExperimentContext.NO_TRACE); | |
878 | // context.setRank(rank); | |
879 | // | |
880 | // fExperimentContext = context; | |
881 | // | |
882 | // return context; | |
883 | // } | |
884 | // | |
885 | // /* (non-Javadoc) | |
886 | // * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#seekEvent(org.eclipse.linuxtools .tmf.event.TmfTimestamp) | |
887 | // */ | |
888 | // @Override | |
889 | // public synchronized TmfExperimentContext seekEvent(ITmfTimestamp timestamp) { | |
890 | // | |
891 | // // Tracer.trace("Ctx: seekEvent(TS) - start"); | |
892 | // | |
893 | // if (timestamp == null) | |
894 | // timestamp = TmfTimestamp.BIG_BANG; | |
895 | // | |
896 | // // First, find the right checkpoint | |
897 | // int index = Collections.binarySearch(fCheckpoints, new TmfCheckpoint(timestamp, null)); | |
898 | // | |
899 | // // In the very likely case that the checkpoint was not found, bsearch | |
900 | // // returns its negated would-be location (not an offset...). From that | |
901 | // // index, we can then position the stream and get the event. | |
902 | // if (index < 0) | |
903 | // index = Math.max(0, -(index + 2)); | |
904 | // | |
905 | // // Position the experiment at the checkpoint | |
906 | // ITmfLocation<?> location; | |
907 | // synchronized (fCheckpoints) { | |
908 | // if (fCheckpoints.size() > 0) { | |
909 | // if (index >= fCheckpoints.size()) | |
910 | // index = fCheckpoints.size() - 1; | |
911 | // location = fCheckpoints.elementAt(index).getLocation(); | |
912 | // } else | |
913 | // location = null; | |
914 | // } | |
915 | // | |
916 | // final TmfExperimentContext context = seekEvent(location); | |
917 | // context.setRank((long) index * fIndexPageSize); | |
918 | // | |
919 | // // And locate the event | |
920 | // ITmfEvent event = parseEvent(context); | |
921 | // while ((event != null) && (event.getTimestamp().compareTo(timestamp, false) < 0)) { | |
922 | // readNextEvent(context); | |
923 | // event = parseEvent(context); | |
924 | // } | |
925 | // | |
926 | // if (event == null) { | |
927 | // context.setLocation(null); | |
928 | // context.setRank(ITmfContext.UNKNOWN_RANK); | |
929 | // } | |
930 | // | |
931 | // return context; | |
932 | // } | |
933 | // | |
934 | // /* (non-Javadoc) | |
935 | // * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#seekEvent(long) | |
936 | // */ | |
937 | // @Override | |
938 | // public synchronized TmfExperimentContext seekEvent(final long rank) { | |
939 | // | |
940 | // // Tracer.trace("Ctx: seekEvent(rank) - start"); | |
941 | // | |
942 | // // Position the stream at the previous checkpoint | |
943 | // int index = (int) rank / fIndexPageSize; | |
944 | // ITmfLocation<?> location; | |
945 | // synchronized (fCheckpoints) { | |
946 | // if (fCheckpoints.size() == 0) | |
947 | // location = null; | |
948 | // else { | |
949 | // if (index >= fCheckpoints.size()) | |
950 | // index = fCheckpoints.size() - 1; | |
951 | // location = fCheckpoints.elementAt(index).getLocation(); | |
952 | // } | |
953 | // } | |
954 | // | |
955 | // final TmfExperimentContext context = seekEvent(location); | |
956 | // context.setRank((long) index * fIndexPageSize); | |
957 | // | |
958 | // // And locate the event | |
959 | // ITmfEvent event = parseEvent(context); | |
960 | // long pos = context.getRank(); | |
961 | // while ((event != null) && (pos++ < rank)) { | |
962 | // readNextEvent(context); | |
963 | // event = parseEvent(context); | |
964 | // } | |
965 | // | |
966 | // if (event == null) { | |
967 | // context.setLocation(null); | |
968 | // context.setRank(ITmfContext.UNKNOWN_RANK); | |
969 | // } | |
970 | // | |
971 | // return context; | |
972 | // } | |
973 | // | |
974 | // @Override | |
975 | // public TmfContext seekEvent(final double ratio) { | |
976 | // final TmfContext context = seekEvent((long) (ratio * getNbEvents())); | |
977 | // return context; | |
978 | // } | |
979 | // | |
980 | // @Override | |
981 | // public double getLocationRatio(final ITmfLocation<?> location) { | |
982 | // if (location instanceof TmfExperimentLocation) | |
983 | // return (double) seekEvent(location).getRank() / getNbEvents(); | |
984 | // return 0; | |
985 | // } | |
986 | // | |
987 | // @Override | |
988 | // public ITmfLocation<?> getCurrentLocation() { | |
989 | // if (fExperimentContext != null) | |
990 | // return fExperimentContext.getLocation(); | |
991 | // return null; | |
992 | // } | |
993 | // | |
994 | // // private void dumpContext(TmfExperimentContext context, boolean isBefore) { | |
995 | // // TmfContext context0 = context.getContexts()[0]; | |
996 | // // TmfEvent event0 = context.getEvents()[0]; | |
997 | // // TmfExperimentLocation location0 = (TmfExperimentLocation) context.getLocation(); | |
998 | // // long rank0 = context.getRank(); | |
999 | // // int trace = context.getLastTrace(); | |
1000 | // // | |
1001 | // // StringBuffer result = new StringBuffer("Ctx: " + (isBefore ? "B " : "A ")); | |
1002 | // // | |
1003 | // // result.append("[Ctx: fLoc= " + context0.getLocation().toString() + ", fRnk= " + context0.getRank() + "] "); | |
1004 | // // result.append("[Evt: " + event0.getTimestamp().toString() + "] "); | |
1005 | // // result.append("[Loc: fLoc= " + location0.getLocation()[0].toString() + ", fRnk= " + location0.getRanks()[0] + "] "); | |
1006 | // // result.append("[Rnk: " + rank0 + "], [Trc: " + trace + "]"); | |
1007 | // // Tracer.trace(result.toString()); | |
1008 | // // } | |
1009 | // | |
1010 | // /** | |
1011 | // * Scan the next events from all traces and return the next one in | |
1012 | // * chronological order. | |
1013 | // * | |
1014 | // * @param context the trace context | |
1015 | // * @return the next event | |
1016 | // */ | |
1017 | // @Override | |
1018 | // public synchronized ITmfEvent readNextEvent(final ITmfContext context) { | |
1019 | // | |
1020 | // // Validate the context | |
1021 | // if (!(context instanceof TmfExperimentContext)) | |
1022 | // return null; // Throw an exception? | |
1023 | // | |
1024 | // if (!context.equals(fExperimentContext)) | |
1025 | // // Tracer.trace("Ctx: Restoring context"); | |
1026 | // fExperimentContext = seekEvent(context.getLocation()); | |
1027 | // | |
1028 | // final TmfExperimentContext expContext = (TmfExperimentContext) context; | |
1029 | // | |
1030 | // // dumpContext(expContext, true); | |
1031 | // | |
1032 | // // If an event was consumed previously, get the next one from that trace | |
1033 | // final int lastTrace = expContext.getLastTrace(); | |
1034 | // if (lastTrace != TmfExperimentContext.NO_TRACE) { | |
1035 | // final ITmfContext traceContext = expContext.getContexts()[lastTrace]; | |
1036 | // expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].readNextEvent(traceContext); | |
1037 | // expContext.setLastTrace(TmfExperimentContext.NO_TRACE); | |
1038 | // } | |
1039 | // | |
1040 | // // Scan the candidate events and identify the "next" trace to read from | |
1041 | // final ITmfEvent eventArray[] = expContext.getEvents(); | |
1042 | // if (eventArray == null) | |
1043 | // return null; | |
1044 | // int trace = TmfExperimentContext.NO_TRACE; | |
1045 | // ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH; | |
1046 | // if (eventArray.length == 1) { | |
1047 | // if (eventArray[0] != null) { | |
1048 | // timestamp = eventArray[0].getTimestamp(); | |
1049 | // trace = 0; | |
1050 | // } | |
1051 | // } else | |
1052 | // for (int i = 0; i < eventArray.length; i++) { | |
1053 | // final ITmfEvent event = eventArray[i]; | |
1054 | // if (event != null && event.getTimestamp() != null) { | |
1055 | // final ITmfTimestamp otherTS = event.getTimestamp(); | |
1056 | // if (otherTS.compareTo(timestamp, true) < 0) { | |
1057 | // trace = i; | |
1058 | // timestamp = otherTS; | |
1059 | // } | |
1060 | // } | |
1061 | // } | |
1062 | // // Update the experiment context and set the "next" event | |
1063 | // ITmfEvent event = null; | |
1064 | // if (trace != TmfExperimentContext.NO_TRACE) { | |
1065 | // updateIndex(expContext, timestamp); | |
1066 | // | |
1067 | // final ITmfContext traceContext = expContext.getContexts()[trace]; | |
1068 | // final TmfExperimentLocation expLocation = (TmfExperimentLocation) expContext.getLocation(); | |
1069 | // // expLocation.getLocation()[trace] = traceContext.getLocation().clone(); | |
1070 | // expLocation.getLocation().locations[trace] = traceContext.getLocation().clone(); | |
1071 | // | |
1072 | // // updateIndex(expContext, timestamp); | |
1073 | // | |
1074 | // expLocation.getRanks()[trace] = traceContext.getRank(); | |
1075 | // expContext.setLastTrace(trace); | |
1076 | // expContext.increaseRank(); | |
1077 | // event = expContext.getEvents()[trace]; | |
1078 | // fExperimentContext = expContext; | |
1079 | // } | |
1080 | // | |
1081 | // // if (event != null) { | |
1082 | // // Tracer.trace("Exp: " + (expContext.getRank() - 1) + ": " + event.getTimestamp().toString()); | |
1083 | // // dumpContext(expContext, false); | |
1084 | // // Tracer.trace("Ctx: Event returned= " + event.getTimestamp().toString()); | |
1085 | // // } | |
1086 | // | |
1087 | // return event; | |
1088 | // } | |
1089 | // | |
1090 | // public synchronized void updateIndex(final ITmfContext context, final ITmfTimestamp timestamp) { | |
1091 | // // Build the index as we go along | |
1092 | // final long rank = context.getRank(); | |
1093 | // if (context.hasValidRank() && (rank % fIndexPageSize) == 0) { | |
1094 | // // Determine the table position | |
1095 | // final long position = rank / fIndexPageSize; | |
1096 | // // Add new entry at proper location (if empty) | |
1097 | // if (fCheckpoints.size() == position) { | |
1098 | // final ITmfLocation<?> location = context.getLocation().clone(); | |
1099 | // fCheckpoints.add(new TmfCheckpoint(timestamp.clone(), location)); | |
1100 | // // System.out.println(this + "[" + (fCheckpoints.size() - 1) + "] " + timestamp + ", " | |
1101 | // // + location.toString()); | |
1102 | // } | |
1103 | // } | |
1104 | // } | |
1105 | // | |
1106 | // /* (non-Javadoc) | |
1107 | // * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#parseEvent(org.eclipse.linuxtools .tmf.trace.TmfContext) | |
1108 | // */ | |
1109 | //// @Override | |
1110 | // public ITmfEvent parseEvent(final ITmfContext context) { | |
1111 | // | |
1112 | // // Validate the context | |
1113 | // if (!(context instanceof TmfExperimentContext)) | |
1114 | // return null; // Throw an exception? | |
1115 | // | |
1116 | // if (!context.equals(fExperimentContext)) | |
1117 | // // Tracer.trace("Ctx: Restoring context"); | |
1118 | // seekEvent(context.getLocation()); | |
1119 | // | |
1120 | // final TmfExperimentContext expContext = (TmfExperimentContext) context; | |
1121 | // | |
1122 | // // If an event was consumed previously, get the next one from that trace | |
1123 | // final int lastTrace = expContext.getLastTrace(); | |
1124 | // if (lastTrace != TmfExperimentContext.NO_TRACE) { | |
1125 | // final ITmfContext traceContext = expContext.getContexts()[lastTrace]; | |
1126 | // expContext.getEvents()[lastTrace] = expContext.getTraces()[lastTrace].readNextEvent(traceContext); | |
1127 | // expContext.setLastTrace(TmfExperimentContext.NO_TRACE); | |
1128 | // fExperimentContext = (TmfExperimentContext) context; | |
1129 | // } | |
1130 | // | |
1131 | // // Scan the candidate events and identify the "next" trace to read from | |
1132 | // int trace = TmfExperimentContext.NO_TRACE; | |
1133 | // ITmfTimestamp timestamp = TmfTimestamp.BIG_CRUNCH; | |
1134 | // for (int i = 0; i < expContext.getTraces().length; i++) { | |
1135 | // final ITmfEvent event = expContext.getEvents()[i]; | |
1136 | // if (event != null && event.getTimestamp() != null) { | |
1137 | // final ITmfTimestamp otherTS = event.getTimestamp(); | |
1138 | // if (otherTS.compareTo(timestamp, true) < 0) { | |
1139 | // trace = i; | |
1140 | // timestamp = otherTS; | |
1141 | // } | |
1142 | // } | |
1143 | // } | |
1144 | // | |
1145 | // ITmfEvent event = null; | |
1146 | // if (trace != TmfExperimentContext.NO_TRACE) | |
1147 | // event = expContext.getEvents()[trace]; | |
1148 | // | |
1149 | // return event; | |
1150 | // } | |
1151 | // | |
1152 | // /* (non-Javadoc) | |
1153 | // * @see java.lang.Object#toString() | |
1154 | // */ | |
1155 | // @Override | |
1156 | // @SuppressWarnings("nls") | |
1157 | // public String toString() { | |
1158 | // return "[TmfExperiment (" + getName() + ")]"; | |
1159 | // } | |
1160 | // | |
1161 | // // ------------------------------------------------------------------------ | |
1162 | // // Indexing | |
1163 | // // ------------------------------------------------------------------------ | |
1164 | // | |
1165 | // private synchronized void initializeStreamingMonitor() { | |
1166 | // if (fInitialized) | |
1167 | // return; | |
1168 | // fInitialized = true; | |
1169 | // | |
1170 | // if (getStreamingInterval() == 0) { | |
1171 | // final TmfContext context = seekEvent(0); | |
1172 | // final ITmfEvent event = getNext(context); | |
1173 | // if (event == null) | |
1174 | // return; | |
1175 | // final TmfTimeRange timeRange = new TmfTimeRange(event.getTimestamp().clone(), TmfTimestamp.BIG_CRUNCH); | |
1176 | // final TmfExperimentRangeUpdatedSignal signal = new TmfExperimentRangeUpdatedSignal(this, this, timeRange); | |
1177 | // | |
1178 | // // Broadcast in separate thread to prevent deadlock | |
1179 | // new Thread() { | |
1180 | // @Override | |
1181 | // public void run() { | |
1182 | // broadcast(signal); | |
1183 | // } | |
1184 | // }.start(); | |
1185 | // return; | |
1186 | // } | |
1187 | // | |
1188 | // final Thread thread = new Thread("Streaming Monitor for experiment " + getName()) { ////$NON-NLS-1$ | |
1189 | // private ITmfTimestamp safeTimestamp = null; | |
1190 | // private TmfTimeRange timeRange = null; | |
1191 | // | |
1192 | // @Override | |
1193 | // public void run() { | |
1194 | // while (!fExecutor.isShutdown()) { | |
1195 | // if (!isIndexingBusy()) { | |
1196 | // ITmfTimestamp startTimestamp = TmfTimestamp.BIG_CRUNCH; | |
1197 | // ITmfTimestamp endTimestamp = TmfTimestamp.BIG_BANG; | |
1198 | // for (final ITmfTrace<T> trace : fTraces) { | |
1199 | // if (trace.getStartTime().compareTo(startTimestamp) < 0) | |
1200 | // startTimestamp = trace.getStartTime(); | |
1201 | // if (trace.getStreamingInterval() != 0 && trace.getEndTime().compareTo(endTimestamp) > 0) | |
1202 | // endTimestamp = trace.getEndTime(); | |
1203 | // } | |
1204 | // if (safeTimestamp != null && safeTimestamp.compareTo(getTimeRange().getEndTime(), false) > 0) | |
1205 | // timeRange = new TmfTimeRange(startTimestamp, safeTimestamp); | |
1206 | // else | |
1207 | // timeRange = null; | |
1208 | // safeTimestamp = endTimestamp; | |
1209 | // if (timeRange != null) { | |
1210 | // final TmfExperimentRangeUpdatedSignal signal = | |
1211 | // new TmfExperimentRangeUpdatedSignal(TmfExperiment.this, TmfExperiment.this, timeRange); | |
1212 | // broadcast(signal); | |
1213 | // } | |
1214 | // } | |
1215 | // try { | |
1216 | // Thread.sleep(getStreamingInterval()); | |
1217 | // } catch (final InterruptedException e) { | |
1218 | // e.printStackTrace(); | |
1219 | // } | |
1220 | // } | |
1221 | // } | |
1222 | // }; | |
1223 | // thread.start(); | |
1224 | // } | |
1225 | // | |
1226 | // /* | |
1227 | // * (non-Javadoc) | |
1228 | // * | |
1229 | // * @see org.eclipse.linuxtools.tmf.trace.ITmfTrace#getStreamingInterval() | |
1230 | // */ | |
1231 | // @Override | |
1232 | // public long getStreamingInterval() { | |
1233 | // long interval = 0; | |
1234 | // for (final ITmfTrace<T> trace : fTraces) | |
1235 | // interval = Math.max(interval, trace.getStreamingInterval()); | |
1236 | // return interval; | |
1237 | // } | |
1238 | // | |
1239 | // /* | |
1240 | // * The experiment holds the globally ordered events of its set of traces. It | |
1241 | // * is expected to provide access to each individual event by index i.e. it | |
1242 | // * must be possible to request the Nth event of the experiment. | |
1243 | // * | |
1244 | // * The purpose of the index is to keep the information needed to rapidly | |
1245 | // * restore the traces contexts at regular intervals (every INDEX_PAGE_SIZE | |
1246 | // * event). | |
1247 | // */ | |
1248 | // | |
1249 | // // The index page size | |
1250 | // private static final int DEFAULT_INDEX_PAGE_SIZE = 5000; | |
1251 | // protected int fIndexPageSize; | |
1252 | // protected boolean fIndexing = false; | |
1253 | // protected TmfTimeRange fIndexingPendingRange = TmfTimeRange.NULL_RANGE; | |
1254 | // | |
1255 | // private Integer fEndSynchReference; | |
1256 | // | |
1257 | // // private static BufferedWriter fEventLog = null; | |
1258 | // // private static BufferedWriter openLogFile(String filename) { | |
1259 | // // BufferedWriter outfile = null; | |
1260 | // // try { | |
1261 | // // outfile = new BufferedWriter(new FileWriter(filename)); | |
1262 | // // } catch (IOException e) { | |
1263 | // // e.printStackTrace(); | |
1264 | // // } | |
1265 | // // return outfile; | |
1266 | // // } | |
1267 | // | |
1268 | // protected boolean isIndexingBusy() { | |
1269 | // synchronized (fCheckpoints) { | |
1270 | // return fIndexing; | |
1271 | // } | |
1272 | // } | |
1273 | // | |
1274 | // @SuppressWarnings("unchecked") | |
1275 | // private void indexExperiment(final boolean waitForCompletion, final int index, final TmfTimeRange timeRange) { | |
1276 | // | |
1277 | // synchronized (fCheckpoints) { | |
1278 | // if (fIndexing) | |
1279 | // return; | |
1280 | // fIndexing = true; | |
1281 | // } | |
1282 | // | |
1283 | // final Job job = new Job("Indexing " + getName() + "...") { //$NON-NLS-1$ //$NON-NLS-2$ | |
1284 | // | |
1285 | // @Override | |
1286 | // protected IStatus run(final IProgressMonitor monitor) { | |
1287 | // while (!monitor.isCanceled()) | |
1288 | // try { | |
1289 | // Thread.sleep(100); | |
1290 | // } catch (final InterruptedException e) { | |
1291 | // return Status.OK_STATUS; | |
1292 | // } | |
1293 | // monitor.done(); | |
1294 | // return Status.OK_STATUS; | |
1295 | // } | |
1296 | // }; | |
1297 | // job.schedule(); | |
1298 | // | |
1299 | // // fEventLog = openLogFile("TraceEvent.log"); | |
1300 | // // System.out.println(System.currentTimeMillis() + ": Experiment indexing started"); | |
1301 | // | |
1302 | // final ITmfEventRequest<ITmfEvent> request = new TmfEventRequest<ITmfEvent>(ITmfEvent.class, timeRange, index, | |
1303 | // TmfDataRequest.ALL_DATA, | |
1304 | // fIndexPageSize, ITmfDataRequest.ExecutionType.BACKGROUND) { // PATA | |
1305 | // // FOREGROUND | |
1306 | // | |
1307 | // // long indexingStart = System.nanoTime(); | |
1308 | // | |
1309 | // ITmfTimestamp startTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getStartTime(); | |
1310 | // ITmfTimestamp lastTime = (fTimeRange == TmfTimeRange.NULL_RANGE) ? null : fTimeRange.getEndTime(); | |
1311 | // long initialNbEvents = fNbEvents; | |
1312 | // | |
1313 | // @Override | |
1314 | // public void handleStarted() { | |
1315 | // super.handleStarted(); | |
1316 | // } | |
1317 | // | |
1318 | // @Override | |
1319 | // public void handleData(final ITmfEvent event) { | |
1320 | // super.handleData(event); | |
1321 | // if (event != null) { | |
1322 | // final ITmfTimestamp ts = event.getTimestamp(); | |
1323 | // if (startTime == null) | |
1324 | // startTime = ts.clone(); | |
1325 | // lastTime = ts.clone(); | |
1326 | // } | |
1327 | // if ((getNbRead() % fIndexPageSize) == 1 && getNbRead() != 1) | |
1328 | // updateExperiment(); | |
1329 | // } | |
1330 | // | |
1331 | // @Override | |
1332 | // public void handleSuccess() { | |
1333 | // // long indexingEnd = System.nanoTime(); | |
1334 | // | |
1335 | // // if the end time is a real value then it is the streaming safe | |
1336 | // // time stamp | |
1337 | // // set the last time to the safe time stamp to prevent | |
1338 | // // unnecessary indexing requests | |
1339 | // if (getRange().getEndTime() != TmfTimestamp.BIG_CRUNCH) | |
1340 | // lastTime = getRange().getEndTime(); | |
1341 | // updateExperiment(); | |
1342 | // // System.out.println(System.currentTimeMillis() + ": Experiment indexing completed"); | |
1343 | // | |
1344 | // // long average = (indexingEnd - indexingStart) / fNbEvents; | |
1345 | // // System.out.println(getName() + ": start=" + startTime + ", end=" + lastTime + ", elapsed=" | |
1346 | // // + (indexingEnd * 1.0 - indexingStart) / 1000000000); | |
1347 | // // System.out.println(getName() + ": nbEvents=" + fNbEvents + " (" + (average / 1000) + "." | |
1348 | // // + (average % 1000) + " us/evt)"); | |
1349 | // super.handleSuccess(); | |
1350 | // } | |
1351 | // | |
1352 | // @Override | |
1353 | // public void handleCompleted() { | |
1354 | // job.cancel(); | |
1355 | // super.handleCompleted(); | |
1356 | // synchronized (fCheckpoints) { | |
1357 | // fIndexing = false; | |
1358 | // if (fIndexingPendingRange != TmfTimeRange.NULL_RANGE) { | |
1359 | // indexExperiment(false, (int) fNbEvents, fIndexingPendingRange); | |
1360 | // fIndexingPendingRange = TmfTimeRange.NULL_RANGE; | |
1361 | // } | |
1362 | // } | |
1363 | // } | |
1364 | // | |
1365 | // private void updateExperiment() { | |
1366 | // final int nbRead = getNbRead(); | |
1367 | // if (startTime != null) | |
1368 | // fTimeRange = new TmfTimeRange(startTime, lastTime.clone()); | |
1369 | // if (nbRead != 0) { | |
1370 | // // updateTimeRange(); | |
1371 | // // updateNbEvents(); | |
1372 | // fNbEvents = initialNbEvents + nbRead; | |
1373 | // notifyListeners(); | |
1374 | // } | |
1375 | // } | |
1376 | // }; | |
1377 | // | |
1378 | // sendRequest((ITmfDataRequest<T>) request); | |
1379 | // if (waitForCompletion) | |
1380 | // try { | |
1381 | // request.waitForCompletion(); | |
1382 | // } catch (final InterruptedException e) { | |
1383 | // e.printStackTrace(); | |
1384 | // } | |
1385 | // } | |
1386 | // | |
1387 | // protected void notifyListeners() { | |
1388 | // broadcast(new TmfExperimentUpdatedSignal(this, this)); // , null)); | |
1389 | // // broadcast(new TmfExperimentRangeUpdatedSignal(this, this, | |
1390 | // // fTimeRange)); // , null)); | |
1391 | // } | |
1392 | // | |
1393 | // // ------------------------------------------------------------------------ | |
1394 | // // Signal handlers | |
1395 | // // ------------------------------------------------------------------------ | |
1396 | // | |
1397 | // @TmfSignalHandler | |
1398 | // public void experimentSelected(final TmfExperimentSelectedSignal<T> signal) { | |
1399 | // final TmfExperiment<?> experiment = signal.getExperiment(); | |
1400 | // if (experiment == this) { | |
1401 | // setCurrentExperiment(experiment); | |
1402 | // fEndSynchReference = Integer.valueOf(signal.getReference()); | |
1403 | // } | |
1404 | // } | |
1405 | // | |
1406 | // @TmfSignalHandler | |
1407 | // public void endSync(final TmfEndSynchSignal signal) { | |
1408 | // if (fEndSynchReference != null && fEndSynchReference.intValue() == signal.getReference()) { | |
1409 | // fEndSynchReference = null; | |
1410 | // initializeStreamingMonitor(); | |
1411 | // } | |
1412 | // } | |
1413 | // | |
1414 | // @TmfSignalHandler | |
1415 | // public void experimentUpdated(final TmfExperimentUpdatedSignal signal) { | |
1416 | // } | |
1417 | // | |
1418 | // @TmfSignalHandler | |
1419 | // public void experimentRangeUpdated(final TmfExperimentRangeUpdatedSignal signal) { | |
1420 | // if (signal.getExperiment() == this) | |
1421 | // indexExperiment(false, (int) fNbEvents, signal.getRange()); | |
1422 | // } | |
1423 | // | |
1424 | // @TmfSignalHandler | |
1425 | // public void traceUpdated(final TmfTraceUpdatedSignal signal) { | |
1426 | // for (final ITmfTrace<T> trace : fTraces) | |
1427 | // if (trace == signal.getTrace()) { | |
1428 | // synchronized (fCheckpoints) { | |
1429 | // if (fIndexing) { | |
1430 | // if (fIndexingPendingRange == TmfTimeRange.NULL_RANGE) | |
1431 | // fIndexingPendingRange = signal.getRange(); | |
1432 | // else { | |
1433 | // ITmfTimestamp startTime = fIndexingPendingRange.getStartTime(); | |
1434 | // ITmfTimestamp endTime = fIndexingPendingRange.getEndTime(); | |
1435 | // if (signal.getRange().getStartTime().compareTo(startTime) < 0) | |
1436 | // startTime = signal.getRange().getStartTime(); | |
1437 | // if (signal.getRange().getEndTime().compareTo(endTime) > 0) | |
1438 | // endTime = signal.getRange().getEndTime(); | |
1439 | // fIndexingPendingRange = new TmfTimeRange(startTime, endTime); | |
1440 | // } | |
1441 | // return; | |
1442 | // } | |
1443 | // } | |
1444 | // indexExperiment(false, (int) fNbEvents, signal.getRange()); | |
1445 | // return; | |
1446 | // } | |
1447 | // } | |
1448 | // | |
1449 | // @Override | |
1450 | // public String getPath() { | |
1451 | // // TODO Auto-generated method stub | |
1452 | // return null; | |
1453 | // } | |
1454 | // | |
1455 | // /** | |
1456 | // * Set the file to be used for bookmarks on this experiment | |
1457 | // * | |
1458 | // * @param file the bookmarks file | |
1459 | // */ | |
1460 | // public void setBookmarksFile(final IFile file) { | |
1461 | // fBookmarksFile = file; | |
1462 | // } | |
1463 | // | |
1464 | // /** | |
1465 | // * Get the file used for bookmarks on this experiment | |
1466 | // * | |
1467 | // * @return the bookmarks file or null if none is set | |
1468 | // */ | |
1469 | // public IFile getBookmarksFile() { | |
1470 | // return fBookmarksFile; | |
1471 | // } | |
1472 | // | |
1473 | // /* | |
1474 | // * (non-Javadoc) | |
1475 | // * | |
1476 | // * @see org.eclipse.linuxtools.tmf.core.trace.ITmfTrace#getResource() | |
1477 | // */ | |
1478 | // @Override | |
1479 | // public IResource getResource() { | |
1480 | // return fResource; | |
1481 | // } | |
1482 | //} |