org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.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  *   Alvaro Sanchez-Leon (alvsan09@gmail.com) - Initial API and implementation
  11  *   Marc Dumais (marc.dumais@ericsson.com) - Fix for 316455 (second part)
  12  *******************************************************************************/
  13 package org.eclipse.linuxtools.lttng.state.experiment;
  14
  15 import java.util.HashMap;
  16 import java.util.Map;
  17
  18 import org.eclipse.linuxtools.lttng.TraceDebug;
  19 import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
  20 import org.eclipse.linuxtools.lttng.control.LttngSyntheticEventProvider;
  21 import org.eclipse.linuxtools.lttng.event.LttngEvent;
  22 import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent;
  23 import org.eclipse.linuxtools.lttng.event.LttngSyntheticEvent.SequenceInd;
  24 import org.eclipse.linuxtools.lttng.model.LTTngTreeNode;
  25 import org.eclipse.linuxtools.lttng.signal.ILttExperimentSelectedListener;
  26 import org.eclipse.linuxtools.lttng.signal.StateExperimentListener;
  27 import org.eclipse.linuxtools.lttng.state.trace.IStateTraceManager;
  28 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  29 import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
  30 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
  31 import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
  32 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
  33 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
  34 import org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal;
  35 import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
  36
  37 /**
  38  * @author alvaro
  39  *
  40  */
  41 public class StateExperimentManager extends LTTngTreeNode implements
  42                 ILttExperimentSelectedListener, IStateExperimentManager {
  43
  44         // ========================================================================
  45         // Data
  46         // =======================================================================
  47         private LTTngTreeNode fSelectedExperiment = null; // one selected experiment
  48                                                                                                                 // supported
  49         private final StateExperimentListener fexperimentListener;
  50         private boolean fwaitForCompletion = false;
  51         /**
  52          * Used to route incoming events to proper trace manager, during check point
  53          * building
  54          */
  55         private final Map<ITmfTrace, IStateTraceManager> ftraceToManagerMap = new HashMap<ITmfTrace, IStateTraceManager>();
  56         private final Map<ITmfTrace, Long> ftraceEventsReadMap = new HashMap<ITmfTrace, Long>();
  57         private LttngSyntheticEvent syntheticEvent = null;
  58         private ITmfEventRequest<LttngEvent> fStateCheckPointRequest = null;
  59
  60
  61         // ========================================================================
  62         // Constructors
  63         // =======================================================================
  64         public StateExperimentManager(Long id, String name) {
  65                 super(id, null, name, null);
  66                 fexperimentListener = new StateExperimentListener("Experiment Manager", this);
  67         }
  68
  69
  70         // ========================================================================
  71         // Methods
  72         // =======================================================================
  73
  74 //      /* (non-Javadoc)
  75 //       * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperimentTimeWindow(org.eclipse.linuxtools.tmf.event.TmfTimeRange, java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
  76 //       */
  77 //      public ILttngSyntEventRequest readExperimentTimeWindow(TmfTimeRange trange,
  78 //                      Object source, IRequestStatusListener listener,
  79 //                      ITransEventProcessor processor) {
  80 //
  81 //              ILttngSyntEventRequest request = null;
  82 //
  83 //              // validate
  84 //              if (fSelectedExperiment != null) {
  85 //                      // Get all trace manager nodes
  86 //                      LTTngTreeNode[] traceMgrs = fSelectedExperiment.getChildren();
  87 //
  88 //                      if (traceMgrs != null && traceMgrs.length > 0) {
  89 //                              IStateTraceManager traceManager;
  90 //                              // Trigger one request per trace
  91 //                              for (LTTngTreeNode traceNode : traceMgrs) {
  92 //                                      traceManager = (IStateTraceManager) traceNode;
  93 //                                      request = traceManager.executeDataRequest(trange, source,
  94 //                                                      listener,
  95 //                                                      processor);
  96 //                              }
  97 //                      }
  98 //              } else {
  99 //                      if (fSelectedExperiment == null) {
 100 //                              TraceDebug.debug("No experiment selected");
 101 //                      }
 102 //              }
 103 //
 104 //              return request;
 105 //      }
 106
 107 //      /* (non-Javadoc)
 108 //       * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#readExperiment(java.lang.String, org.eclipse.linuxtools.lttng.state.IStateDataRequestListener)
 109 //       */
 110 //      @SuppressWarnings("unchecked")
 111 //      public void readExperiment(Object source, IRequestStatusListener listener,
 112 //                      ITransEventProcessor processor) {
 113 //              // validate
 114 //              if (fSelectedExperiment != null) {
 115 //                      TmfExperiment<LttngEvent> experiment = (TmfExperiment<LttngEvent>) fSelectedExperiment
 116 //                                      .getValue();
 117 //                      TmfTimeRange trange = experiment.getTimeRange();
 118 //                      readExperimentTimeWindow(trange, source, listener, processor);
 119 //              } else {
 120 //                      TraceDebug.debug("No selected experiment available");
 121 //              }
 122 //      }
 123
 124
 125
 126         /*
 127          * (non-Javadoc)
 128          *
 129          * @see
 130          * org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager
 131          * #experimentSelected_prep
 132          * (org.eclipse.linuxtools.tmf.experiment.TmfExperiment)
 133          */
 134         @Override
 135         public void experimentSelected_prep(TmfExperiment<LttngEvent> experiment) {
 136                 LTTngTreeNode experimentNode = null;
 137                 if (experiment != null) {
 138                         experimentNode = getChildByName(experiment.getName());
 139                         // keep experiment if already loaded with the same value
 140                         if (experimentNode != null
 141                                         && experimentNode.getValue() != experiment) {
 142                                 // rebuild the experiment nodes from scratch
 143                                 removeChild(experimentNode);
 144                                 experimentNode = null;
 145                         }
 146
 147                         // Make sure all traces involved have a corresponding state manager
 148                         // and
 149                         // state system to request its initial data
 150                         if (experimentNode == null) {
 151                                 // Create the new experiment tree node
 152                                 experimentNode = new LTTngTreeNode(getNextUniqueId(), this,
 153                                                 experiment.getName(), experiment);
 154                                 // add the new experiment to this children list
 155                                 addChild(experimentNode);
 156                         }
 157
 158                         // Make sure the traces exists in the tree
 159                         ITmfTrace[] rtraces = experiment.getTraces();
 160                         String traceName;
 161                         LTTngTreeNode traceStateManagerNode;
 162                         // StateStacksHandler
 163                         for (ITmfTrace rtrace : rtraces) {
 164                                 traceName = rtrace.getName();
 165                                 traceStateManagerNode = experimentNode.getChildByName(traceName);
 166                                 // Node does not exist for this experiment, so needs to be
 167                                 // created
 168                                 if (traceStateManagerNode == null) {
 169                                         traceStateManagerNode = StateManagerFactory.getManager(
 170                                                         rtrace, experimentNode);
 171                                         experimentNode.addChild(traceStateManagerNode);
 172                                 }
 173                         }
 174
 175                         // Reset event provider to handle requests for the new experiment
 176                         LttngSyntheticEventProvider synEventProvider = LttngCoreProviderFactory
 177                                         .getEventProvider();
 178                         synEventProvider.reset(experimentNode);
 179
 180                         // preserve the selected experiment
 181                         fSelectedExperiment = experimentNode;
 182                 }
 183         }
 184
 185         /*
 186          * (non-Javadoc)
 187          *
 188          * @see org.eclipse.linuxtools.lttng.signal.ILttExperimentSelectedListener#
 189          * experimentSelected(java.lang.Object,
 190          * org.eclipse.linuxtools.tmf.experiment.TmfExperiment)
 191          */
 192         @Override
 193         public void experimentSelected(Object source,
 194                         TmfExperiment<LttngEvent> experiment) {
 195                 // validate
 196                 if (experiment == null) {
 197                         TraceDebug.debug("Received expriment is null");
 198                         return;
 199                 }
 200
 201                 // If previous request is ongoing, cancel it before requesting a new
 202                 // one.
 203                 if (fStateCheckPointRequest != null && !fStateCheckPointRequest.isCompleted()) {
 204                         fStateCheckPointRequest.cancel();
 205                 }
 206
 207                 // trigger data request to build the state system check points
 208                 fStateCheckPointRequest = buildCheckPoints(experiment);
 209         }
 210
 211         /*
 212          * (non-Javadoc)
 213          *
 214          * @see org.eclipse.linuxtools.lttng.signal.ILttExperimentSelectedListener#
 215          * experimentUpdated
 216          * (org.eclipse.linuxtools.tmf.signal.TmfExperimentUpdatedSignal, boolean)
 217          */
 218         @Override
 219         public void experimentUpdated(TmfExperimentUpdatedSignal signal, boolean wait) {
 220                 // NOTE: This represents the end of TMF indexing for a trace, however
 221                 // the node was already existing and the state system check points are
 222                 // already requested and built upon selection.
 223                 // No action for the time being
 224         }
 225
 226
 227         /**
 228          * @return the SelectedExperiment tree node
 229          */
 230         @Override
 231         public LTTngTreeNode getSelectedExperiment() {
 232                 return fSelectedExperiment;
 233         }
 234
 235         /* (non-Javadoc)
 236          * @see org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager#getExperimentTimeRange()
 237          */
 238         @Override
 239         @SuppressWarnings("unchecked")
 240         public TmfTimeRange getExperimentTimeRange() {
 241                 TmfTimeRange timeRangeResult = null;
 242                 if (fSelectedExperiment != null) {
 243                         timeRangeResult = ((TmfExperiment<LttngEvent>) fSelectedExperiment
 244                                         .getValue()).getTimeRange();
 245                 }
 246                 return timeRangeResult;
 247         }
 248
 249         /*
 250          * (non-Javadoc)
 251          *
 252          * @see java.lang.Object#finalize()
 253          */
 254         @Override
 255         protected void finalize() {
 256                 fexperimentListener.dispose();
 257         }
 258
 259
 260         /*
 261          * (non-Javadoc)
 262          *
 263          * @see
 264          * org.eclipse.linuxtools.lttng.state.experiment.IStateExperimentManager
 265          * #waitForComplete(boolean)
 266          */
 267         @Override
 268         public void waitForCompletion(boolean wait) {
 269                 fwaitForCompletion = wait;
 270         }
 271
 272         private ITmfEventRequest<LttngEvent> buildCheckPoints(TmfExperiment<LttngEvent> experiment) {
 273                 // validate
 274                 if (experiment == null) {
 275                         TraceDebug.debug("Received expriment is null");
 276                         return null;
 277                 }
 278
 279                 LTTngTreeNode experimentNode = getChildByName(experiment.getName());
 280                 if (experimentNode == null) {
 281                         TraceDebug.debug("Expriment Node " + experiment.getName() + " does not exist");
 282                         return null;
 283                 }
 284
 285                 // get the trace manager nodes associated to the experiment
 286                 LTTngTreeNode[] traceNodes = experimentNode.getChildren();
 287                 synchronized (this) {
 288                         ftraceToManagerMap.clear();
 289                         ftraceEventsReadMap.clear();
 290                 }
 291
 292                 ITmfTrace trace;
 293                 for (LTTngTreeNode traceStateManagerNode : traceNodes) {
 294                         IStateTraceManager traceManager;
 295                         try {
 296                                 traceManager = (IStateTraceManager) traceStateManagerNode;
 297                         } catch (ClassCastException e) {
 298                                 System.out.println(e.getStackTrace().toString());
 299                                 return null;
 300                         }
 301
 302                         // Clear all previously created check points as preparation to
 303                         // re-build
 304                         traceManager.clearCheckPoints();
 305
 306                         // build the trace to manager mapping for event dispatching
 307                         trace = traceManager.getTrace();
 308                         synchronized (this) {
 309                                 ftraceToManagerMap.put(trace, traceManager);
 310                                 ftraceEventsReadMap.put(trace, new Long(0));
 311                         }
 312                 }
 313
 314                 // if no trace mapping
 315                 if (ftraceToManagerMap.size() < 1) {
 316                         TraceDebug.debug("No traces associated to experiment " + experiment.getName());
 317                         return null;
 318                 }
 319
 320                 // Prepare event data request to build state model
 321                 ITmfEventRequest<LttngEvent> request = new TmfEventRequest<LttngEvent>(
 322                                 LttngEvent.class, TmfTimeRange.Eternity,
 323                                 TmfDataRequest.ALL_DATA, 1, ITmfDataRequest.ExecutionType.BACKGROUND) {
 324
 325                         long nbEventsHandled = 0;
 326
 327                         /*
 328                          * (non-Javadoc)
 329                          *
 330                          * @see
 331                          * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleData()
 332                          */
 333                         @Override
 334                         public void handleData(LttngEvent event) {
 335                                 super.handleData(event);
 336                                 if (event != null) {
 337 //                                      Tracer.trace("Chk: " + event.getTimestamp());
 338                                         nbEventsHandled++;
 339                                         ITmfTrace trace = event.getParentTrace();
 340                                         IStateTraceManager traceManager = ftraceToManagerMap.get(trace);
 341                                         long nbEvents = ftraceEventsReadMap.get(trace) + 1;
 342                                         ftraceEventsReadMap.put(trace, nbEvents);
 343                                         if (traceManager != null) {
 344                                                 // obtain synthetic event
 345                                                 LttngSyntheticEvent synEvent = updateSynEvent(event, traceManager);
 346                                                 // update state system, and save check points as needed
 347                                                 traceManager.handleEvent(synEvent, nbEvents);
 348                                         } else {
 349                                                 TraceDebug
 350                                                                 .debug("StateTraceManager not found for trace"
 351                                                                                 + trace.getName());
 352                                         }
 353                                 }
 354                         }
 355
 356                         /*
 357                          * (non-Javadoc)
 358                          *
 359                          * @see
 360                          * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleFailure()
 361                          */
 362                         @Override
 363                         public void handleFailure() {
 364                                 printCompletedMessage();
 365                         }
 366
 367                         /*
 368                          * (non-Javadoc)
 369                          *
 370                          * @see
 371                          * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleCancel()
 372                          */
 373                         @Override
 374                         public void handleCancel() {
 375                                 printCompletedMessage();
 376                         }
 377
 378                         /*
 379                          * (non-Javadoc)
 380                          *
 381                          * @see
 382                          * org.eclipse.linuxtools.tmf.request.TmfDataRequest#handleSuccess()
 383                          */
 384                         @Override
 385                         public void handleSuccess() {
 386                                 printCompletedMessage();
 387                         }
 388
 389                         /**
 390                          * @param header
 391                          */
 392                         private void printCompletedMessage() {
 393                                 if (TraceDebug.isDEBUG()) {
 394                                         TraceDebug.debug("Trace check point building completed, number of events handled: " + nbEventsHandled
 395                                                         + "\n\t\t");
 396                                         for (IStateTraceManager traceMgr : ftraceToManagerMap.values()) {
 397                                                 TraceDebug.debug(traceMgr.toString() + "\n\t\t");
 398                                         }
 399                                 }
 400                         }
 401                 };
 402
 403                 // Execute event data request
 404                 experiment.sendRequest(request);
 405
 406                 if (fwaitForCompletion) {
 407                         try {
 408                                 request.waitForCompletion();
 409                         } catch (InterruptedException e) {
 410                                 e.printStackTrace();
 411                         }
 412                 }
 413
 414                 return request;
 415         }
 416
 417
 418         private LttngSyntheticEvent updateSynEvent(LttngEvent e, IStateTraceManager stateTraceManager) {
 419                 if (syntheticEvent == null || syntheticEvent.getBaseEvent() != e) {
 420                         syntheticEvent = new LttngSyntheticEvent(e);
 421                 }
 422
 423                 // Trace model needed by application handlers
 424                 syntheticEvent.setTraceModel(stateTraceManager.getStateModel());
 425                 syntheticEvent.setSequenceInd(SequenceInd.UPDATE);
 426
 427                 return syntheticEvent;
 428         }
 429
 430 }