1 /*******************************************************************************
2 * Copyright (c) 2009 Ericsson
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
10 * William Bourque - Initial API and implementation
11 *******************************************************************************/
12 package org
.eclipse
.linuxtools
.lttng
.ui
.views
.histogram
;
14 import org
.eclipse
.linuxtools
.lttng
.event
.LttngEvent
;
15 import org
.eclipse
.linuxtools
.tmf
.event
.TmfEvent
;
16 import org
.eclipse
.linuxtools
.tmf
.event
.TmfTimeRange
;
17 import org
.eclipse
.linuxtools
.tmf
.request
.TmfEventRequest
;
20 * <b><u>HistogramRequest</u></b>
22 * Request class, to perform a request to TMF for the histograms.
25 public class HistogramRequest
extends TmfEventRequest
<LttngEvent
> {
26 private HistogramContent histogramContent
= null;
28 private int lastInterval
= 0;
29 private long lastRangeTime
= 0L;
30 private long nbEventsInInterval
= 1;
32 private int nbIntervalNotEmpty
= 1;
33 private int nbEventRead
= 0;
35 private HistogramCanvas parentCanvas
= null;
37 private boolean requestCompleted
= false;
40 * Constructor for HistogramRequest.<p>
41 * Prepare the request in TMF and reset the histogram content.
43 * @param range Range of the request.
44 * @param nbRequested Nb events requested. Can be "Infinity" for all.
45 * @param newParentCanvas HistogramCanvas related to the request.
46 * @param timeInterval Time interval to consider (i.e. : 1 interval is 1 bar in the histogram)
48 * @see org.eclipse.linuxtools.tmf.request.TmfEventRequest
50 public HistogramRequest(TmfTimeRange range
, int nbRequested
, HistogramCanvas newParentCanvas
, Long timeInterval
) {
51 super((Class
<LttngEvent
>)LttngEvent
.class, range
, nbRequested
, HistogramConstant
.MAX_EVENTS_PER_READ
);
54 // This does not work! The request won't be processed or the number of events returned is wrong!
55 // We cannot use this !
56 //super((Class<LttngEvent>)dataType, range);
58 parentCanvas
= newParentCanvas
;
59 histogramContent
= parentCanvas
.getHistogramContent();
61 // Reset the content of the HistogramContent... the given data better be valid or this will fail.
62 histogramContent
.resetContentData();
63 histogramContent
.setStartTime(range
.getStartTime().getValue());
64 histogramContent
.setEndTime(range
.getEndTime().getValue());
65 histogramContent
.setIntervalTime(timeInterval
);
66 histogramContent
.resetTable();
68 lastRangeTime
= histogramContent
.getStartTime();
72 * HandleData function : will be called by TMF each time a new event is receive for the request.<p>
73 * Calculation for the content is done here.
76 public void handleData() {
77 TmfEvent
[] result
= getData();
78 TmfEvent
[] evt
= new TmfEvent
[1];
80 evt
[0] = (result
.length
> 0) ? result
[0] : null;
84 // The request by timerange only does not work! (see constructor above)
85 // However, the request with number of events will loop until it reach its number or EOF
86 // We have to filter out ourself the extra useless events!
88 if ( (evt
[0] != null) && (requestCompleted
== false) ) {
89 LttngEvent tmpEvent
= (LttngEvent
)evt
[0];
91 // This check is linked to the evil fix mentionned above
92 if ( tmpEvent
.getTimestamp().getValue() <= histogramContent
.getEndTime() ) {
94 // Distance (in time) between this event and the last one we read
95 long distance
= ( tmpEvent
.getTimestamp().getValue() - lastRangeTime
);
97 // Check if we changed of interval (the distance is higher than the interval time)
98 if ( distance
> histogramContent
.getIntervalTime() ) {
100 histogramContent
.getElementByIndex(lastInterval
).intervalNbEvents
= nbEventsInInterval
;
101 lastRangeTime
= tmpEvent
.getTimestamp().getValue();
104 // We can skip several interval at once, so we need to find what was our interval now
105 lastInterval
= (int)((lastRangeTime
- histogramContent
.getStartTime()) / histogramContent
.getIntervalTime() );
108 // Because of the threads, weird phenomenons seem to happen here, like a position after the
109 // element range because another request was issued.
110 // This enforce the position but may result in slightly inconsistent result (i.e. a weird misplaced bar sometime).
111 if ( lastInterval
< 0 ) {
114 else if ( lastInterval
>= histogramContent
.getNbElement() ) {
115 lastInterval
= (histogramContent
.getNbElement()-1);
119 // We save the time we have. This mean only the FIRST time read in an interval will be saved.
120 histogramContent
.getElementByIndex(lastInterval
).firstIntervalTimestamp
= lastRangeTime
;
121 histogramContent
.setReadyUpToPosition(lastInterval
);
123 nbIntervalNotEmpty
++;
124 nbEventsInInterval
= 1;
126 // We are still in the same interval, just keep counting
128 nbEventsInInterval
++;
129 if ( nbEventsInInterval
> histogramContent
.getHeighestEventCount() ) {
130 histogramContent
.setHeighestEventCount(nbEventsInInterval
);
136 // Call an asynchronous redraw every REDRAW_EVERY_NB_EVENTS events
137 // That way we don't need to wait until to end to have something on the screen
138 if ( nbEventRead
% HistogramConstant
.REDRAW_EVERY_NB_EVENTS
== 0 ) {
139 redrawAsyncronously();
145 // Because of the other evil bug (see above), we have to ignore extra useless events we will get
146 // However, we might be far away from the end so we better start a redraw now
147 redrawAsyncronously();
148 requestCompleted
= true;
150 // Althought it won't do anything, try to call control functions to stop the request
159 * Function that is called when the request completed (successful or not).<p>
160 * Update information and redraw the screen.
163 public void handleCompleted() {
164 parentCanvas
.canvasRedrawer
.asynchronousNotifyParentUpdatedInformation();
165 redrawAsyncronously();
169 * Function that is called when the request completed successfully.<p>
172 public void handleSuccess() {
173 // Nothing different from completed.
177 * Function that is called when the request completed in failure.<p>
180 public void handleFailure() {
181 // Nothing different from cancel.
185 * Function that is called when the request was cancelled.<p>
186 * Redraw and set the requestCompleted flag to true;
189 public void handleCancel() {
190 redrawAsyncronously();
191 requestCompleted
= true;
195 * Update the HistogramContent with the latest information.<p>
196 * This will perform some calculation that might be a bit harsh so it shouldnt be called too often.
198 public void updateEventsInfo() {
199 int averageNumberOfEvents
= nbEventRead
/ nbIntervalNotEmpty
;
200 histogramContent
.setAverageNumberOfEvents(averageNumberOfEvents
);
201 histogramContent
.recalculateEventHeight();
205 * Perform an asynchonous redraw of the screen.
207 public void redrawAsyncronously() {
209 // Canvas redraw is already asynchronous
210 parentCanvas
.redrawAsynchronously();