Commit | Line | Data |
---|---|---|
6e512b93 | 1 | /******************************************************************************* |
8827c197 | 2 | * Copyright (c) 2009, 2010 Ericsson |
6e512b93 ASL |
3 | * |
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 | |
8 | * | |
9 | * Contributors: | |
10 | * Alvaro Sanchez-Leon (alvsan09@gmail.com) - Initial API and implementation | |
11 | *******************************************************************************/ | |
12 | package org.eclipse.linuxtools.lttng.ui.views.common; | |
13 | ||
8827c197 FC |
14 | import java.util.Arrays; |
15 | ||
16 | import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory; | |
17 | import org.eclipse.linuxtools.lttng.control.LttngSyntheticEventProvider; | |
18 | import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent; | |
19 | import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent.SequenceInd; | |
20 | import org.eclipse.linuxtools.lttng.event.LttngTimestamp; | |
21 | import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest; | |
22 | import org.eclipse.linuxtools.lttng.request.IRequestStatusListener; | |
23 | import org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest; | |
24 | import org.eclipse.linuxtools.lttng.request.RequestCompletedSignal; | |
25 | import org.eclipse.linuxtools.lttng.request.RequestStartedSignal; | |
26 | import org.eclipse.linuxtools.lttng.state.evProcessor.ITransEventProcessor; | |
6e512b93 | 27 | import org.eclipse.linuxtools.lttng.ui.TraceDebug; |
8827c197 | 28 | import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer; |
8827c197 | 29 | import org.eclipse.linuxtools.tmf.event.TmfEvent; |
6e512b93 | 30 | import org.eclipse.linuxtools.tmf.event.TmfTimeRange; |
63eecb47 | 31 | import org.eclipse.linuxtools.tmf.event.TmfTimestamp; |
8827c197 FC |
32 | import org.eclipse.linuxtools.tmf.experiment.TmfExperiment; |
33 | import org.eclipse.linuxtools.tmf.request.TmfDataRequest; | |
34 | import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal; | |
6e512b93 | 35 | import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler; |
8827c197 FC |
36 | import org.eclipse.linuxtools.tmf.signal.TmfSignalManager; |
37 | import org.eclipse.linuxtools.tmf.signal.TmfTimeSynchSignal; | |
38 | import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.ITimeAnalysisViewer; | |
39 | import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeScaleSelectionEvent; | |
40 | import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.TmfTimeSelectionEvent; | |
41 | import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry; | |
6e512b93 | 42 | import org.eclipse.linuxtools.tmf.ui.views.TmfView; |
8827c197 | 43 | import org.eclipse.swt.widgets.Display; |
6e512b93 ASL |
44 | |
45 | /** | |
46 | * <p> | |
47 | * Abstract class used as a base for views handling specific time range data | |
48 | * requests | |
49 | * </p> | |
50 | * <p> | |
8827c197 FC |
51 | * The class handles a single element queue of data requests, i.e. request can |
52 | * be triggered from different sources e.g. opening a file as well as a new | |
53 | * selected time window | |
6e512b93 ASL |
54 | * </p> |
55 | * | |
56 | * @author alvaro | |
57 | * | |
58 | */ | |
59 | public abstract class AbsTimeUpdateView extends TmfView implements | |
8827c197 | 60 | IRequestStatusListener { |
6e512b93 ASL |
61 | |
62 | // ======================================================================== | |
63 | // Data | |
64 | // ======================================================================== | |
8827c197 FC |
65 | /** |
66 | * One second in nanoseconds | |
67 | */ | |
68 | private static final long INITIAL_WINDOW_OFFSET = 1000000000L; /* | |
69 | * 1 sec // | |
70 | * in ns // | |
71 | */ | |
72 | // private static final long INITIAL_WINDOW_OFFSET = 100000000L; /* 100 ms | |
73 | // in ns */ | |
74 | /** | |
75 | * Number of events before a GUI refresh | |
76 | */ | |
77 | private static final Long INPUT_CHANGED_REFRESH = 3000L; | |
78 | private static final long DEFAULT_OFFSET = 0L; | |
79 | private static final int DEFAULT_CHUNK = 1; | |
80 | ||
81 | protected boolean synch = true; // time synchronisation, used to be an | |
82 | // option | |
83 | protected ITimeAnalysisViewer tsfviewer = null; | |
6e512b93 | 84 | |
cb866e08 FC |
85 | private LttngSyntEventRequest fCurrentRequest = null; |
86 | ||
87 | // ======================================================================== | |
6e512b93 ASL |
88 | // Constructor |
89 | // ======================================================================== | |
90 | public AbsTimeUpdateView(String viewID) { | |
8827c197 FC |
91 | super(viewID); |
92 | // freqState = UiCommonFactory.getQueue(this); | |
6e512b93 ASL |
93 | } |
94 | ||
95 | // ======================================================================== | |
96 | // Methods | |
97 | // ======================================================================== | |
98 | /* | |
99 | * (non-Javadoc) | |
100 | * | |
101 | * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener# | |
102 | * processingStarted(org.eclipse.linuxtools.lttng.state.StateDataRequest) | |
103 | */ | |
104 | @TmfSignalHandler | |
105 | public synchronized void processingStarted(RequestStartedSignal signal) { | |
8827c197 | 106 | LttngSyntEventRequest request = signal.getRequest(); |
6e512b93 | 107 | if (request != null) { |
8827c197 FC |
108 | // update queue with the id of the current request. |
109 | // freqState.requestStarted(request); | |
110 | ||
111 | // if there was no new request then this one is still on | |
112 | // prepare for the reception of new data | |
113 | waitCursor(true); | |
114 | ||
115 | // no new time range for zoom orders | |
116 | TmfTimeRange trange = null; | |
117 | // Time Range will be used to filter out events which are | |
118 | // not visible in one pixel | |
119 | trange = request.getRange(); | |
120 | ||
121 | // indicate if the data model needs to be cleared e.g. a new | |
122 | // experiment is being selected | |
123 | boolean clearData = request.isclearDataInd(); | |
124 | // Indicate if current data needs to be cleared and if so | |
125 | // specify the new experiment time range that applies | |
126 | ModelUpdatePrep(trange, clearData); | |
6e512b93 ASL |
127 | } |
128 | } | |
129 | ||
130 | /* | |
131 | * (non-Javadoc) | |
132 | * | |
133 | * @seeorg.eclipse.linuxtools.lttng.state.IStateDataRequestListener# | |
134 | * processingCompleted(org.eclipse.linuxtools.lttng.state.StateDataRequest) | |
135 | */ | |
136 | @TmfSignalHandler | |
8827c197 FC |
137 | public void processingCompleted(RequestCompletedSignal signal) { |
138 | ILttngSyntEventRequest request = signal.getRequest(); | |
6e512b93 ASL |
139 | |
140 | if (request == null) { | |
141 | return; | |
8035003b | 142 | } |
6e512b93 | 143 | |
8827c197 FC |
144 | // Update wait cursor |
145 | waitCursor(false); | |
146 | ||
6e512b93 ASL |
147 | // No data refresh actions for cancelled requests. |
148 | if (request.isCancelled() || request.isFailed()) { | |
149 | if (TraceDebug.isDEBUG()) { | |
150 | TmfTimeRange trange = request.getRange(); | |
151 | if (request.isCancelled()) { | |
152 | TraceDebug.debug("Request cancelled " | |
153 | + trange.getStartTime() + "-" + trange.getEndTime() | |
8827c197 FC |
154 | + " Handled Events: " + request.getSynEventCount() |
155 | + " " + request.toString(), 15); | |
6e512b93 ASL |
156 | } else if (request.isFailed()) { |
157 | TraceDebug.debug("Request Failed " + trange.getStartTime() | |
158 | + "-" + trange.getEndTime() + " Handled Events: " | |
8827c197 FC |
159 | + request.getSynEventCount() + " " |
160 | + request.toString()); | |
6e512b93 ASL |
161 | } |
162 | } | |
163 | ||
164 | return; | |
165 | } else { | |
8827c197 | 166 | modelInputChanged(request, true); |
6e512b93 ASL |
167 | } |
168 | } | |
169 | ||
170 | /** | |
8827c197 | 171 | * Registers as listener of time selection from other views |
6e512b93 | 172 | * |
8827c197 | 173 | * @param signal |
6e512b93 | 174 | */ |
8827c197 FC |
175 | public void synchToTime(TmfTimeSynchSignal signal) { |
176 | if (synch) { | |
177 | Object source = signal.getSource(); | |
178 | if (signal != null && source != null && source != this) { | |
179 | // Internal value is expected in nano seconds. | |
180 | long selectedTime = signal.getCurrentTime().getValue(); | |
181 | if (tsfviewer != null) { | |
182 | tsfviewer.setSelectedTime(selectedTime, true, source); | |
41dc35d0 | 183 | } |
8827c197 FC |
184 | } |
185 | } | |
186 | } | |
187 | ||
188 | /** | |
189 | * Process the reception of time window adjustment in this view if the | |
190 | * source of the update is not this view. | |
191 | * | |
192 | * @param signal | |
193 | * @param clearingData | |
194 | */ | |
195 | public void synchToTimeRange(TmfRangeSynchSignal signal, boolean clearingData) { | |
196 | if (synch) { | |
197 | Object source = signal.getSource(); | |
198 | if (signal != null && source != null && source != this) { | |
199 | // Internal value is expected in nano seconds. | |
200 | TmfTimeRange trange = signal.getCurrentRange(); | |
201 | TmfExperiment<?> experiment = TmfExperiment.getCurrentExperiment(); | |
202 | if (experiment == null) { | |
203 | TraceDebug.debug("Current selected experiment is null"); | |
204 | return; | |
63eecb47 | 205 | } |
6e512b93 | 206 | |
8827c197 FC |
207 | // Clearing of process data is configurable |
208 | dataRequest(trange, experiment.getTimeRange(), clearingData); | |
41dc35d0 | 209 | } |
6e512b93 ASL |
210 | } |
211 | } | |
212 | ||
213 | /** | |
8827c197 FC |
214 | * Trigger time synchronisation to other views this method shall be called |
215 | * when a check has been performed to note that an actual change of time has | |
216 | * been performed vs a pure re-selection of the same time | |
217 | * | |
218 | * @param time | |
219 | * @param source | |
6e512b93 | 220 | */ |
8827c197 FC |
221 | protected void synchTimeNotification(long time, Object source) { |
222 | // if synchronisation selected | |
223 | if (synch) { | |
224 | // Notify other views | |
225 | TmfSignalManager.dispatchSignal(new TmfTimeSynchSignal(source, new LttngTimestamp(time))); | |
226 | } | |
227 | } | |
228 | ||
229 | /** | |
230 | * Common implementation of ITmfTimeSelectionListener, not used by all the | |
231 | * views extending this abstract class | |
232 | * | |
233 | * @param event | |
234 | */ | |
235 | protected void tsfTmProcessSelEvent(TmfTimeSelectionEvent event) { | |
236 | Object source = event.getSource(); | |
237 | if (source == null) { | |
238 | return; | |
239 | } | |
240 | ||
241 | ParamsUpdater paramUpdater = getParamsUpdater(); | |
242 | Long savedSelTime = paramUpdater.getSelectedTime(); | |
243 | ||
244 | long selTimens = event.getSelectedTime(); | |
245 | ||
246 | // make sure the new selected time is different than saved before | |
247 | // executing update | |
248 | if (savedSelTime == null || savedSelTime != selTimens) { | |
249 | // Notify listener views. | |
250 | synchTimeNotification(selTimens, source); | |
251 | ||
252 | // Update the parameter updater to save the selected time | |
253 | paramUpdater.setSelectedTime(selTimens); | |
254 | ||
63eecb47 | 255 | if (TraceDebug.isDEBUG()) { |
8827c197 | 256 | TraceDebug.debug("Selected Time: " + new LttngTimestamp(selTimens) + "\n\t\t" + getName()); |
63eecb47 | 257 | } |
8827c197 FC |
258 | } |
259 | } | |
63eecb47 | 260 | |
8827c197 FC |
261 | /** |
262 | * Common implementation of ITmfTimeScaleSelectionListener, not used by all | |
263 | * the views extending this abstract class | |
264 | * | |
265 | * @param event | |
266 | */ | |
267 | protected synchronized void tsfTmProcessTimeScaleEvent(TmfTimeScaleSelectionEvent event) { | |
268 | // source needed to keep track of source values | |
269 | Object source = event.getSource(); | |
270 | ||
271 | if (source != null) { | |
272 | // Update the parameter updater before carrying out a read request | |
273 | ParamsUpdater paramUpdater = getParamsUpdater(); | |
274 | boolean newParams = paramUpdater.processTimeScaleEvent(event); | |
275 | ||
276 | if (newParams) { | |
277 | // Read the updated time window | |
278 | TmfTimeRange trange = paramUpdater.getTrange(); | |
279 | if (trange != null) { | |
280 | ||
281 | // Notify listener views. to perform data requests | |
282 | // upon this notification | |
283 | synchTimeRangeNotification(trange, paramUpdater.getSelectedTime(), source); | |
284 | } | |
285 | } | |
286 | } | |
287 | } | |
288 | ||
289 | /** | |
290 | * Inform registered listeners about the new time range | |
291 | * | |
292 | * @param trange | |
293 | * @param selectedTime | |
294 | * @param source | |
295 | */ | |
296 | protected void synchTimeRangeNotification(TmfTimeRange trange, Long selectedTime, Object source) { | |
297 | // if synchronisation selected | |
298 | if (synch) { | |
299 | // Notify other views | |
300 | TmfSignalManager.dispatchSignal(new TmfRangeSynchSignal(source, trange, new LttngTimestamp(selectedTime))); | |
301 | } | |
302 | } | |
303 | ||
304 | /** | |
305 | * @param zoomedTRange | |
306 | * @param experimentTRange | |
307 | */ | |
308 | public void dataRequest(TmfTimeRange zoomedTRange, | |
309 | TmfTimeRange experimentTRange, boolean clearingData) { | |
310 | ||
311 | // timeRange is the Experiment time range | |
312 | boolean sent = processDataRequest(zoomedTRange, experimentTRange, clearingData); | |
313 | ||
314 | if (sent) { | |
315 | waitCursor(true); | |
316 | } | |
317 | } | |
318 | ||
319 | /** | |
320 | * send data request directly e.g. doesn't use a queue | |
321 | * | |
322 | * @param requestTrange | |
323 | * @param listener | |
324 | * @param experimentTRange | |
325 | * @param processor | |
326 | * @return | |
327 | */ | |
328 | private boolean processDataRequest(TmfTimeRange requestTrange, | |
329 | TmfTimeRange experimentTRange, boolean clearingData) { | |
330 | // Validate input | |
331 | if (requestTrange == null || experimentTRange == null) { | |
332 | TraceDebug.debug("Invalid input"); | |
333 | return false; | |
334 | } | |
335 | ||
cb866e08 FC |
336 | // Cancel the currently executing request before starting a new one |
337 | if (fCurrentRequest != null && !fCurrentRequest.isCompleted()) { | |
338 | System.out.println("Cancelling request"); | |
339 | // fCurrentRequest.cancel(); | |
340 | } | |
341 | ||
342 | fCurrentRequest = new LttngSyntEventRequest( | |
8827c197 FC |
343 | requestTrange, DEFAULT_OFFSET, TmfDataRequest.ALL_DATA, |
344 | DEFAULT_CHUNK, this, experimentTRange, getEventProcessor()) { | |
345 | ||
346 | Long fCount = getSynEventCount(); | |
347 | ITransEventProcessor processor = getProcessor(); | |
348 | TmfTimestamp frunningTimeStamp; | |
349 | ||
350 | /* | |
351 | * (non-Javadoc) | |
352 | * | |
353 | * @see | |
354 | * org.eclipse.linuxtools.lttng.request.LttngSyntEventRequest#handleData | |
355 | * () | |
356 | */ | |
cb866e08 FC |
357 | // int handleDataCount = 0; |
358 | // int handleDataValidCount = 0; | |
550d787e | 359 | @Override |
8827c197 | 360 | public void handleData() { |
cb866e08 | 361 | LttngSyntheticEvent[] result = getData(); |
8827c197 FC |
362 | |
363 | TmfEvent evt = (result.length > 0) ? result[0] : null; | |
cb866e08 | 364 | // handleDataCount++; |
8827c197 | 365 | if (evt != null) { |
cb866e08 | 366 | // handleDataValidCount++; |
8827c197 FC |
367 | LttngSyntheticEvent synEvent = (LttngSyntheticEvent) evt; |
368 | // process event | |
369 | SequenceInd indicator = synEvent.getSynType(); | |
370 | if (indicator == SequenceInd.BEFORE | |
371 | || indicator == SequenceInd.AFTER) { | |
372 | processor.process(evt, synEvent.getTraceModel()); | |
373 | } else if (indicator == SequenceInd.STARTREQ) { | |
374 | handleRequestStarted(); | |
375 | } else if (indicator == SequenceInd.ENDREQ) { | |
376 | processor.process(evt, synEvent.getTraceModel()); | |
377 | // handleCompleted(); | |
378 | } | |
379 | ||
380 | if (indicator == SequenceInd.BEFORE) { | |
381 | fCount++; | |
382 | if (fCount != 0 && fCount % INPUT_CHANGED_REFRESH == 0) { | |
383 | // send partial update | |
384 | modelInputChanged(this, false); | |
385 | ||
386 | if (TraceDebug.isDEBUG()) { | |
387 | frunningTimeStamp = evt.getTimestamp(); | |
388 | TraceDebug.debug("handled: " + fCount + " sequence: " + synEvent.getSynType()); | |
389 | } | |
390 | ||
391 | } | |
392 | } | |
393 | } | |
394 | } | |
395 | ||
396 | public void handleRequestStarted() { | |
397 | notifyStarting(); | |
398 | } | |
550d787e FC |
399 | |
400 | @Override | |
401 | public void done() { | |
cb866e08 FC |
402 | // if (TraceDebug.isDEBUG()) { |
403 | // TraceDebug.debug("AbsTimeUpdateView: Received=" + handleDataCount + ", Valid=" + handleDataCount + ", fCount=" + fCount); | |
404 | // } | |
550d787e FC |
405 | super.done(); |
406 | } | |
8827c197 | 407 | |
550d787e | 408 | @Override |
8827c197 FC |
409 | public void handleCompleted() { |
410 | super.handleCompleted(); | |
411 | ||
412 | // Data is not complete and should be handled as such | |
413 | if (isFailed() || isCancelled()) { | |
414 | modelIncomplete(this); | |
415 | } | |
416 | ||
417 | if (TraceDebug.isDEBUG()) { | |
418 | if (frunningTimeStamp != null) { | |
419 | TraceDebug.debug("Last event time stamp: " | |
420 | + frunningTimeStamp.getValue()); | |
421 | } | |
422 | } | |
423 | } | |
424 | }; | |
425 | ||
426 | // obtain singleton core provider | |
427 | LttngSyntheticEventProvider provider = LttngCoreProviderFactory | |
428 | .getEventProvider(); | |
429 | ||
430 | // send the request to TMF | |
cb866e08 FC |
431 | fCurrentRequest.startRequestInd(provider); |
432 | fCurrentRequest.setclearDataInd(clearingData); | |
8827c197 FC |
433 | return true; |
434 | } | |
435 | ||
436 | /** | |
437 | * Returns an initial smaller window to allow the user to select the area of | |
438 | * interest | |
439 | * | |
440 | * @param experimentTRange | |
441 | * @return | |
442 | */ | |
443 | protected TmfTimeRange getInitTRange(TmfTimeRange experimentTRange) { | |
444 | TmfTimestamp expStartTime = experimentTRange.getStartTime(); | |
445 | TmfTimestamp expEndTime = experimentTRange.getEndTime(); | |
446 | TmfTimestamp initialEndOfWindow = new LttngTimestamp(expStartTime | |
447 | .getValue() | |
448 | + INITIAL_WINDOW_OFFSET); | |
449 | if (initialEndOfWindow.compareTo(expEndTime, false) < 0) { | |
450 | return new TmfTimeRange(expStartTime, initialEndOfWindow); | |
6e512b93 | 451 | } |
8827c197 FC |
452 | |
453 | // The original size of the experiment is smaller than proposed adjusted | |
454 | // time | |
455 | return experimentTRange; | |
6e512b93 ASL |
456 | } |
457 | ||
458 | /** | |
459 | * Request the Time Analysis widget to enable or disable the wait cursor | |
460 | * e.g. data request in progress or data request completed | |
461 | * | |
462 | * @param waitInd | |
463 | */ | |
8827c197 FC |
464 | protected void waitCursor(final boolean waitInd) { |
465 | if (tsfviewer != null) { | |
466 | Display display = tsfviewer.getControl().getDisplay(); | |
467 | ||
468 | // Perform the updates on the UI thread | |
469 | display.asyncExec(new Runnable() { | |
470 | public void run() { | |
471 | tsfviewer.waitCursor(waitInd); | |
472 | } | |
473 | }); | |
474 | } | |
475 | } | |
6e512b93 ASL |
476 | |
477 | /** | |
8827c197 | 478 | * View preparation to override the current local information |
6e512b93 | 479 | * |
d712a5f3 FC |
480 | * @param timeRange |
481 | * - new total time range e.g. Experiment level | |
8827c197 FC |
482 | * @param clearAllData |
483 | */ | |
484 | protected void ModelUpdatePrep(TmfTimeRange timeRange, boolean clearAllData) { | |
485 | ItemContainer<?> itemContainer = getItemContainer(); | |
486 | if (clearAllData) { | |
487 | // start fresh e.g. new experiment selected | |
488 | itemContainer.clearItems(); | |
489 | } else { | |
490 | // clear children but keep processes | |
491 | itemContainer.clearChildren(); | |
492 | } | |
493 | ||
494 | // Obtain the current resource array | |
495 | ITmfTimeAnalysisEntry[] itemArr = itemContainer.readItems(); | |
496 | ||
497 | // clean up data and boundaries | |
498 | displayModel(itemArr, -1, -1, false, -1, -1, null); | |
499 | ||
500 | ParamsUpdater updater = getParamsUpdater(); | |
501 | if (updater != null) { | |
502 | // Start over | |
503 | updater.setEventsDiscarded(0); | |
504 | ||
505 | // Update new visible time range if available | |
506 | if (timeRange != null) { | |
507 | updater.update(timeRange.getStartTime().getValue(), timeRange.getEndTime().getValue()); | |
508 | } | |
509 | } | |
510 | } | |
511 | ||
512 | /** | |
513 | * Initialize the model and view before reloading items | |
514 | * | |
515 | * @param boundaryRange | |
516 | * @param visibleRange | |
517 | * @param source | |
6e512b93 | 518 | */ |
8827c197 FC |
519 | protected void ModelUpdateInit(TmfTimeRange boundaryRange, TmfTimeRange visibleRange, Object source) { |
520 | // Update the view boundaries | |
521 | if (boundaryRange != null) { | |
522 | ItemContainer<?> itemContainer = getItemContainer(); | |
523 | if (itemContainer != null) { | |
524 | itemContainer.clearItems(); | |
525 | // Obtain the current process array | |
526 | ITmfTimeAnalysisEntry[] itemArr = itemContainer.readItems(); | |
527 | ||
528 | long startTime = boundaryRange.getStartTime().getValue(); | |
529 | long endTime = boundaryRange.getEndTime().getValue(); | |
530 | ||
531 | // Update the view part | |
532 | displayModel(itemArr, startTime, endTime, true, visibleRange.getStartTime().getValue(), visibleRange | |
533 | .getEndTime().getValue(), source); | |
534 | } | |
535 | } | |
536 | ||
537 | // update the view filtering parameters | |
538 | if (visibleRange != null) { | |
539 | ParamsUpdater updater = getParamsUpdater(); | |
540 | if (updater != null) { | |
541 | // Start over | |
542 | updater.setEventsDiscarded(0); | |
543 | // Update new visible time range if available | |
544 | updater.update(visibleRange.getStartTime().getValue(), visibleRange.getEndTime().getValue()); | |
545 | } | |
546 | } | |
547 | } | |
6e512b93 ASL |
548 | |
549 | /** | |
550 | * Actions taken by the view to refresh its widget(s) with the updated data | |
551 | * model | |
552 | * | |
553 | * @param request | |
8827c197 FC |
554 | * @param complete |
555 | * true: yes, false: partial update | |
556 | */ | |
557 | protected void modelInputChanged(ILttngSyntEventRequest request, boolean complete) { | |
558 | long experimentStartTime = -1; | |
559 | long experimentEndTime = -1; | |
560 | TmfTimeRange experimentTimeRange = request.getExperimentTimeRange(); | |
561 | if (experimentTimeRange != null) { | |
562 | experimentStartTime = experimentTimeRange.getStartTime().getValue(); | |
563 | experimentEndTime = experimentTimeRange.getEndTime().getValue(); | |
564 | } | |
565 | ||
566 | // Obtain the current resource list | |
567 | ITmfTimeAnalysisEntry[] itemArr = getItemContainer().readItems(); | |
568 | ||
569 | if (itemArr != null) { | |
570 | // Sort the array by pid | |
571 | Arrays.sort(itemArr); | |
572 | ||
573 | // Update the view part | |
574 | displayModel(itemArr, experimentStartTime, experimentEndTime, false, request.getRange().getStartTime() | |
575 | .getValue(), request.getRange().getEndTime().getValue(), request.getSource()); | |
576 | } | |
577 | ||
578 | if (complete) { | |
579 | // reselect to original time | |
5dbe4d3b | 580 | ParamsUpdater paramUpdater = getParamsUpdater(); |
8827c197 FC |
581 | if (paramUpdater != null && tsfviewer != null) { |
582 | final Long selTime = paramUpdater.getSelectedTime(); | |
583 | if (selTime != null) { | |
584 | TraceDebug.debug("View: " + getName() + "\n\t\tRestoring the selected time to: " + selTime); | |
585 | Display display = tsfviewer.getControl().getDisplay(); | |
586 | display.asyncExec(new Runnable() { | |
587 | public void run() { | |
588 | tsfviewer.setSelectedTime(selTime, false, this); | |
589 | } | |
590 | }); | |
591 | } | |
592 | ||
593 | if (TraceDebug.isDEBUG()) { | |
594 | int eventCount = 0; | |
595 | Long count = request.getSynEventCount(); | |
596 | for (int pos = 0; pos < itemArr.length; pos++) { | |
597 | eventCount += itemArr[pos].getTraceEvents().size(); | |
598 | } | |
599 | ||
5dbe4d3b | 600 | int discarded = paramUpdater.getEventsDiscarded(); |
8827c197 | 601 | int discardedOutofOrder = paramUpdater.getEventsDiscardedWrongOrder(); |
5dbe4d3b ASL |
602 | int discardedOutofViewRange = paramUpdater.getEventsDiscardedOutOfViewRange(); |
603 | int dicardedNotVisible = paramUpdater.getEventsDiscardedNotVisible(); | |
604 | ||
8827c197 FC |
605 | TmfTimeRange range = request.getRange(); |
606 | StringBuilder sb = new StringBuilder("View: " + getName() + ", Events handled: " + count | |
607 | + ", Events loaded in view: " + eventCount + ", Number of events discarded: " + discarded | |
608 | + "\n\tNumber of events discarded with start time earlier than next good time: " | |
5dbe4d3b ASL |
609 | + discardedOutofOrder + "\n\tDiscarded Not visible: " + dicardedNotVisible |
610 | + "\n\tDiscarded out of view Range: " + discardedOutofViewRange); | |
8827c197 FC |
611 | |
612 | sb.append("\n\t\tRequested Time Range: " + range.getStartTime() + "-" + range.getEndTime()); | |
613 | sb.append("\n\t\tExperiment Time Range: " + experimentStartTime + "-" + experimentEndTime); | |
614 | TraceDebug.debug(sb.toString()); | |
615 | } | |
616 | } | |
617 | ||
618 | } | |
619 | } | |
620 | ||
621 | // /** | |
622 | // * Obtains the remainder fraction on unit Seconds of the entered value in | |
623 | // * nanoseconds. e.g. input: 1241207054171080214 ns The number of seconds | |
624 | // can | |
625 | // * be obtain by removing the last 9 digits: 1241207054 the fractional | |
626 | // * portion of seconds, expressed in ns is: 171080214 | |
627 | // * | |
628 | // * @param v | |
629 | // * @return | |
630 | // */ | |
631 | // protected String formatNs(long v) { | |
632 | // StringBuffer str = new StringBuffer(); | |
633 | // boolean neg = v < 0; | |
634 | // if (neg) { | |
635 | // v = -v; | |
636 | // str.append('-'); | |
637 | // } | |
638 | // | |
639 | // String strVal = String.valueOf(v); | |
640 | // if (v < 1000000000) { | |
641 | // return strVal; | |
642 | // } | |
643 | // | |
644 | // // Extract the last nine digits (e.g. fraction of a S expressed in ns | |
645 | // return strVal.substring(strVal.length() - 9); | |
646 | // } | |
647 | ||
648 | /** | |
649 | * The request was stopped, the data is incomplete | |
650 | * | |
651 | * @param request | |
652 | */ | |
653 | protected abstract void modelIncomplete(ILttngSyntEventRequest request); | |
654 | ||
655 | /** | |
656 | * Returns the Event processor instance related to a specific view | |
657 | * | |
658 | * @return | |
659 | */ | |
660 | protected abstract ITransEventProcessor getEventProcessor(); | |
661 | ||
662 | /** | |
663 | * To be overridden by some sub-classes although may not be needed in some | |
664 | * e.g. statistics view | |
665 | * | |
666 | * @param items | |
667 | * @param startBoundTime | |
668 | * @param endBoundTime | |
669 | * @param updateTimeBounds | |
670 | * - Time bounds updated needed e.g. if a new Experiment or trace | |
671 | * is selected | |
672 | * @param startVisibleWindow | |
673 | * @param endVisibleWindow | |
674 | * @param source | |
675 | */ | |
676 | protected abstract void displayModel(final ITmfTimeAnalysisEntry[] items, final long startBoundTime, | |
677 | final long endBoundTime, final boolean updateTimeBounds, final long startVisibleWindow, | |
678 | final long endVisibleWindow, final Object source); | |
679 | ||
680 | /** | |
681 | * To be overridden by some sub-classes although may not be needed in some | |
682 | * e.g. statistics view | |
683 | * | |
684 | * @return | |
685 | */ | |
686 | protected abstract ParamsUpdater getParamsUpdater(); | |
687 | ||
688 | /** | |
689 | * Returns the model's item container | |
690 | * | |
691 | * @return | |
6e512b93 | 692 | */ |
8827c197 | 693 | protected abstract ItemContainer<?> getItemContainer(); |
6e512b93 | 694 | } |