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

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Ericsson, École Polytechnique de Montréal
   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  *   Geneviève Bastien - Move code to provide base classes for time graph view
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.internal.lttng2.kernel.ui.views.controlflow;
  15
  16 import java.util.ArrayList;
  17 import java.util.Collections;
  18 import java.util.Comparator;
  19 import java.util.List;
  20
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.jface.action.IToolBarManager;
  23 import org.eclipse.jface.dialogs.IDialogSettings;
  24 import org.eclipse.linuxtools.internal.lttng2.kernel.core.Attributes;
  25 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Activator;
  26 import org.eclipse.linuxtools.internal.lttng2.kernel.ui.Messages;
  27 import org.eclipse.linuxtools.lttng2.kernel.core.trace.LttngKernelTrace;
  28 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  29 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  30 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  31 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  32 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  33 import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
  34 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
  35 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
  36 import org.eclipse.linuxtools.tmf.core.trace.TmfTraceManager;
  37 import org.eclipse.linuxtools.tmf.ui.views.timegraph.AbstractTimeGraphView;
  38 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ILinkEvent;
  39 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeEvent;
  40 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  41 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeEvent;
  42 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
  43 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.model.TimeLinkEvent;
  44 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils;
  45 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.Resolution;
  46 import org.eclipse.linuxtools.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
  47
  48 /**
  49  * The Control Flow view main object
  50  *
  51  */
  52 public class ControlFlowView extends AbstractTimeGraphView {
  53
  54     // ------------------------------------------------------------------------
  55     // Constants
  56     // ------------------------------------------------------------------------
  57
  58     /**
  59      * View ID.
  60      */
  61     public static final String ID = "org.eclipse.linuxtools.lttng2.kernel.ui.views.controlflow"; //$NON-NLS-1$
  62
  63     private static final String PROCESS_COLUMN = Messages.ControlFlowView_processColumn;
  64     private static final String TID_COLUMN = Messages.ControlFlowView_tidColumn;
  65     private static final String PTID_COLUMN = Messages.ControlFlowView_ptidColumn;
  66     private static final String BIRTH_TIME_COLUMN = Messages.ControlFlowView_birthTimeColumn;
  67     private static final String TRACE_COLUMN = Messages.ControlFlowView_traceColumn;
  68
  69     private static final String[] COLUMN_NAMES = new String[] {
  70             PROCESS_COLUMN,
  71             TID_COLUMN,
  72             PTID_COLUMN,
  73             BIRTH_TIME_COLUMN,
  74             TRACE_COLUMN
  75     };
  76
  77     private static final String[] FILTER_COLUMN_NAMES = new String[] {
  78             PROCESS_COLUMN,
  79             TID_COLUMN
  80     };
  81
  82     // ------------------------------------------------------------------------
  83     // Constructors
  84     // ------------------------------------------------------------------------
  85
  86     /**
  87      * Constructor
  88      */
  89     public ControlFlowView() {
  90         super(ID, new ControlFlowPresentationProvider());
  91         setTreeColumns(COLUMN_NAMES);
  92         setTreeLabelProvider(new ControlFlowTreeLabelProvider());
  93         setFilterColumns(FILTER_COLUMN_NAMES);
  94         setEntryComparator(new ControlFlowEntryComparator());
  95     }
  96
  97     @Override
  98     protected void fillLocalToolBar(IToolBarManager manager) {
  99         super.fillLocalToolBar(manager);
 100         IDialogSettings settings = Activator.getDefault().getDialogSettings();
 101         IDialogSettings section = settings.getSection(getClass().getName());
 102         if (section == null) {
 103             section = settings.addNewSection(getClass().getName());
 104         }
 105         manager.add(getTimeGraphCombo().getTimeGraphViewer().getHideArrowsAction(section));
 106         manager.add(getTimeGraphCombo().getTimeGraphViewer().getFollowArrowBwdAction());
 107         manager.add(getTimeGraphCombo().getTimeGraphViewer().getFollowArrowFwdAction());
 108     }
 109
 110     @Override
 111     protected String getNextText() {
 112         return Messages.ControlFlowView_nextProcessActionNameText;
 113     }
 114
 115     @Override
 116     protected String getNextTooltip() {
 117         return Messages.ControlFlowView_nextProcessActionToolTipText;
 118     }
 119
 120     @Override
 121     protected String getPrevText() {
 122         return Messages.ControlFlowView_previousProcessActionNameText;
 123     }
 124
 125     @Override
 126     protected String getPrevTooltip() {
 127         return Messages.ControlFlowView_previousProcessActionToolTipText;
 128     }
 129
 130     private static class ControlFlowEntryComparator implements Comparator<ITimeGraphEntry> {
 131
 132         @Override
 133         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 134
 135             int result = 0;
 136
 137             if ((o1 instanceof ControlFlowEntry) && (o2 instanceof ControlFlowEntry)) {
 138                 ControlFlowEntry entry1 = (ControlFlowEntry) o1;
 139                 ControlFlowEntry entry2 = (ControlFlowEntry) o2;
 140                 result = entry1.getTrace().getStartTime().compareTo(entry2.getTrace().getStartTime());
 141                 if (result == 0) {
 142                     result = entry1.getTrace().getName().compareTo(entry2.getTrace().getName());
 143                 }
 144                 if (result == 0) {
 145                     result = entry1.getThreadId() < entry2.getThreadId() ? -1 : entry1.getThreadId() > entry2.getThreadId() ? 1 : 0;
 146                 }
 147             }
 148
 149             if (result == 0) {
 150                 result = o1.getStartTime() < o2.getStartTime() ? -1 : o1.getStartTime() > o2.getStartTime() ? 1 : 0;
 151             }
 152
 153             return result;
 154         }
 155     }
 156
 157     /**
 158      * @author gbastien
 159      *
 160      */
 161     protected static class ControlFlowTreeLabelProvider extends TreeLabelProvider {
 162
 163         @Override
 164         public String getColumnText(Object element, int columnIndex) {
 165             ControlFlowEntry entry = (ControlFlowEntry) element;
 166
 167             if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_processColumn)) {
 168                 return entry.getName();
 169             } else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_tidColumn)) {
 170                 return Integer.toString(entry.getThreadId());
 171             } else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_ptidColumn)) {
 172                 if (entry.getParentThreadId() > 0) {
 173                     return Integer.toString(entry.getParentThreadId());
 174                 }
 175             } else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_birthTimeColumn)) {
 176                 return Utils.formatTime(entry.getStartTime(), TimeFormat.CALENDAR, Resolution.NANOSEC);
 177             } else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_traceColumn)) {
 178                 return entry.getTrace().getName();
 179             }
 180             return ""; //$NON-NLS-1$
 181         }
 182
 183     }
 184
 185     // ------------------------------------------------------------------------
 186     // Internal
 187     // ------------------------------------------------------------------------
 188
 189     @Override
 190     protected void buildEventList(final ITmfTrace trace, IProgressMonitor monitor) {
 191         setStartTime(Long.MAX_VALUE);
 192         setEndTime(Long.MIN_VALUE);
 193
 194         ArrayList<TimeGraphEntry> rootList = new ArrayList<TimeGraphEntry>();
 195         for (ITmfTrace aTrace : fTraceManager.getActiveTraceSet()) {
 196             if (monitor.isCanceled()) {
 197                 return;
 198             }
 199             if (aTrace instanceof LttngKernelTrace) {
 200                 ArrayList<TimeGraphEntry> entryList = new ArrayList<TimeGraphEntry>();
 201                 LttngKernelTrace ctfKernelTrace = (LttngKernelTrace) aTrace;
 202                 ITmfStateSystem ssq = ctfKernelTrace.getStateSystems().get(LttngKernelTrace.STATE_ID);
 203                 if (!ssq.waitUntilBuilt()) {
 204                     return;
 205                 }
 206                 long start = ssq.getStartTime();
 207                 long end = ssq.getCurrentEndTime() + 1;
 208                 setStartTime(Math.min(getStartTime(), start));
 209                 setEndTime(Math.max(getEndTime(), end));
 210                 List<Integer> threadQuarks = ssq.getQuarks(Attributes.THREADS, "*"); //$NON-NLS-1$
 211                 for (int threadQuark : threadQuarks) {
 212                     if (monitor.isCanceled()) {
 213                         return;
 214                     }
 215                     String threadName = ssq.getAttributeName(threadQuark);
 216                     int threadId = -1;
 217                     try {
 218                         threadId = Integer.parseInt(threadName);
 219                     } catch (NumberFormatException e1) {
 220                         continue;
 221                     }
 222                     if (threadId == 0) { // ignore the swapper thread
 223                         continue;
 224                     }
 225                     int execNameQuark = -1;
 226                     try {
 227                         try {
 228                             execNameQuark = ssq.getQuarkRelative(threadQuark, Attributes.EXEC_NAME);
 229                         } catch (AttributeNotFoundException e) {
 230                             continue;
 231                         }
 232                         int ppidQuark = ssq.getQuarkRelative(threadQuark, Attributes.PPID);
 233                         List<ITmfStateInterval> execNameIntervals = ssq.queryHistoryRange(execNameQuark, start, end - 1);
 234                         // use monitor when available in api
 235                         if (monitor.isCanceled()) {
 236                             return;
 237                         }
 238                         TimeGraphEntry entry = null;
 239                         for (ITmfStateInterval execNameInterval : execNameIntervals) {
 240                             if (monitor.isCanceled()) {
 241                                 return;
 242                             }
 243                             if (!execNameInterval.getStateValue().isNull() &&
 244                                     execNameInterval.getStateValue().getType() == ITmfStateValue.Type.STRING) {
 245                                 String execName = execNameInterval.getStateValue().unboxStr();
 246                                 long startTime = execNameInterval.getStartTime();
 247                                 long endTime = execNameInterval.getEndTime() + 1;
 248                                 int ppid = -1;
 249                                 if (ppidQuark != -1) {
 250                                     ITmfStateInterval ppidInterval = ssq.querySingleState(startTime, ppidQuark);
 251                                     ppid = ppidInterval.getStateValue().unboxInt();
 252                                 }
 253                                 if (entry == null) {
 254                                     entry = new ControlFlowEntry(threadQuark, ctfKernelTrace, execName, threadId, ppid, startTime, endTime);
 255                                     entryList.add(entry);
 256                                 } else {
 257                                     // update the name of the entry to the
 258                                     // latest execName
 259                                     entry.setName(execName);
 260                                 }
 261                                 entry.addEvent(new TimeEvent(entry, startTime, endTime - startTime));
 262                             } else {
 263                                 entry = null;
 264                             }
 265                         }
 266                     } catch (AttributeNotFoundException e) {
 267                         e.printStackTrace();
 268                     } catch (TimeRangeException e) {
 269                         e.printStackTrace();
 270                     } catch (StateValueTypeException e) {
 271                         e.printStackTrace();
 272                     } catch (StateSystemDisposedException e) {
 273                         /* Ignored */
 274                     }
 275                 }
 276                 buildTree(entryList, rootList);
 277             }
 278             Collections.sort(rootList, getEntryComparator());
 279             putEntryList(trace, (ArrayList<TimeGraphEntry>) rootList.clone());
 280
 281             if (trace.equals(getTrace())) {
 282                 refresh();
 283             }
 284         }
 285         for (TimeGraphEntry entry : rootList) {
 286             if (monitor.isCanceled()) {
 287                 return;
 288             }
 289             buildStatusEvents(trace, entry, monitor);
 290         }
 291     }
 292
 293     private static void buildTree(ArrayList<TimeGraphEntry> entryList,
 294             ArrayList<TimeGraphEntry> rootList) {
 295         for (TimeGraphEntry listentry : entryList) {
 296             ControlFlowEntry entry = (ControlFlowEntry) listentry;
 297             boolean root = true;
 298             if (entry.getParentThreadId() > 0) {
 299                 for (TimeGraphEntry parententry : entryList) {
 300                     ControlFlowEntry parent = (ControlFlowEntry) parententry;
 301                     if (parent.getThreadId() == entry.getParentThreadId() &&
 302                             entry.getStartTime() >= parent.getStartTime() &&
 303                             entry.getStartTime() <= parent.getEndTime()) {
 304                         parent.addChild(entry);
 305                         root = false;
 306                         break;
 307                     }
 308                 }
 309             }
 310             if (root) {
 311                 rootList.add(entry);
 312             }
 313         }
 314     }
 315
 316     private void buildStatusEvents(ITmfTrace trace, TimeGraphEntry entry, IProgressMonitor monitor) {
 317         ITmfStateSystem ssq = entry.getTrace().getStateSystems().get(LttngKernelTrace.STATE_ID);
 318
 319         long start = ssq.getStartTime();
 320         long end = ssq.getCurrentEndTime() + 1;
 321         long resolution = Math.max(1, (end - start) / getDisplayWidth());
 322         List<ITimeEvent> eventList = getEventList(entry, entry.getStartTime(), entry.getEndTime(), resolution, monitor);
 323         if (monitor.isCanceled()) {
 324             return;
 325         }
 326         entry.setEventList(eventList);
 327         if (trace.equals(getTrace())) {
 328             redraw();
 329         }
 330         for (ITimeGraphEntry child : entry.getChildren()) {
 331             if (monitor.isCanceled()) {
 332                 return;
 333             }
 334             buildStatusEvents(trace, (TimeGraphEntry) child, monitor);
 335         }
 336     }
 337
 338     @Override
 339     protected List<ITimeEvent> getEventList(TimeGraphEntry tgentry, long startTime, long endTime, long resolution, IProgressMonitor monitor) {
 340         List<ITimeEvent> eventList = null;
 341         if (!(tgentry instanceof ControlFlowEntry)) {
 342             return eventList;
 343         }
 344         ControlFlowEntry entry = (ControlFlowEntry) tgentry;
 345         final long realStart = Math.max(startTime, entry.getStartTime());
 346         final long realEnd = Math.min(endTime, entry.getEndTime());
 347         if (realEnd <= realStart) {
 348             return null;
 349         }
 350         ITmfStateSystem ssq = entry.getTrace().getStateSystems().get(LttngKernelTrace.STATE_ID);
 351         try {
 352             int statusQuark = ssq.getQuarkRelative(entry.getThreadQuark(), Attributes.STATUS);
 353             List<ITmfStateInterval> statusIntervals = ssq.queryHistoryRange(statusQuark, realStart, realEnd - 1, resolution, monitor);
 354             eventList = new ArrayList<ITimeEvent>(statusIntervals.size());
 355             long lastEndTime = -1;
 356             for (ITmfStateInterval statusInterval : statusIntervals) {
 357                 if (monitor.isCanceled()) {
 358                     return null;
 359                 }
 360                 long time = statusInterval.getStartTime();
 361                 long duration = statusInterval.getEndTime() - time + 1;
 362                 int status = -1;
 363                 try {
 364                     status = statusInterval.getStateValue().unboxInt();
 365                 } catch (StateValueTypeException e) {
 366                     e.printStackTrace();
 367                 }
 368                 if (lastEndTime != time && lastEndTime != -1) {
 369                     eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 370                 }
 371                 eventList.add(new TimeEvent(entry, time, duration, status));
 372                 lastEndTime = time + duration;
 373             }
 374         } catch (AttributeNotFoundException e) {
 375             e.printStackTrace();
 376         } catch (TimeRangeException e) {
 377             e.printStackTrace();
 378         } catch (StateSystemDisposedException e) {
 379             /* Ignored */
 380         }
 381         return eventList;
 382     }
 383
 384     /**
 385      * Returns a value corresponding to the selected entry.
 386      *
 387      * Used in conjunction with selectEntry to change the selected entry. If one
 388      * of these methods is overridden in child class, then both should be.
 389      *
 390      * @param time
 391      *            The currently selected time
 392      * @return a value identifying the entry
 393      */
 394     private int getSelectionValue(long time) {
 395         int thread = -1;
 396         for (ITmfTrace trace : fTraceManager.getActiveTraceSet()) {
 397             if (thread > 0) {
 398                 break;
 399             }
 400             if (trace instanceof LttngKernelTrace) {
 401                 LttngKernelTrace ctfKernelTrace = (LttngKernelTrace) trace;
 402                 ITmfStateSystem ssq = ctfKernelTrace.getStateSystems().get(LttngKernelTrace.STATE_ID);
 403                 if (time >= ssq.getStartTime() && time <= ssq.getCurrentEndTime()) {
 404                     List<Integer> currentThreadQuarks = ssq.getQuarks(Attributes.CPUS, "*", Attributes.CURRENT_THREAD); //$NON-NLS-1$
 405                     for (int currentThreadQuark : currentThreadQuarks) {
 406                         try {
 407                             ITmfStateInterval currentThreadInterval = ssq.querySingleState(time, currentThreadQuark);
 408                             int currentThread = currentThreadInterval.getStateValue().unboxInt();
 409                             if (currentThread > 0) {
 410                                 int statusQuark = ssq.getQuarkAbsolute(Attributes.THREADS, Integer.toString(currentThread), Attributes.STATUS);
 411                                 ITmfStateInterval statusInterval = ssq.querySingleState(time, statusQuark);
 412                                 if (statusInterval.getStartTime() == time) {
 413                                     thread = currentThread;
 414                                     break;
 415                                 }
 416                             }
 417                         } catch (AttributeNotFoundException e) {
 418                             e.printStackTrace();
 419                         } catch (TimeRangeException e) {
 420                             e.printStackTrace();
 421                         } catch (StateValueTypeException e) {
 422                             e.printStackTrace();
 423                         } catch (StateSystemDisposedException e) {
 424                             /* Ignored */
 425                         }
 426                     }
 427                 }
 428             }
 429         }
 430         return thread;
 431     }
 432
 433     @Override
 434     protected void synchingToTime(long time) {
 435         int selected = getSelectionValue(time);
 436         if (selected > 0) {
 437             for (Object element : getTimeGraphViewer().getExpandedElements()) {
 438                 if (element instanceof ControlFlowEntry) {
 439                     ControlFlowEntry entry = (ControlFlowEntry) element;
 440                     if (entry.getThreadId() == selected) {
 441                         getTimeGraphCombo().setSelection(entry);
 442                         break;
 443                     }
 444                 }
 445             }
 446         }
 447     }
 448
 449     @Override
 450     protected List<ILinkEvent> getLinkList(long startTime, long endTime, long resolution, IProgressMonitor monitor) {
 451         List<ILinkEvent> list = new ArrayList<ILinkEvent>();
 452         ITmfTrace[] traces = TmfTraceManager.getTraceSet(getTrace());
 453         List<TimeGraphEntry> entryList = getEntryListMap().get(getTrace());
 454         if (traces == null || entryList == null) {
 455             return list;
 456         }
 457         for (ITmfTrace trace : traces) {
 458             if (trace instanceof LttngKernelTrace) {
 459                 ITmfStateSystem ssq = trace.getStateSystems().get(LttngKernelTrace.STATE_ID);
 460                 try {
 461                     long start = Math.max(startTime, ssq.getStartTime());
 462                     long end = Math.min(endTime, ssq.getCurrentEndTime());
 463                     if (end < start) {
 464                         continue;
 465                     }
 466                     List<Integer> currentThreadQuarks = ssq.getQuarks(Attributes.CPUS, "*", Attributes.CURRENT_THREAD); //$NON-NLS-1$
 467                     for (int currentThreadQuark : currentThreadQuarks) {
 468                         List<ITmfStateInterval> currentThreadIntervals = ssq.queryHistoryRange(currentThreadQuark, start, end, resolution, monitor);
 469                         int prevThread = 0;
 470                         long prevEnd = 0;
 471                         for (ITmfStateInterval currentThreadInterval : currentThreadIntervals) {
 472                             if (monitor.isCanceled()) {
 473                                 return null;
 474                             }
 475                             long time = currentThreadInterval.getStartTime();
 476                             int thread = currentThreadInterval.getStateValue().unboxInt();
 477                             if (thread > 0 && prevThread > 0 && thread != prevThread && time == prevEnd) {
 478                                 ITimeGraphEntry prevEntry = findEntry(entryList, trace, prevThread);
 479                                 ITimeGraphEntry nextEntry = findEntry(entryList, trace, thread);
 480                                 list.add(new TimeLinkEvent(prevEntry, nextEntry, time, 0, 0));
 481                             }
 482                             prevThread = thread;
 483                             prevEnd = currentThreadInterval.getEndTime() + 1;
 484                         }
 485                     }
 486                 } catch (TimeRangeException e) {
 487                     e.printStackTrace();
 488                 } catch (AttributeNotFoundException e) {
 489                     e.printStackTrace();
 490                 } catch (StateValueTypeException e) {
 491                     e.printStackTrace();
 492                 } catch (StateSystemDisposedException e) {
 493                     /* Ignored */
 494                 }
 495             }
 496         }
 497         return list;
 498     }
 499
 500     private ControlFlowEntry findEntry(List<TimeGraphEntry> entryList, ITmfTrace trace, int threadId) {
 501         for (TimeGraphEntry entry : entryList) {
 502             if (entry instanceof ControlFlowEntry) {
 503                 ControlFlowEntry controlFlowEntry = (ControlFlowEntry) entry;
 504                 if (controlFlowEntry.getThreadId() == threadId && controlFlowEntry.getTrace() == trace) {
 505                     return controlFlowEntry;
 506                 } else if (entry.hasChildren()) {
 507                     controlFlowEntry = findEntry(entry.getChildren(), trace, threadId);
 508                     if (controlFlowEntry != null) {
 509                         return controlFlowEntry;
 510                     }
 511                 }
 512             }
 513         }
 514         return null;
 515     }
 516 }