org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 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  *   Yann N. Dauphin    (dhaemon@gmail.com)    - Implementation
  11  *   Francois Chouinard (fchouinard@gmail.com) - Initial API
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.lttng.ui.views.statistics;
  15
  16 import java.text.DecimalFormat;
  17 import java.util.Arrays;
  18 import java.util.HashSet;
  19 import java.util.Set;
  20
  21 import org.eclipse.jface.viewers.ColumnLabelProvider;
  22 import org.eclipse.jface.viewers.ITreeContentProvider;
  23 import org.eclipse.jface.viewers.TreeViewer;
  24 import org.eclipse.jface.viewers.TreeViewerColumn;
  25 import org.eclipse.jface.viewers.Viewer;
  26 import org.eclipse.jface.viewers.ViewerComparator;
  27 import org.eclipse.linuxtools.lttng.control.LttngCoreProviderFactory;
  28 import org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest;
  29 import org.eclipse.linuxtools.lttng.state.evProcessor.AbsEventToHandlerResolver;
  30 import org.eclipse.linuxtools.lttng.ui.TraceDebug;
  31 import org.eclipse.linuxtools.lttng.ui.model.trange.ItemContainer;
  32 import org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView;
  33 import org.eclipse.linuxtools.lttng.ui.views.common.ParamsUpdater;
  34 import org.eclipse.linuxtools.lttng.ui.views.statistics.evProcessor.StatsTimeCountHandlerFactory;
  35 import org.eclipse.linuxtools.lttng.ui.views.statistics.model.StatisticsTreeNode;
  36 import org.eclipse.linuxtools.lttng.ui.views.statistics.model.StatisticsTreeRootFactory;
  37 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  38 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  39 import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
  40 import org.eclipse.linuxtools.tmf.request.ITmfDataRequest.ExecutionType;
  41 import org.eclipse.linuxtools.tmf.signal.TmfExperimentSelectedSignal;
  42 import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
  43 import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
  44 import org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.ITmfTimeAnalysisEntry;
  45 import org.eclipse.swt.SWT;
  46 import org.eclipse.swt.events.SelectionAdapter;
  47 import org.eclipse.swt.events.SelectionEvent;
  48 import org.eclipse.swt.graphics.Color;
  49 import org.eclipse.swt.graphics.Cursor;
  50 import org.eclipse.swt.graphics.Image;
  51 import org.eclipse.swt.layout.FillLayout;
  52 import org.eclipse.swt.widgets.Composite;
  53 import org.eclipse.swt.widgets.Display;
  54 import org.eclipse.swt.widgets.Event;
  55 import org.eclipse.swt.widgets.Listener;
  56 import org.eclipse.ui.ISharedImages;
  57 import org.eclipse.ui.PlatformUI;
  58
  59 /**
  60  * <b><u>StatisticsView</u></b>
  61  * <p>
  62  * The Statistics View displays statistics for traces.
  63  *
  64  * It is implemented according to the MVC pattern. - The model is a
  65  * StatisticsTreeNode built by the State Manager. - The view is built with a
  66  * TreeViewer. - The controller that keeps model and view synchronised is an
  67  * observer of the model.
  68  */
  69 public class StatisticsView extends AbsTimeUpdateView {
  70         public static final String ID = "org.eclipse.linuxtools.lttng.ui.views.statistics";
  71         private TreeViewer treeViewer;
  72
  73         // Table column names
  74         private final String LEVEL_COLUMN = "Level";
  75         private final String EVENTS_COUNT_COLUMN = "Number of Events";
  76         private final String CPU_TIME_COLUMN = "CPU Time";
  77         private final String CUMULATIVE_CPU_TIME_COLUMN = "Cumulative CPU Time";
  78         private final String ELAPSED_TIME_COLUMN = "Elapsed Time";
  79
  80         // Table column tooltips
  81         private final String LEVEL_COLUMN_TIP = "Level at which statistics apply.";
  82         private final String EVENTS_COUNT_COLUMN_TIP = "Total amount of events that are tied to given resource.";
  83         private final String CPU_TIME_COLUMN_TIP = "Total amount of time the CPU was used excluding wait times(I/O, etc.) at that level.";
  84         private final String CUMULATIVE_CPU_TIME_COLUMN_TIP = "Total amount of time between the first and last event excluding wait times in a level.";
  85         private final String ELAPSED_TIME_COLUMN_TIP = "Total amount of time the CPU was used including wait times(I/O, etc.) at that level.";
  86
  87         // Level for which statistics should not be displayed.
  88         private Set<String> folderLevels = new HashSet<String>(Arrays
  89                         .asList(new String[] { "Event Types", "Modes", "Submodes", "CPUs",
  90                                         "Processes", "Functions" }));
  91
  92         // Levels for which sub-levels should not contain time-related statistics.
  93         private Set<String> levelsWithEmptyTime = new HashSet<String>(Arrays
  94                         .asList(new String[] { "Event Types" }));
  95
  96         private DecimalFormat decimalFormat = new DecimalFormat("0.#########");
  97         private Cursor fwaitCursor = null;
  98
  99         private static final Long STATS_INPUT_CHANGED_REFRESH = 5000L;
 100
 101         // Used to draw bar charts in columns.
 102         private interface ColumnPercentageProvider {
 103                 public double getPercentage(StatisticsTreeNode node);
 104         }
 105
 106         /**
 107          * Contains all the information necessary to build a column of the table.
 108          */
 109         private class ColumnData {
 110                 // Name of the column.
 111                 public final String header;
 112                 // Width of the column.
 113                 public final int width;
 114                 // Alignment of the column.
 115                 public final int alignment;
 116                 // Tooltip of the column.
 117                 public final String tooltip;
 118                 // Adapts a StatisticsTreeNode into the content of it's corresponding
 119                 // cell for that column.
 120                 public final ColumnLabelProvider labelProvider;
 121                 // Used to sort elements of this column. Can be null.
 122                 public final ViewerComparator comparator;
 123                 // Used to draw bar charts in this column. Can be null.
 124                 public final ColumnPercentageProvider percentageProvider;
 125
 126                 public ColumnData(String h, int w, int a, String t,
 127                                 ColumnLabelProvider l, ViewerComparator c,
 128                                 ColumnPercentageProvider p) {
 129                         header = h;
 130                         width = w;
 131                         alignment = a;
 132                         tooltip = t;
 133                         labelProvider = l;
 134                         comparator = c;
 135                         percentageProvider = p;
 136                 }
 137         };
 138
 139         // List that will be used to create the table.
 140         private ColumnData[] columnDataList = new ColumnData[] {
 141                         new ColumnData(LEVEL_COLUMN, 200, SWT.LEFT, LEVEL_COLUMN_TIP,
 142                                         new ColumnLabelProvider() {
 143                                                 @Override
 144                                                 public String getText(Object element) {
 145                                                         return ((StatisticsTreeNode) element).getKey();
 146                                                 }
 147
 148                                                 @Override
 149                                                 public Image getImage(Object element) {
 150                                                         StatisticsTreeNode node = (StatisticsTreeNode) element;
 151                                                         if (folderLevels.contains(node.getKey())) {
 152                                                                 return PlatformUI.getWorkbench()
 153                                                                                 .getSharedImages().getImage(
 154                                                                                                 ISharedImages.IMG_OBJ_FOLDER);
 155                                                         } else {
 156                                                                 return PlatformUI.getWorkbench()
 157                                                                                 .getSharedImages().getImage(
 158                                                                                                 ISharedImages.IMG_OBJ_ELEMENT);
 159                                                         }
 160                                                 }
 161                                         }, new ViewerComparator() {
 162                                                 @Override
 163                                                 public int compare(Viewer viewer, Object e1, Object e2) {
 164                                                         StatisticsTreeNode n1 = (StatisticsTreeNode) e1;
 165                                                         StatisticsTreeNode n2 = (StatisticsTreeNode) e2;
 166
 167                                                         return n1.getKey().compareTo(n2.getKey());
 168                                                 }
 169                                         }, null),
 170                         new ColumnData(EVENTS_COUNT_COLUMN, 125, SWT.LEFT,
 171                                         EVENTS_COUNT_COLUMN_TIP, new ColumnLabelProvider() {
 172                                                 @Override
 173                                                 public String getText(Object element) {
 174                                                         StatisticsTreeNode node = (StatisticsTreeNode) element;
 175                                                         if (!folderLevels.contains(node.getKey())) {
 176                                                                 return Long.toString(node.getValue().nbEvents);
 177                                                         } else {
 178                                                                 return "";
 179                                                         }
 180                                                 }
 181                                         }, new ViewerComparator() {
 182                                                 @Override
 183                                                 public int compare(Viewer viewer, Object e1, Object e2) {
 184                                                         StatisticsTreeNode n1 = (StatisticsTreeNode) e1;
 185                                                         StatisticsTreeNode n2 = (StatisticsTreeNode) e2;
 186
 187                                                         return (int) (n1.getValue().nbEvents - n2
 188                                                                         .getValue().nbEvents);
 189                                                 }
 190                                         }, new ColumnPercentageProvider() {
 191                                                 @Override
 192                                                 public double getPercentage(StatisticsTreeNode node) {
 193                                                         StatisticsTreeNode parent = node;
 194                                                         do {
 195                                                                 parent = parent.getParent();
 196                                                         } while (parent != null
 197                                                                         && parent.getValue().nbEvents == 0);
 198
 199                                                         if (parent == null) {
 200                                                                 return 0;
 201                                                         } else {
 202                                                                 return (double) node.getValue().nbEvents
 203                                                                                 / parent.getValue().nbEvents;
 204                                                         }
 205                                                 }
 206                                         }),
 207                         new ColumnData(CPU_TIME_COLUMN, 125, SWT.LEFT, CPU_TIME_COLUMN_TIP,
 208                                         new ColumnLabelProvider() {
 209                                                 @Override
 210                                                 public String getText(Object element) {
 211                                                         StatisticsTreeNode node = (StatisticsTreeNode) element;
 212
 213                                                         if (folderLevels.contains(node.getKey())) {
 214                                                                 return "";
 215                                                         } else if (node.getParent() != null
 216                                                                         && levelsWithEmptyTime.contains(node
 217                                                                                         .getParent().getKey())) {
 218                                                                 return "";
 219                                                         } else {
 220                                                                 return decimalFormat
 221                                                                                 .format(node.getValue().cpuTime
 222                                                                                                 / Math.pow(10, 9));
 223                                                         }
 224                                                 }
 225                                         }, null, null),
 226                         new ColumnData(CUMULATIVE_CPU_TIME_COLUMN, 155, SWT.LEFT,
 227                                         CUMULATIVE_CPU_TIME_COLUMN_TIP, new ColumnLabelProvider() {
 228                                                 @Override
 229                                                 public String getText(Object element) {
 230                                                         StatisticsTreeNode node = (StatisticsTreeNode) element;
 231                                                         if (folderLevels.contains(node.getKey())) {
 232                                                                 return "";
 233                                                         } else if (node.getParent() != null
 234                                                                         && levelsWithEmptyTime.contains(node
 235                                                                                         .getParent().getKey())) {
 236                                                                 return "";
 237                                                         } else {
 238                                                                 return decimalFormat
 239                                                                                 .format(node.getValue().cumulativeCpuTime
 240                                                                                                 / Math.pow(10, 9));
 241                                                         }
 242                                                 }
 243                                         }, null, null),
 244                         new ColumnData(ELAPSED_TIME_COLUMN, 100, SWT.LEFT,
 245                                         ELAPSED_TIME_COLUMN_TIP, new ColumnLabelProvider() {
 246                                                 @Override
 247                                                 public String getText(Object element) {
 248                                                         StatisticsTreeNode node = (StatisticsTreeNode) element;
 249                                                         if (folderLevels.contains(node.getKey())) {
 250                                                                 return "";
 251                                                         } else if (node.getParent() != null
 252                                                                         && levelsWithEmptyTime.contains(node
 253                                                                                         .getParent().getKey())) {
 254                                                                 return "";
 255                                                         } else {
 256                                                                 return decimalFormat
 257                                                                                 .format(node.getValue().elapsedTime
 258                                                                                                 / Math.pow(10, 9));
 259                                                         }
 260                                                 }
 261                                         }, null, null) };
 262
 263         /**
 264          * Adapter TreeViewers can use to interact with StatisticsTreeNode objects.
 265          *
 266          * @see org.eclipse.jface.viewers.ITreeContentProvider
 267          */
 268         class TreeContentProvider implements ITreeContentProvider {
 269                 /*
 270                  * (non-Javadoc)
 271                  *
 272                  * @see
 273                  * org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang
 274                  * .Object)
 275                  */
 276                 @Override
 277                 public Object[] getChildren(Object parentElement) {
 278                         return ((StatisticsTreeNode) parentElement).getChildren().toArray();
 279                 }
 280
 281                 /*
 282                  * (non-Javadoc)
 283                  *
 284                  * @see
 285                  * org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang
 286                  * .Object)
 287                  */
 288                 @Override
 289                 public Object getParent(Object element) {
 290                         return ((StatisticsTreeNode) element).getParent();
 291                 }
 292
 293                 /*
 294                  * (non-Javadoc)
 295                  *
 296                  * @see
 297                  * org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang
 298                  * .Object)
 299                  */
 300                 @Override
 301                 public boolean hasChildren(Object element) {
 302                         return ((StatisticsTreeNode) element).hasChildren();
 303                 }
 304
 305                 /*
 306                  * (non-Javadoc)
 307                  *
 308                  * @see
 309                  * org.eclipse.jface.viewers.IStructuredContentProvider#getElements(
 310                  * java.lang.Object)
 311                  */
 312                 @Override
 313                 public Object[] getElements(Object inputElement) {
 314                         return getChildren(inputElement);
 315                 }
 316
 317                 /*
 318                  * (non-Javadoc)
 319                  *
 320                  * @see org.eclipse.jface.viewers.IContentProvider#dispose()
 321                  */
 322                 @Override
 323                 public void dispose() {
 324                 }
 325
 326                 /*
 327                  * (non-Javadoc)
 328                  *
 329                  * @see
 330                  * org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse
 331                  * .jface.viewers.Viewer, java.lang.Object, java.lang.Object)
 332                  */
 333                 // @Override
 334                 @Override
 335                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 336                 }
 337         }
 338
 339         public StatisticsView(String viewName) {
 340                 super(viewName);
 341         }
 342
 343         public StatisticsView() {
 344                 this("StatisticsView");
 345         }
 346
 347         /*
 348          * (non-Javadoc)
 349          *
 350          * @see
 351          * org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets
 352          * .Composite)
 353          */
 354         @Override
 355         public void createPartControl(Composite parent) {
 356                 parent.setLayout(new FillLayout());
 357
 358                 treeViewer = new TreeViewer(parent, SWT.BORDER | SWT.H_SCROLL
 359                                 | SWT.V_SCROLL);
 360                 treeViewer.setContentProvider(new TreeContentProvider());
 361                 treeViewer.getTree().setHeaderVisible(true);
 362                 treeViewer.setUseHashlookup(true);
 363
 364                 for (final ColumnData columnData : columnDataList) {
 365                         final TreeViewerColumn treeColumn = new TreeViewerColumn(
 366                                         treeViewer, columnData.alignment);
 367                         treeColumn.getColumn().setText(columnData.header);
 368                         treeColumn.getColumn().setWidth(columnData.width);
 369                         treeColumn.getColumn().setToolTipText(columnData.tooltip);
 370                         if (columnData.comparator != null) {
 371                                 treeColumn.getColumn().addSelectionListener(
 372                                                 new SelectionAdapter() {
 373                                                         @Override
 374                                                         public void widgetSelected(SelectionEvent e) {
 375                                                                 if (treeViewer.getTree().getSortDirection() == SWT.UP
 376                                                                                 || treeViewer.getTree().getSortColumn() != treeColumn
 377                                                                                                 .getColumn()) {
 378                                                                         treeViewer
 379                                                                                         .setComparator(columnData.comparator);
 380                                                                         treeViewer.getTree().setSortDirection(
 381                                                                                         SWT.DOWN);
 382                                                                 } else {
 383                                                                         treeViewer
 384                                                                                         .setComparator(new ViewerComparator() {
 385                                                                                                 @Override
 386                                                                                                 public int compare(
 387                                                                                                                 Viewer viewer,
 388                                                                                                                 Object e1, Object e2) {
 389                                                                                                         return -1
 390                                                                                                                         * columnData.comparator
 391                                                                                                                                         .compare(
 392                                                                                                                                                         viewer,
 393                                                                                                                                                         e1,
 394                                                                                                                                                         e2);
 395                                                                                                 }
 396                                                                                         });
 397                                                                         treeViewer.getTree().setSortDirection(
 398                                                                                         SWT.UP);
 399                                                                 }
 400                                                                 treeViewer.getTree().setSortColumn(
 401                                                                                 treeColumn.getColumn());
 402                                                         }
 403                                                 });
 404                         }
 405                         treeColumn.setLabelProvider(columnData.labelProvider);
 406                 }
 407
 408                 // Handler that will draw the bar charts.
 409                 treeViewer.getTree().addListener(SWT.EraseItem, new Listener() {
 410                         // @Override
 411                         @Override
 412                         public void handleEvent(Event event) {
 413                                 if (columnDataList[event.index].percentageProvider != null) {
 414                                         StatisticsTreeNode node = (StatisticsTreeNode) event.item
 415                                                         .getData();
 416
 417                                         double percentage = columnDataList[event.index].percentageProvider
 418                                                         .getPercentage(node);
 419                                         if (percentage == 0) {
 420                                                 return;
 421                                         }
 422
 423                                         if ((event.detail & SWT.SELECTED) > 0) {
 424                                                 Color oldForeground = event.gc.getForeground();
 425                                                 event.gc.setForeground(event.item.getDisplay()
 426                                                                 .getSystemColor(SWT.COLOR_LIST_SELECTION));
 427                                                 event.gc.fillRectangle(event.x, event.y, event.width,
 428                                                                 event.height);
 429                                                 event.gc.setForeground(oldForeground);
 430                                                 event.detail &= ~SWT.SELECTED;
 431                                         }
 432
 433                                         int barWidth = (int) ((treeViewer.getTree().getColumn(1)
 434                                                         .getWidth() - 8) * percentage);
 435                                         int oldAlpha = event.gc.getAlpha();
 436                                         Color oldForeground = event.gc.getForeground();
 437                                         Color oldBackground = event.gc.getBackground();
 438                                         event.gc.setAlpha(64);
 439                                         event.gc.setForeground(event.item.getDisplay()
 440                                                         .getSystemColor(SWT.COLOR_BLUE));
 441                                         event.gc.setBackground(event.item.getDisplay()
 442                                                         .getSystemColor(SWT.COLOR_LIST_BACKGROUND));
 443                                         event.gc.fillGradientRectangle(event.x, event.y, barWidth,
 444                                                         event.height, true);
 445                                         event.gc.drawRectangle(event.x, event.y, barWidth,
 446                                                         event.height);
 447                                         event.gc.setForeground(oldForeground);
 448                                         event.gc.setBackground(oldBackground);
 449                                         event.gc.setAlpha(oldAlpha);
 450                                         event.detail &= ~SWT.BACKGROUND;
 451                                 }
 452                         }
 453                 });
 454
 455                 treeViewer.setComparator(columnDataList[0].comparator);
 456                 treeViewer.getTree().setSortColumn(treeViewer.getTree().getColumn(0));
 457                 treeViewer.getTree().setSortDirection(SWT.DOWN);
 458
 459                 // Read current data if any available
 460                 TmfExperiment<?> experiment = TmfExperiment.getCurrentExperiment();
 461                 if (experiment != null) {
 462                         requestData(experiment);
 463                 } else {
 464                         TraceDebug.debug("No selected experiment information available");
 465                 }
 466         }
 467
 468         @Override
 469         public void dispose() {
 470                 super.dispose();
 471                 if (fwaitCursor != null) {
 472                         fwaitCursor.dispose();
 473                 }
 474
 475                 // clean the model
 476                 StatisticsTreeRootFactory.removeAll();
 477         }
 478
 479         /*
 480          * (non-Javadoc)
 481          *
 482          * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 483          */
 484         @Override
 485         public void setFocus() {
 486                 treeViewer.getTree().setFocus();
 487         }
 488
 489
 490         /*
 491      * (non-Javadoc)
 492      * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#getInputChangedRefresh()
 493      */
 494     @Override
 495     protected Long getInputChangedRefresh() {
 496         return STATS_INPUT_CHANGED_REFRESH;
 497     }
 498
 499         /**
 500          * @return
 501          */
 502         @Override
 503         public AbsEventToHandlerResolver getEventProcessor() {
 504                 return StatsTimeCountHandlerFactory.getInstance();
 505         }
 506
 507         /*
 508          * (non-Javadoc)
 509          *
 510          * @see
 511          * org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#waitCursor
 512          * (boolean)
 513          */
 514         @Override
 515         protected void waitCursor(final boolean waitInd) {
 516                 if ((treeViewer == null) || (treeViewer.getTree().isDisposed())) {
 517                         return;
 518                 }
 519
 520                 Display display = treeViewer.getControl().getDisplay();
 521                 if (fwaitCursor == null) {
 522                         fwaitCursor = new Cursor(display, SWT.CURSOR_WAIT);
 523                 }
 524
 525                 // Perform the updates on the UI thread
 526                 display.asyncExec(new Runnable() {
 527                         @Override
 528                         public void run() {
 529                                 if ((treeViewer != null) && (!treeViewer.getTree().isDisposed())) {
 530                                         Cursor cursor = null; /* indicates default */
 531                                         if (waitInd) {
 532                                                 cursor = fwaitCursor;
 533                                         }
 534                                         treeViewer.getControl().setCursor(cursor);
 535                                 }
 536                         }
 537                 });
 538         }
 539
 540         @Override
 541         public void ModelUpdatePrep(TmfTimeRange timeRange, boolean clearAllData) {
 542                 Object input = treeViewer.getInput();
 543                 if ((input != null) && (input instanceof StatisticsTreeNode) && (!treeViewer.getTree().isDisposed())) {
 544                         ((StatisticsTreeNode) input).reset();
 545                         treeViewer.getTree().getDisplay().asyncExec(new Runnable() {
 546                                 // @Override
 547                                 @Override
 548                                 public void run() {
 549                                         if (!treeViewer.getTree().isDisposed())
 550                                                 treeViewer.refresh();
 551                                 }
 552                         });
 553                 }
 554         }
 555
 556         @Override
 557         public void modelInputChanged(ILttngSyntEventRequest request, boolean complete) {
 558                 // Ignore update if disposed
 559                 if (treeViewer.getTree().isDisposed()) return;
 560
 561                 treeViewer.getTree().getDisplay().asyncExec(new Runnable() {
 562                         // @Override
 563                         @Override
 564                         public void run() {
 565                                 if (!treeViewer.getTree().isDisposed())
 566                                         treeViewer.refresh();
 567                         }
 568                 });
 569                 }
 570
 571         /*
 572          * (non-Javadoc)
 573          *
 574          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
 575          * modelIncomplete
 576          * (org.eclipse.linuxtools.lttng.request.ILttngSyntEventRequest)
 577          */
 578         @Override
 579         public void modelIncomplete(ILttngSyntEventRequest request) {
 580                 Object input = treeViewer.getInput();
 581                 if (input != null && input instanceof StatisticsTreeNode) {
 582                         // The data from this experiment is invalid and shall be removed to
 583                         // refresh upon next selection
 584                     String name = request.getExperimentName();
 585                         StatisticsTreeRootFactory.removeStatTreeRoot(name);
 586                 }
 587         }
 588
 589         /**
 590          * @param signal
 591          */
 592         @TmfSignalHandler
 593         public void experimentSelected(TmfExperimentSelectedSignal<? extends TmfEvent> signal) {
 594                 if (signal != null) {
 595                         TmfExperiment<?> experiment = signal.getExperiment();
 596                         String experimentName =  experiment.getName();
 597
 598                         if (StatisticsTreeRootFactory.containsTreeRoot(experimentName)) {
 599                                 // The experiment root is already present
 600                                 StatisticsTreeNode experimentTreeNode = StatisticsTreeRootFactory.getStatTreeRoot(experimentName);
 601
 602                                 ITmfTrace[] traces = experiment.getTraces();
 603
 604                                 // check if there is partial data loaded in the experiment
 605                                 int numTraces = experiment.getTraces().length;
 606                                 int numNodeTraces = experimentTreeNode.getNbChildren();
 607
 608                                 if (numTraces == numNodeTraces) {
 609                                         boolean same = true;
 610                                         // Detect if the experiment contains the same traces as when
 611                                         // previously selected
 612                                         for (int i = 0; i < numTraces; i++) {
 613                                                 String traceName = traces[i].getName();
 614                                                 if (!experimentTreeNode.containsChild(traceName)) {
 615                                                          same = false;
 616                                                          break;
 617                                                 }
 618                                         }
 619
 620                                         if (same) {
 621                                                 // no need to reload data, all traces are already loaded
 622                                                 treeViewer.setInput(experimentTreeNode);
 623                                                 return;
 624                                         }
 625                                 }
 626                         }
 627
 628                         // if the data is not available or has changed, reload it
 629                         requestData(experiment);
 630                 }
 631         }
 632
 633         /**
 634          * @param experiment
 635          */
 636         private void requestData(TmfExperiment<?> experiment) {
 637                 if (experiment != null) {
 638                         StatisticsTreeNode treeModelRoot = StatisticsTreeRootFactory.getStatTreeRoot(experiment.getName());
 639
 640                         // if the model has contents, clear to start over
 641                         if (treeModelRoot.hasChildren()) {
 642                                 treeModelRoot.reset();
 643                         }
 644
 645                         // set input to a clean data model
 646                         treeViewer.setInput(treeModelRoot);
 647                         TmfTimeRange experimentTRange = experiment.getTimeRange();
 648
 649                         // send the initial request, to start filling up model
 650                         dataRequest(experimentTRange, experimentTRange, true, ExecutionType.BACKGROUND);
 651                 } else {
 652                         TraceDebug.debug("No selected experiment information available");
 653                 }
 654         }
 655
 656         /*
 657          * (non-Javadoc)
 658          *
 659          * @see
 660          * org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#displayModel
 661          * (org.eclipse.linuxtools.tmf.ui.viewers.timeAnalysis.model.
 662          * ITmfTimeAnalysisEntry[], long, long, boolean, long, long,
 663          * java.lang.Object)
 664          */
 665         @Override
 666         protected void displayModel(ITmfTimeAnalysisEntry[] items, long startBoundTime, long endBoundTime,
 667                         boolean updateTimeBounds, long startVisibleWindow, long endVisibleWindow, Object source) {
 668                 // No applicable to statistics view
 669         }
 670
 671         /*
 672          * (non-Javadoc)
 673          *
 674          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#
 675          * getParamsUpdater()
 676          */
 677         @Override
 678         protected ParamsUpdater getParamsUpdater() {
 679                 // Not applicable to statistics view
 680                 return null;
 681         }
 682
 683         @Override
 684         protected ItemContainer<?> getItemContainer() {
 685                 // Not applicable to statistics view
 686                 return null;
 687         }
 688
 689         /*
 690          * (non-Javadoc)
 691          * @see org.eclipse.linuxtools.lttng.ui.views.common.AbsTimeUpdateView#getProviderId()
 692          */
 693         @Override
 694         protected int getProviderId() {
 695             return LttngCoreProviderFactory.STATISTICS_LTTNG_SYTH_EVENT_PROVIDER;
 696         }
 697 }