org.eclipse.linuxtools.lttng2.kernel.ui/src/org/eclipse/linuxtools/internal/lttng2/kernel/ui/views/controlflow/ControlFlowView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012 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  *   Patrick Tasse - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.controlflow;
  14
  15 import java.util.ArrayList;
  16 import java.util.Arrays;
  17 import java.util.HashMap;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 import org.eclipse.jface.action.Action;
  22 import org.eclipse.jface.action.IToolBarManager;
  23 import org.eclipse.jface.action.Separator;
  24 import org.eclipse.jface.viewers.ILabelProviderListener;
  25 import org.eclipse.jface.viewers.ITableLabelProvider;
  26 import org.eclipse.jface.viewers.ITreeContentProvider;
  27 import org.eclipse.jface.viewers.Viewer;
  28 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  29 import org.eclipse.linuxtools.lttng2.kernel.core.trace.Attributes;
  30 import org.eclipse.linuxtools.lttng2.kernel.core.trace.CtfKernelTrace;
  31 import org.eclipse.linuxtools.tmf.core.ctfadaptor.CtfTmfTimestamp;
  32 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  33 import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
  34 import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
  35 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  36 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  37 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  38 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  39 import org.eclipse.linuxtools.tmf.core.signal.TmfExperimentSelectedSignal;
  40 import org.eclipse.linuxtools.tmf.core.signal.TmfRangeSynchSignal;
  41 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  42 import org.eclipse.linuxtools.tmf.core.signal.TmfTimeSynchSignal;
  43 import org.eclipse.linuxtools.tmf.core.statesystem.IStateSystemQuerier;
  44 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
  45 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  46 import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
  47 import org.eclipse.linuxtools.tmf.ui.views.TmfView;
  48 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphRangeListener;
  49 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphSelectionListener;
  50 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  51 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.StateItem;
  52 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphCombo;
  53 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphPresentationProvider;
  54 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphRangeUpdateEvent;
  55 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphSelectionEvent;
  56 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  57 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  58 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  59 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  60 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils;
  61 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.Resolution;
  62 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  63 import org.eclipse.swt.SWT;
  64 import org.eclipse.swt.graphics.Image;
  65 import org.eclipse.swt.graphics.RGB;
  66 import org.eclipse.swt.widgets.Composite;
  67 import org.eclipse.swt.widgets.Display;
  68 import org.eclipse.swt.widgets.TreeColumn;
  69 import org.eclipse.ui.IActionBars;
  70
  71 public class ControlFlowView extends TmfView {
  72
  73     // ------------------------------------------------------------------------
  74     // Constants
  75     // ------------------------------------------------------------------------
  76
  77     /**
  78      * View ID.
  79      */
  80     public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.controlflow"; //$NON-NLS-1$
  81
  82     /**
  83      * Initial time range
  84      */
  85     private static final long INITIAL_WINDOW_OFFSET = (1L * 100  * 1000 * 1000); // .1sec
  86
  87     private static final String PROCESS_COLUMN    = Messages.ControlFlowView_processColumn;
  88     private static final String TID_COLUMN        = Messages.ControlFlowView_tidColumn;
  89     private static final String PPID_COLUMN       = Messages.ControlFlowView_ppidColumn;
  90     private static final String BIRTH_TIME_COLUMN = Messages.ControlFlowView_birthTimeColumn;
  91     private static final String TRACE_COLUMN      = Messages.ControlFlowView_traceColumn;
  92
  93     private final String[] COLUMN_NAMES = new String[] {
  94             PROCESS_COLUMN,
  95             TID_COLUMN,
  96             PPID_COLUMN,
  97             BIRTH_TIME_COLUMN,
  98             TRACE_COLUMN
  99     };
 100
 101     // ------------------------------------------------------------------------
 102     // Fields
 103     // ------------------------------------------------------------------------
 104
 105     // The timegraph combo
 106     private TimeGraphCombo fTimeGraphCombo;
 107
 108     // The selected experiment
 109     private TmfExperiment<ITmfEvent> fSelectedExperiment;
 110
 111     // The timegraph entry list
 112     private ArrayList<ControlFlowEntry> fEntryList;
 113
 114     // The start time
 115     private long fStartTime;
 116
 117     // The end time
 118     private long fEndTime;
 119
 120     // The display width
 121     private int fDisplayWidth;
 122
 123     // The zoom thread
 124     private ZoomThread fZoomThread;
 125
 126     // The next resource action
 127     private Action fNextResourceAction;
 128
 129     // The previous resource action
 130     private Action fPreviousResourceAction;
 131
 132     // ------------------------------------------------------------------------
 133     // Classes
 134     // ------------------------------------------------------------------------
 135
 136     private class TreeContentProvider implements ITreeContentProvider {
 137
 138         @Override
 139         public void dispose() {
 140         }
 141
 142         @Override
 143         public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 144         }
 145
 146         @Override
 147         public Object[] getElements(Object inputElement) {
 148             return (ITimeGraphEntry[]) inputElement;
 149         }
 150
 151         @Override
 152         public Object[] getChildren(Object parentElement) {
 153             ITimeGraphEntry entry = (ITimeGraphEntry) parentElement;
 154             return entry.getChildren();
 155         }
 156
 157         @Override
 158         public Object getParent(Object element) {
 159             ITimeGraphEntry entry = (ITimeGraphEntry) element;
 160             return entry.getParent();
 161         }
 162
 163         @Override
 164         public boolean hasChildren(Object element) {
 165             ITimeGraphEntry entry = (ITimeGraphEntry) element;
 166             return entry.hasChildren();
 167         }
 168
 169     }
 170
 171     private class TreeLabelProvider implements ITableLabelProvider {
 172
 173         @Override
 174         public void addListener(ILabelProviderListener listener) {
 175         }
 176
 177         @Override
 178         public void dispose() {
 179         }
 180
 181         @Override
 182         public boolean isLabelProperty(Object element, String property) {
 183             return false;
 184         }
 185
 186         @Override
 187         public void removeListener(ILabelProviderListener listener) {
 188         }
 189
 190         @Override
 191         public Image getColumnImage(Object element, int columnIndex) {
 192             return null;
 193         }
 194
 195         @Override
 196         public String getColumnText(Object element, int columnIndex) {
 197             ControlFlowEntry entry = (ControlFlowEntry) element;
 198             if (columnIndex == 0) {
 199                 return entry.getName();
 200             } else if (columnIndex == 1) {
 201                 return Integer.toString(entry.getThreadId());
 202             } else if (columnIndex == 2) {
 203                 if (entry.getPPID() > 0) {
 204                     return Integer.toString(entry.getPPID());
 205                 }
 206             } else if (columnIndex == 3) {
 207                 return Utils.formatTime(entry.getBirthTime(), TimeFormat.ABSOLUTE, Resolution.NANOSEC);
 208             } else if (columnIndex == 4) {
 209                 return entry.getTrace().getName();
 210             }
 211             return ""; //$NON-NLS-1$
 212         }
 213
 214     }
 215
 216     private class ZoomThread extends Thread {
 217         private long fZoomStartTime;
 218         private long fZoomEndTime;
 219         private long fResolution;
 220         private boolean fCancelled = false;
 221
 222         public ZoomThread(long startTime, long endTime) {
 223             super("ControlFlowView zoom"); //$NON-NLS-1$
 224             fZoomStartTime = startTime;
 225             fZoomEndTime = endTime;
 226             fResolution = Math.max(1, (fZoomEndTime - fZoomStartTime) / fDisplayWidth);
 227         }
 228
 229         @Override
 230         public void run() {
 231             if (fEntryList == null) {
 232                 return;
 233             }
 234             for (ControlFlowEntry entry : fEntryList) {
 235                 if (fCancelled) {
 236                     return;
 237                 }
 238                 zoom(entry);
 239             }
 240             redraw();
 241         }
 242
 243         private void zoom(ControlFlowEntry entry) {
 244             List<ITimeEvent> zoomedEventList = getEventList(entry, fZoomStartTime, fZoomEndTime, fResolution);
 245             entry.setZoomedEventList(zoomedEventList);
 246             for (ControlFlowEntry child : entry.getChildren()) {
 247                 if (fCancelled) {
 248                     return;
 249                 }
 250                 zoom(child);
 251             }
 252         }
 253
 254         public void cancel() {
 255             fCancelled = true;
 256         }
 257     }
 258
 259     // ------------------------------------------------------------------------
 260     // Constructors
 261     // ------------------------------------------------------------------------
 262
 263     public ControlFlowView() {
 264         super(ID);
 265         fDisplayWidth = Display.getDefault().getBounds().width;
 266     }
 267
 268     // ------------------------------------------------------------------------
 269     // ViewPart
 270     // ------------------------------------------------------------------------
 271
 272     /* (non-Javadoc)
 273      * @see org.eclipse.linuxtools.tmf.ui.views.TmfView#createPartControl(org.eclipse.swt.widgets.Composite)
 274      */
 275     @Override
 276     public void createPartControl(Composite parent) {
 277         fTimeGraphCombo = new TimeGraphCombo(parent, SWT.NONE);
 278
 279         fTimeGraphCombo.setTreeContentProvider(new TreeContentProvider());
 280
 281         fTimeGraphCombo.setTreeLabelProvider(new TreeLabelProvider());
 282
 283         fTimeGraphCombo.setTimeGraphProvider(new TimeGraphPresentationProvider() {
 284             private static final String UNKNOWN = "UNKNOWN"; //$NON-NLS-1$
 285             private static final String WAIT = "WAIT"; //$NON-NLS-1$
 286             private static final String USERMODE = "USERMODE"; //$NON-NLS-1$
 287             private static final String SYSCALL = "SYSCALL"; //$NON-NLS-1$
 288             private static final String INTERRUPTED = "INTERRUPTED"; //$NON-NLS-1$
 289
 290             @Override
 291             public String getStateTypeName() {
 292                 return Messages.ControlFlowView_stateTypeName;
 293             }
 294
 295             @Override
 296             public StateItem[] getStateTable() {
 297                 return new StateItem[] {
 298                         new StateItem(new RGB(100, 100, 100), UNKNOWN),
 299                         new StateItem(new RGB(150, 150, 0), WAIT),
 300                         new StateItem(new RGB(0, 200, 0), USERMODE),
 301                         new StateItem(new RGB(0, 0, 200), SYSCALL),
 302                         new StateItem(new RGB(200, 100, 100), INTERRUPTED)
 303                 };
 304             }
 305
 306             @Override
 307             public int getEventTableIndex(ITimeEvent event) {
 308                 if (event instanceof ControlFlowEvent) {
 309                     int status = ((ControlFlowEvent) event).getStatus();
 310                     if (status == Attributes.STATUS_WAIT) {
 311                         return 1;
 312                     } else if (status == Attributes.STATUS_RUN_USERMODE) {
 313                         return 2;
 314                     } else if (status == Attributes.STATUS_RUN_SYSCALL) {
 315                         return 3;
 316                     } else if (status == Attributes.STATUS_INTERRUPTED) {
 317                         return 4;
 318                     }
 319                 }
 320                 return 0;
 321             }
 322
 323             @Override
 324             public String getEventName(ITimeEvent event) {
 325                 if (event instanceof ControlFlowEvent) {
 326                     int status = ((ControlFlowEvent) event).getStatus();
 327                     if (status == Attributes.STATUS_WAIT) {
 328                         return WAIT;
 329                     } else if (status == Attributes.STATUS_RUN_USERMODE) {
 330                         return USERMODE;
 331                     } else if (status == Attributes.STATUS_RUN_SYSCALL) {
 332                         return SYSCALL;
 333                     } else if (status == Attributes.STATUS_INTERRUPTED) {
 334                         return INTERRUPTED;
 335                     }
 336                 }
 337                 return UNKNOWN;
 338             }
 339
 340             @Override
 341             public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event) {
 342                 Map<String, String> retMap = new HashMap<String, String>();
 343                 if (event instanceof ControlFlowEvent) {
 344                     int status = ((ControlFlowEvent) event).getStatus();
 345                     if (status == Attributes.STATUS_RUN_SYSCALL) {
 346                         ControlFlowEntry entry = (ControlFlowEntry) event.getEntry();
 347                         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 348                         try {
 349                             int syscallQuark = ssq.getQuarkRelative(entry.getThreadQuark(), Attributes.SYSTEM_CALL);
 350                             ITmfStateInterval value = ssq.querySingleState(event.getTime(), syscallQuark);
 351                             if (!value.getStateValue().isNull()) {
 352                                 ITmfStateValue state = value.getStateValue();
 353                                 retMap.put(Messages.ControlFlowView_attributeSyscallName, state.toString());
 354                             }
 355
 356                         } catch (AttributeNotFoundException e) {
 357                             e.printStackTrace();
 358                         } catch (TimeRangeException e) {
 359                             e.printStackTrace();
 360                         }
 361 //                        List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution);
 362                     }
 363                 }
 364
 365                 return retMap;
 366             }
 367         });
 368
 369         fTimeGraphCombo.setTreeColumns(COLUMN_NAMES);
 370
 371         fTimeGraphCombo.getTimeGraphViewer().addRangeListener(new ITimeGraphRangeListener() {
 372             @Override
 373             public void timeRangeUpdated(TimeGraphRangeUpdateEvent event) {
 374                 final long startTime = event.getStartTime();
 375                 final long endTime = event.getEndTime();
 376                 TmfTimeRange range = new TmfTimeRange(new CtfTmfTimestamp(startTime), new CtfTmfTimestamp(endTime));
 377                 TmfTimestamp time = new CtfTmfTimestamp(fTimeGraphCombo.getTimeGraphViewer().getSelectedTime());
 378                 broadcast(new TmfRangeSynchSignal(ControlFlowView.this, range, time));
 379                 if (fZoomThread != null) {
 380                     fZoomThread.cancel();
 381                 }
 382                 startZoomThread(startTime, endTime);
 383             }
 384         });
 385
 386         fTimeGraphCombo.getTimeGraphViewer().addTimeListener(new ITimeGraphTimeListener() {
 387             @Override
 388             public void timeSelected(TimeGraphTimeEvent event) {
 389                 long time = event.getTime();
 390                 broadcast(new TmfTimeSynchSignal(ControlFlowView.this, new CtfTmfTimestamp(time)));
 391             }
 392         });
 393
 394         fTimeGraphCombo.addSelectionListener(new ITimeGraphSelectionListener() {
 395             @Override
 396             public void selectionChanged(TimeGraphSelectionEvent event) {
 397                 //ITimeGraphEntry selection = event.getSelection();
 398             }
 399         });
 400
 401         fTimeGraphCombo.getTimeGraphViewer().setTimeCalendarFormat(true);
 402
 403         final Thread thread = new Thread("ControlFlowView build") { //$NON-NLS-1$
 404             @Override
 405             public void run() {
 406                 if (TmfExperiment.getCurrentExperiment() != null) {
 407                     selectExperiment(TmfExperiment.getCurrentExperiment());
 408                 }
 409             }
 410         };
 411         thread.start();
 412
 413         // View Action Handling
 414         makeActions();
 415         contributeToActionBars();
 416     }
 417
 418     /* (non-Javadoc)
 419      * @see org.eclipse.ui.part.WorkbenchPart#setFocus()
 420      */
 421     @Override
 422     public void setFocus() {
 423         fTimeGraphCombo.setFocus();
 424     }
 425
 426     // ------------------------------------------------------------------------
 427     // Signal handlers
 428     // ------------------------------------------------------------------------
 429
 430     @TmfSignalHandler
 431     public void experimentSelected(final TmfExperimentSelectedSignal<? extends ITmfEvent> signal) {
 432         if (signal.getExperiment().equals(fSelectedExperiment)) {
 433             return;
 434         }
 435
 436         final Thread thread = new Thread("ControlFlowView build") { //$NON-NLS-1$
 437             @Override
 438             public void run() {
 439                 selectExperiment(signal.getExperiment());
 440             }};
 441         thread.start();
 442     }
 443
 444     @TmfSignalHandler
 445     public void synchToTime(final TmfTimeSynchSignal signal) {
 446         if (signal.getSource() == this) {
 447             return;
 448         }
 449         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 450         Display.getDefault().asyncExec(new Runnable() {
 451             @Override
 452             public void run() {
 453                 if (fTimeGraphCombo.isDisposed()) {
 454                     return;
 455                 }
 456                 fTimeGraphCombo.getTimeGraphViewer().setSelectedTime(time, true);
 457             }
 458         });
 459     }
 460
 461     @TmfSignalHandler
 462     public void synchToRange(final TmfRangeSynchSignal signal) {
 463         if (signal.getSource() == this) {
 464             return;
 465         }
 466         final long startTime = signal.getCurrentRange().getStartTime().normalize(0, -9).getValue();
 467         final long endTime = signal.getCurrentRange().getEndTime().normalize(0, -9).getValue();
 468         final long time = signal.getCurrentTime().normalize(0, -9).getValue();
 469         Display.getDefault().asyncExec(new Runnable() {
 470             @Override
 471             public void run() {
 472                 if (fTimeGraphCombo.isDisposed()) {
 473                     return;
 474                 }
 475                 fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(startTime, endTime);
 476                 fTimeGraphCombo.getTimeGraphViewer().setSelectedTime(time, false);
 477                 startZoomThread(startTime, endTime);
 478             }
 479         });
 480     }
 481
 482     // ------------------------------------------------------------------------
 483     // Internal
 484     // ------------------------------------------------------------------------
 485
 486     @SuppressWarnings("unchecked")
 487     private void selectExperiment(TmfExperiment<?> experiment) {
 488         fStartTime = Long.MAX_VALUE;
 489         fEndTime = Long.MIN_VALUE;
 490         fSelectedExperiment = (TmfExperiment<ITmfEvent>) experiment;
 491         fEntryList = new ArrayList<ControlFlowEntry>();
 492         for (ITmfTrace<?> trace : experiment.getTraces()) {
 493             if (trace instanceof CtfKernelTrace) {
 494                 CtfKernelTrace ctfKernelTrace = (CtfKernelTrace) trace;
 495                 IStateSystemQuerier ssq = ctfKernelTrace.getStateSystem();
 496                 long start = ssq.getStartTime();
 497                 long end = ssq.getCurrentEndTime();
 498                 fStartTime = Math.min(fStartTime, start);
 499                 fEndTime = Math.max(fEndTime, end);
 500                 List<Integer> threadQuarks = ssq.getQuarks(Attributes.THREADS, "*"); //$NON-NLS-1$
 501                 for (int threadQuark : threadQuarks) {
 502                     String threadName = ssq.getAttributeName(threadQuark);
 503                     int threadId = -1;
 504                     try {
 505                         threadId = Integer.parseInt(threadName);
 506                     } catch (NumberFormatException e1) {
 507                         continue;
 508                     }
 509                     if (threadId == 0) { // ignore the swapper thread
 510                         continue;
 511                     }
 512                     int execNameQuark = -1;
 513                     try {
 514                         try {
 515                             execNameQuark = ssq.getQuarkRelative(threadQuark, Attributes.EXEC_NAME);
 516                         } catch (AttributeNotFoundException e) {
 517                             continue;
 518                         }
 519                         int ppidQuark = ssq.getQuarkRelative(threadQuark, Attributes.PPID);
 520                         List<ITmfStateInterval> execNameIntervals = ssq.queryHistoryRange(execNameQuark, start, end);
 521                         long birthTime = -1;
 522                         for (ITmfStateInterval execNameInterval : execNameIntervals) {
 523                             if (!execNameInterval.getStateValue().isNull() && execNameInterval.getStateValue().getType() == 1) {
 524                                 String execName = execNameInterval.getStateValue().unboxStr();
 525                                 long startTime = execNameInterval.getStartTime();
 526                                 long endTime = execNameInterval.getEndTime() + 1;
 527                                 if (birthTime == -1) {
 528                                     birthTime = startTime;
 529                                 }
 530                                 int ppid = -1;
 531                                 if (ppidQuark != -1) {
 532                                     ITmfStateInterval ppidInterval = ssq.querySingleState(startTime, ppidQuark);
 533                                     ppid = ppidInterval.getStateValue().unboxInt();
 534                                 }
 535                                 ControlFlowEntry entry = new ControlFlowEntry(threadQuark, ctfKernelTrace, execName, threadId, ppid, birthTime, startTime, endTime);
 536                                 fEntryList.add(entry);
 537                                 entry.addEvent(new TimeEvent(entry, startTime, endTime - startTime));
 538                             } else {
 539                                 birthTime = -1;
 540                             }
 541                         }
 542                     } catch (AttributeNotFoundException e) {
 543                         e.printStackTrace();
 544                     } catch (TimeRangeException e) {
 545                         e.printStackTrace();
 546                     } catch (StateValueTypeException e) {
 547                         e.printStackTrace();
 548                     }
 549                 }
 550             }
 551             buildTree();
 552             refresh(INITIAL_WINDOW_OFFSET);
 553             ControlFlowEntry[] entries = fEntryList.toArray(new ControlFlowEntry[0]);
 554             Arrays.sort(entries);
 555             for (ControlFlowEntry entry : entries) {
 556                 buildStatusEvents(entry);
 557             }
 558         }
 559     }
 560
 561     private void buildTree() {
 562         ArrayList<ControlFlowEntry> rootList = new ArrayList<ControlFlowEntry>();
 563         for (ControlFlowEntry entry : fEntryList) {
 564             boolean root = true;
 565             if (entry.getPPID() > 0) {
 566                 for (ControlFlowEntry parent : fEntryList) {
 567                     if (parent.getThreadId() == entry.getPPID() &&
 568                             entry.getStartTime() >= parent.getStartTime() &&
 569                             entry.getStartTime() <= parent.getEndTime()) {
 570                         parent.addChild(entry);
 571                         root = false;
 572                         break;
 573                     }
 574                 }
 575             }
 576             if (root) {
 577                 rootList.add(entry);
 578             }
 579         }
 580         fEntryList = rootList;
 581     }
 582
 583     private void buildStatusEvents(ControlFlowEntry entry) {
 584         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 585         long start = ssq.getStartTime();
 586         long end = ssq.getCurrentEndTime();
 587         long resolution = Math.max(1, (end - start) / fDisplayWidth);
 588         List<ITimeEvent> eventList = getEventList(entry, entry.getStartTime(), entry.getEndTime(), resolution);
 589         entry.setEventList(eventList);
 590         redraw();
 591         for (ITimeGraphEntry child : entry.getChildren()) {
 592             buildStatusEvents((ControlFlowEntry) child);
 593         }
 594     }
 595
 596     private List<ITimeEvent> getEventList(ControlFlowEntry entry, long startTime, long endTime, long resolution) {
 597         startTime = Math.max(startTime, entry.getStartTime());
 598         endTime = Math.min(endTime, entry.getEndTime());
 599         if (endTime <= startTime) {
 600             return null;
 601         }
 602         IStateSystemQuerier ssq = entry.getTrace().getStateSystem();
 603         List<ITimeEvent> eventList = null;
 604         try {
 605             int statusQuark = ssq.getQuarkRelative(entry.getThreadQuark(), Attributes.STATUS);
 606             List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, startTime, endTime - 1, resolution);
 607             eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 608             long lastEndTime = -1;
 609             for (ITmfStateInterval statusInterval : statusIntervals) {
 610                 long time = statusInterval.getStartTime();
 611                 long duration = statusInterval.getEndTime() - time + 1;
 612                 int status = -1;
 613                 try {
 614                     status = statusInterval.getStateValue().unboxInt();
 615                 } catch (StateValueTypeException e) {
 616                     e.printStackTrace();
 617                 }
 618                 if (lastEndTime != time && lastEndTime != -1) {
 619                     eventList.add(new ControlFlowEvent(entry, lastEndTime, time - lastEndTime, 0));
 620                 }
 621                 eventList.add(new ControlFlowEvent(entry, time, duration, status));
 622                 lastEndTime = time + duration;
 623             }
 624         } catch (AttributeNotFoundException e) {
 625             e.printStackTrace();
 626         } catch (TimeRangeException e) {
 627             e.printStackTrace();
 628         }
 629         return eventList;
 630     }
 631
 632     private void refresh(final long windowRange) {
 633         Display.getDefault().asyncExec(new Runnable() {
 634             @Override
 635             public void run() {
 636                 if (fTimeGraphCombo.isDisposed()) {
 637                     return;
 638                 }
 639                 ITimeGraphEntry[] entries = fEntryList.toArray(new ITimeGraphEntry[0]);
 640                 Arrays.sort(entries);
 641                 fTimeGraphCombo.setInput(entries);
 642                 fTimeGraphCombo.getTimeGraphViewer().setTimeBounds(fStartTime, fEndTime);
 643
 644                 long endTime = fStartTime + windowRange;
 645
 646                 if (fEndTime < endTime) {
 647                     endTime = fEndTime;
 648                 }
 649                 fTimeGraphCombo.getTimeGraphViewer().setStartFinishTime(fStartTime, endTime);
 650                 for (TreeColumn column : fTimeGraphCombo.getTreeViewer().getTree().getColumns()) {
 651                     column.pack();
 652                 }
 653
 654                 startZoomThread(fStartTime, endTime);
 655             }
 656         });
 657     }
 658
 659     private void redraw() {
 660         Display.getDefault().asyncExec(new Runnable() {
 661             @Override
 662             public void run() {
 663                 if (fTimeGraphCombo.isDisposed()) {
 664                     return;
 665                 }
 666                 fTimeGraphCombo.redraw();
 667                 fTimeGraphCombo.update();
 668             }
 669         });
 670     }
 671
 672     private void startZoomThread(long startTime, long endTime) {
 673         if (fZoomThread != null) {
 674             fZoomThread.cancel();
 675         }
 676         fZoomThread = new ZoomThread(startTime, endTime);
 677         fZoomThread.start();
 678     }
 679
 680     private void makeActions() {
 681         fPreviousResourceAction = fTimeGraphCombo.getTimeGraphViewer().getPreviousItemAction();
 682         fPreviousResourceAction.setText(Messages.ControlFlowView_previousProcessActionNameText);
 683         fPreviousResourceAction.setToolTipText(Messages.ControlFlowView_previousProcessActionToolTipText);
 684         fNextResourceAction = fTimeGraphCombo.getTimeGraphViewer().getNextItemAction();
 685         fNextResourceAction.setText(Messages.ControlFlowView_nextProcessActionNameText);
 686         fNextResourceAction.setToolTipText(Messages.ControlFlowView_nextProcessActionToolTipText);
 687     }
 688
 689     private void contributeToActionBars() {
 690         IActionBars bars = getViewSite().getActionBars();
 691         fillLocalToolBar(bars.getToolBarManager());
 692     }
 693
 694     private void fillLocalToolBar(IToolBarManager manager) {
 695         manager.add(fTimeGraphCombo.getTimeGraphViewer().getShowLegendAction());
 696         manager.add(new Separator());
 697         manager.add(fTimeGraphCombo.getTimeGraphViewer().getResetScaleAction());
 698         manager.add(fTimeGraphCombo.getTimeGraphViewer().getPreviousEventAction());
 699         manager.add(fTimeGraphCombo.getTimeGraphViewer().getNextEventAction());
 700         manager.add(fPreviousResourceAction);
 701         manager.add(fNextResourceAction);
 702         manager.add(fTimeGraphCombo.getTimeGraphViewer().getZoomInAction());
 703         manager.add(fTimeGraphCombo.getTimeGraphViewer().getZoomOutAction());
 704         manager.add(new Separator());
 705     }
 706 }