org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010 Ericsson
   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  *   Francois Chouinard - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.component;
  14
  15 import org.eclipse.linuxtools.tmf.Tracer;
  16 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  17 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  18 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
  19 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType;
  20 import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
  21 import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
  22 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
  23
  24 /**
  25  * <b><u>TmfEventProvider</u></b>
  26  * <p>
  27  * Implement me. Please.
  28  */
  29 public abstract class TmfEventProvider<T extends TmfEvent> extends TmfDataProvider<T> {
  30
  31         public TmfEventProvider(String name, Class<T> type) {
  32                 super(name, type);
  33         }
  34
  35         public TmfEventProvider(String name, Class<T> type, int queueSize) {
  36                 super(name, type, queueSize);
  37         }
  38
  39         public TmfEventProvider(TmfEventProvider<T> oldProvider) {
  40                 super(oldProvider);
  41         }
  42
  43         @Override
  44         public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
  45                 boolean requestCompleted = super.isCompleted(request, data, nbRead);
  46                 if (!requestCompleted && request instanceof ITmfEventRequest<?> && !data.isNullRef()) {
  47                         TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();
  48                         return data.getTimestamp().compareTo(endTime, false) > 0;
  49                 }
  50                 return requestCompleted;
  51         }
  52
  53         @Override
  54         protected synchronized void newCoalescedDataRequest(ITmfDataRequest<T> request) {
  55                 if (request instanceof ITmfEventRequest<?>) {
  56                         ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
  57                         TmfCoalescedEventRequest<T> coalescedRequest =
  58                                 new TmfCoalescedEventRequest<T>(
  59                                                 fType, eventRequest.getRange(), eventRequest.getIndex(), eventRequest.getNbRequested(), eventRequest.getBlockSize(),
  60                                                 eventRequest.getExecType());
  61                         coalescedRequest.addRequest(eventRequest);
  62                 if (Tracer.isRequestTraced()) {
  63                         Tracer.traceRequest(request, "coalesced with " + coalescedRequest.getRequestId()); //$NON-NLS-1$
  64                 }
  65                         fPendingCoalescedRequests.add(coalescedRequest);
  66                 }
  67                 else {
  68                         super.newCoalescedDataRequest(request);
  69                 }
  70         }
  71
  72         @Override
  73         protected void queueBackgroundRequest(final ITmfDataRequest<T> request, final int blockSize, final boolean indexing) {
  74
  75                 if (! (request instanceof ITmfEventRequest)) {
  76                         super.queueBackgroundRequest(request, blockSize, indexing);
  77                         return;
  78                 }
  79
  80                 Thread thread = new Thread() {
  81                         @Override
  82                         public void run() {
  83                                 request.start();
  84
  85                                 final Integer[] CHUNK_SIZE = new Integer[1];
  86                                 CHUNK_SIZE[0] = Math.min(request.getNbRequested(), blockSize + ((indexing) ? 1 : 0));
  87
  88                                 final Integer[] nbRead = new Integer[1];
  89                                 nbRead[0] = 0;
  90
  91                                 final Boolean[] isFinished = new Boolean[1];
  92                                 isFinished[0] = Boolean.FALSE;
  93
  94                                 int startIndex = request.getIndex();
  95
  96                                 while (!isFinished[0]) {
  97
  98                                         TmfEventRequest<T> subRequest= new TmfEventRequest<T>(request.getDataType(), ((ITmfEventRequest<?>) request).getRange(), startIndex + nbRead[0], CHUNK_SIZE[0], blockSize, ExecutionType.BACKGROUND)
  99                                         {
 100                                                 @Override
 101                                                 public void handleData(T data) {
 102                                                         super.handleData(data);
 103                                                         request.handleData(data);
 104                                                         if (this.getNbRead() > CHUNK_SIZE[0]) {
 105                                                                 System.out.println("ERROR - Read too many events"); //$NON-NLS-1$
 106                                                         }
 107                                                 }
 108
 109                                                 @Override
 110                                                 public void handleCompleted() {
 111                                                         nbRead[0] += this.getNbRead();
 112                                                         if (nbRead[0] >= request.getNbRequested() || (this.getNbRead() < CHUNK_SIZE[0])) {
 113                                                                 if (this.isCancelled()) {
 114                                                                         request.cancel();
 115                                                                 } else if (this.isFailed()) {
 116                                                                     request.fail();
 117                                                                 } else {
 118                                                                         request.done();
 119                                                                 }
 120                                                                 isFinished[0] = Boolean.TRUE;
 121                                                         }
 122                                                         super.handleCompleted();
 123                                                 }
 124                                         };
 125
 126                                         if (!isFinished[0]) {
 127                                                 queueRequest(subRequest);
 128
 129                                                 try {
 130                                                         subRequest.waitForCompletion();
 131                                                 } catch (InterruptedException e) {
 132                                                         e.printStackTrace();
 133                                                 }
 134
 135                                                 if (startIndex == 0 && nbRead[0] == CHUNK_SIZE[0]) { // do this only once if the event request index is unknown
 136                                                         startIndex = subRequest.getIndex(); // update the start index with the index of the first subrequest's
 137                                                 }                                       // start time event which was set during the arm request
 138                                                 CHUNK_SIZE[0] = Math.min(request.getNbRequested() - nbRead[0], blockSize);
 139                                         }
 140                                 }
 141                         }
 142                 };
 143
 144                 thread.start();
 145         }
 146 }