org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/histogram/HistogramRequest.java

   1 package org.eclipse.linuxtools.lttng.ui.views.histogram;
   2
   3 import org.eclipse.linuxtools.lttng.event.LttngEvent;
   4 import org.eclipse.linuxtools.tmf.event.TmfEvent;
   5 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
   6 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
   7
   8 public class HistogramRequest extends TmfEventRequest<LttngEvent> {
   9
  10         final static int MAX_EVENTS_PER_REQUEST = 1;
  11         final static int REDRAW_EVERY_NB_EVENTS = 10000;
  12
  13         private HistogramContent histogramContent = null;
  14
  15         private int lastPos = 0;
  16         private long lastRangeTime = 0L;
  17         private long nbEventsInRange = 1;
  18
  19         private int  nbPosNotEmpty = 1;
  20         private int  nbEventRead = 0;
  21
  22         private TraceCanvas parentCanvas = null;
  23
  24         private boolean requestCompleted = false;
  25
  26         @SuppressWarnings("unchecked")
  27         public HistogramRequest(Class<? extends TmfEvent> dataType, TmfTimeRange range, int nbRequested, HistogramContent newContent, TraceCanvas newParentCanvas, Long timeInterval) {
  28         super((Class<LttngEvent>)dataType, range, nbRequested, MAX_EVENTS_PER_REQUEST);
  29
  30         // *** FIXME ***
  31         // This does not work! The request won't be processed or the number of events returned is wrong!
  32         // We cannot use this !
  33                 //super((Class<LttngEvent>)dataType, range);
  34
  35         histogramContent = newContent;
  36         parentCanvas = newParentCanvas;
  37
  38         histogramContent.resetContentData();
  39         histogramContent.setStartTime(range.getStartTime().getValue());
  40         histogramContent.setEndTime(range.getEndTime().getValue());
  41         histogramContent.setIntervalTime(timeInterval);
  42         histogramContent.resetTable();
  43
  44         lastRangeTime = histogramContent.getStartTime();
  45     }
  46
  47         @Override
  48     public void handleData() {
  49         TmfEvent[] result = getData();
  50         TmfEvent[] evt = new TmfEvent[1];
  51
  52         evt[0] = (result.length > 0) ? result[0] : null;
  53
  54         // *** FIXME ***
  55         // *** EVIL BUG ***
  56         // The request by timerange only does not work! (see constructor above)
  57         //      However, the request with number of events will loop until it reach its number or EOF
  58         //  We have to filter out ourself the extra useless events!
  59         //
  60         if ( (evt[0] != null) && (requestCompleted == false) ) {
  61                 LttngEvent tmpEvent = (LttngEvent)evt[0];
  62
  63                 // This check is linked to the evil fix mentionned above
  64                 if ( tmpEvent.getTimestamp().getValue() <= histogramContent.getEndTime() ) {
  65
  66                         long distance = ( tmpEvent.getTimestamp().getValue() - lastRangeTime );
  67
  68                                 if  ( distance > histogramContent.getIntervalTime() ) {
  69
  70                                         histogramContent.getElementByIndex(lastPos).intervalNbEvents = nbEventsInRange;
  71                                         lastRangeTime = tmpEvent.getTimestamp().getValue();
  72
  73                                         lastPos = (int)((lastRangeTime - histogramContent.getStartTime()) / histogramContent.getIntervalTime() );
  74
  75                                         // *** HACK ***
  76                                         // Because of the threads, weird phenomenons seem to happen here, like a position after the
  77                                         //       element range because another request was issued.
  78                                         // This enforce the position but may result in slightly inconsistent result (i.e. a weird misplaced bar sometime).
  79                                         if ( lastPos < 0 ) {
  80                                                 lastPos = 0;
  81                                         }
  82                                         else if ( lastPos >= histogramContent.getNbElement() ) {
  83                                                 lastPos = (histogramContent.getNbElement()-1);
  84                                         }
  85
  86                                         histogramContent.getElementByIndex(lastPos).firstIntervalTimestamp = lastRangeTime;
  87                                         histogramContent.setReadyUpToPosition(lastPos);
  88
  89                                         nbPosNotEmpty++;
  90                                         nbEventsInRange = 1;
  91                                 }
  92                                 else {
  93                                         nbEventsInRange++;
  94                                         if ( nbEventsInRange > histogramContent.getHeighestEventCount() ) {
  95                                                 histogramContent.setHeighestEventCount(nbEventsInRange);
  96                                         }
  97                                 }
  98
  99                                 nbEventRead++;
 100
 101                                 if ( nbEventRead % REDRAW_EVERY_NB_EVENTS == 0 ) {
 102                                         redrawAsyncronously();
 103                                 }
 104                 }
 105                 else {
 106                         // *** FIXME ***
 107                 // *** EVIL FIX ***
 108                 // Because of the other evil bug (see above), we have to ignore extra useless events we will get
 109                         // However, we might be far away from the end so we better start a redraw now
 110                         redrawAsyncronously();
 111                         requestCompleted = true;
 112
 113                         // Althought it won't do anything, try to call control functions to stop the request
 114                         done();
 115                         cancel();
 116                         fail();
 117                 }
 118                 }
 119     }
 120
 121     @Override
 122     public void handleCompleted() {
 123                 redrawAsyncronously();
 124     }
 125
 126     @Override
 127     public void handleSuccess() {
 128         // Nothing different from completed.
 129     }
 130
 131     @Override
 132     public void handleFailure() {
 133         // Nothing different from cancel.
 134     }
 135
 136     @Override
 137     public void handleCancel() {
 138         redrawAsyncronously();
 139                 requestCompleted = true;
 140     }
 141
 142
 143     public void updateEventsInfo() {
 144         int averageNumberOfEvents = nbEventRead / nbPosNotEmpty;
 145                 histogramContent.setAverageNumberOfEvents(averageNumberOfEvents);
 146                 histogramContent.recalculateEventHeight();
 147     }
 148
 149     public void redrawAsyncronously() {
 150         updateEventsInfo();
 151         // canvas redraw is already asynchronous
 152         parentCanvas.redrawAsynchronously();
 153     }
 154
 155 }