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