tmf/org.eclipse.tracecompass.tmf.ui/src/org/eclipse/tracecompass/tmf/ui/views/callstack/CallStackView.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2015 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  *   Bernd Hufmann - Updated signal handling
  12  *   Marc-Andre Laperle - Map from binary file
  13  *******************************************************************************/
  14
  15 package org.eclipse.tracecompass.tmf.ui.views.callstack;
  16
  17 import java.io.File;
  18 import java.util.ArrayList;
  19 import java.util.Collections;
  20 import java.util.Comparator;
  21 import java.util.HashMap;
  22 import java.util.Iterator;
  23 import java.util.List;
  24 import java.util.Map;
  25
  26 import org.eclipse.core.runtime.IProgressMonitor;
  27 import org.eclipse.core.runtime.IStatus;
  28 import org.eclipse.core.runtime.Status;
  29 import org.eclipse.core.runtime.jobs.Job;
  30 import org.eclipse.jdt.annotation.NonNull;
  31 import org.eclipse.jdt.annotation.Nullable;
  32 import org.eclipse.jface.action.Action;
  33 import org.eclipse.jface.action.IAction;
  34 import org.eclipse.jface.action.IToolBarManager;
  35 import org.eclipse.jface.action.MenuManager;
  36 import org.eclipse.jface.action.Separator;
  37 import org.eclipse.jface.dialogs.IDialogSettings;
  38 import org.eclipse.jface.resource.ImageDescriptor;
  39 import org.eclipse.jface.util.IPropertyChangeListener;
  40 import org.eclipse.jface.util.PropertyChangeEvent;
  41 import org.eclipse.jface.viewers.DoubleClickEvent;
  42 import org.eclipse.jface.viewers.IDoubleClickListener;
  43 import org.eclipse.jface.viewers.ISelection;
  44 import org.eclipse.jface.viewers.IStructuredSelection;
  45 import org.eclipse.swt.SWT;
  46 import org.eclipse.swt.events.MouseAdapter;
  47 import org.eclipse.swt.events.MouseEvent;
  48 import org.eclipse.swt.graphics.Image;
  49 import org.eclipse.swt.widgets.Composite;
  50 import org.eclipse.swt.widgets.Display;
  51 import org.eclipse.swt.widgets.FileDialog;
  52 import org.eclipse.swt.widgets.Menu;
  53 import org.eclipse.swt.widgets.Tree;
  54 import org.eclipse.tracecompass.internal.tmf.core.callstack.FunctionNameMapper;
  55 import org.eclipse.tracecompass.internal.tmf.ui.Activator;
  56 import org.eclipse.tracecompass.internal.tmf.ui.ITmfImageConstants;
  57 import org.eclipse.tracecompass.internal.tmf.ui.Messages;
  58 import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
  59 import org.eclipse.tracecompass.statesystem.core.StateSystemUtils;
  60 import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
  61 import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
  62 import org.eclipse.tracecompass.statesystem.core.exceptions.StateValueTypeException;
  63 import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
  64 import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
  65 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
  66 import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue.Type;
  67 import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
  68 import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
  69 import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
  70 import org.eclipse.tracecompass.tmf.core.signal.TmfWindowRangeUpdatedSignal;
  71 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  72 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
  73 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  74 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  75 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestampDelta;
  76 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
  77 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
  78 import org.eclipse.tracecompass.tmf.ui.editors.ITmfTraceEditor;
  79 import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractTimeGraphView;
  80 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.ITimeGraphTimeListener;
  81 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphContentProvider;
  82 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphTimeEvent;
  83 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.TimeGraphViewer;
  84 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeEvent;
  85 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ITimeGraphEntry;
  86 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.NullTimeEvent;
  87 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
  88 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
  89 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphControl;
  90 import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphSelection;
  91 import org.eclipse.ui.IEditorPart;
  92
  93 /**
  94  * Main implementation for the Call Stack view
  95  *
  96  * @author Patrick Tasse
  97  */
  98 public class CallStackView extends AbstractTimeGraphView {
  99
 100     // ------------------------------------------------------------------------
 101     // Constants
 102     // ------------------------------------------------------------------------
 103
 104     /** View ID. */
 105     public static final String ID = "org.eclipse.linuxtools.tmf.ui.views.callstack"; //$NON-NLS-1$
 106
 107     private static final String[] COLUMN_NAMES = new String[] {
 108             Messages.CallStackView_FunctionColumn,
 109             Messages.CallStackView_DepthColumn,
 110             Messages.CallStackView_EntryTimeColumn,
 111             Messages.CallStackView_ExitTimeColumn,
 112             Messages.CallStackView_DurationColumn
 113     };
 114
 115     private static final String[] FILTER_COLUMN_NAMES = new String[] {
 116             Messages.CallStackView_ThreadColumn
 117     };
 118
 119     /** Timeout between updates in the build thread in ms */
 120     private static final long BUILD_UPDATE_TIMEOUT = 500;
 121
 122     // Fraction of a function duration to be added as spacing
 123     private static final double SPACING_RATIO = 0.01;
 124
 125     private static final Image THREAD_IMAGE = Activator.getDefault().getImageFromPath("icons/obj16/thread_obj.gif"); //$NON-NLS-1$
 126     private static final Image STACKFRAME_IMAGE = Activator.getDefault().getImageFromPath("icons/obj16/stckframe_obj.gif"); //$NON-NLS-1$
 127
 128     private static final String IMPORT_MAPPING_ICON_PATH = "icons/etool16/import.gif"; //$NON-NLS-1$
 129     private static final String IMPORT_BINARY_ICON_PATH = "icons/obj16/binaries_obj.gif"; //$NON-NLS-1$
 130
 131     private static final ImageDescriptor SORT_BY_NAME_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_alpha.gif"); //$NON-NLS-1$
 132     private static final ImageDescriptor SORT_BY_NAME_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_alpha_rev.gif"); //$NON-NLS-1$
 133     private static final ImageDescriptor SORT_BY_ID_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_num.gif"); //$NON-NLS-1$
 134     private static final ImageDescriptor SORT_BY_ID_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_num_rev.gif"); //$NON-NLS-1$
 135     private static final ImageDescriptor SORT_BY_TIME_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_time.gif"); //$NON-NLS-1$
 136     private static final ImageDescriptor SORT_BY_TIME_REV_ICON = Activator.getDefault().getImageDescripterFromPath("icons/etool16/sort_time_rev.gif"); //$NON-NLS-1$
 137     private static final String SORT_OPTION_KEY = "sort.option"; //$NON-NLS-1$
 138
 139     private enum SortOption {
 140         BY_NAME, BY_NAME_REV, BY_ID, BY_ID_REV, BY_TIME, BY_TIME_REV
 141     }
 142
 143     private @NonNull SortOption fSortOption = SortOption.BY_NAME;
 144     private @NonNull Comparator<ITimeGraphEntry> fThreadComparator = new ThreadNameComparator(false);
 145     private Action fSortByNameAction;
 146     private Action fSortByIdAction;
 147     private Action fSortByTimeAction;
 148
 149     // ------------------------------------------------------------------------
 150     // Fields
 151     // ------------------------------------------------------------------------
 152
 153     /** The map to map function addresses to function names */
 154     private Map<String, String> fNameMapping;
 155
 156     // The next event action
 157     private Action fNextEventAction;
 158
 159     // The previous event action
 160     private Action fPrevEventAction;
 161
 162     // The next item action
 163     private Action fNextItemAction;
 164
 165     // The previous item action
 166     private Action fPreviousItemAction;
 167
 168     // The action to import a function-name mapping file
 169     private Action fImportMappingAction;
 170
 171     // The action to import a binary file mapping */
 172     private Action fImportBinaryFileMappingAction;
 173
 174     // The saved time sync. signal used when switching off the pinning of a view
 175     private TmfSelectionRangeUpdatedSignal fSavedTimeSyncSignal;
 176
 177     // The saved window range signal used when switching off the pinning of
 178     // a view
 179     private TmfWindowRangeUpdatedSignal fSavedRangeSyncSignal;
 180
 181     // ------------------------------------------------------------------------
 182     // Classes
 183     // ------------------------------------------------------------------------
 184
 185     private static class TraceEntry extends TimeGraphEntry {
 186         public TraceEntry(String name, long startTime, long endTime) {
 187             super(name, startTime, endTime);
 188         }
 189
 190         @Override
 191         public boolean hasTimeEvents() {
 192             return false;
 193         }
 194     }
 195
 196     private static class ThreadEntry extends TimeGraphEntry {
 197         // The call stack quark
 198         private final int fCallStackQuark;
 199         // The state system from which this entry comes
 200         private final ITmfStateSystem fSS;
 201         // The thread id
 202         private final long fThreadId;
 203
 204         public ThreadEntry(ITmfStateSystem ss, String name, long threadId, int callStackQuark, long startTime, long endTime) {
 205             super(name, startTime, endTime);
 206             fCallStackQuark = callStackQuark;
 207             fThreadId = threadId;
 208             fSS = ss;
 209         }
 210
 211         @Override
 212         public boolean hasTimeEvents() {
 213             return false;
 214         }
 215
 216         public int getCallStackQuark() {
 217             return fCallStackQuark;
 218         }
 219
 220         public long getThreadId() {
 221             return fThreadId;
 222         }
 223
 224         @Nullable
 225         public ITmfStateSystem getStateSystem() {
 226             return fSS;
 227         }
 228     }
 229
 230     private class CallStackComparator implements Comparator<ITimeGraphEntry> {
 231         @Override
 232         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 233             if (o1 instanceof ThreadEntry && o2 instanceof ThreadEntry) {
 234                 return fThreadComparator.compare(o1, o2);
 235             }
 236             return 0;
 237         }
 238     }
 239
 240     private static class ThreadNameComparator implements Comparator<ITimeGraphEntry> {
 241         private boolean reverse;
 242
 243         public ThreadNameComparator(boolean reverse) {
 244             this.reverse = reverse;
 245         }
 246
 247         @Override
 248         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 249             return reverse ? o2.getName().compareTo(o1.getName()) :
 250                     o1.getName().compareTo(o2.getName());
 251         }
 252     }
 253
 254     private static class ThreadIdComparator implements Comparator<ITimeGraphEntry> {
 255         private boolean reverse;
 256
 257         public ThreadIdComparator(boolean reverse) {
 258             this.reverse = reverse;
 259         }
 260
 261         @Override
 262         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 263             ThreadEntry t1 = (ThreadEntry) o1;
 264             ThreadEntry t2 = (ThreadEntry) o2;
 265             return reverse ? Long.compare(t2.getThreadId(), t1.getThreadId()) :
 266                     Long.compare(t1.getThreadId(), t2.getThreadId());
 267         }
 268     }
 269
 270     private static class ThreadTimeComparator implements Comparator<ITimeGraphEntry> {
 271         private boolean reverse;
 272
 273         public ThreadTimeComparator(boolean reverse) {
 274             this.reverse = reverse;
 275         }
 276
 277         @Override
 278         public int compare(ITimeGraphEntry o1, ITimeGraphEntry o2) {
 279             return reverse ? Long.compare(o2.getStartTime(), o1.getStartTime()) :
 280                     Long.compare(o1.getStartTime(), o2.getStartTime());
 281         }
 282     }
 283
 284     private static class CallStackTreeLabelProvider extends TreeLabelProvider {
 285
 286         @Override
 287         public Image getColumnImage(Object element, int columnIndex) {
 288             if (columnIndex == 0) {
 289                 if (element instanceof ThreadEntry) {
 290                     return THREAD_IMAGE;
 291                 } else if (element instanceof CallStackEntry) {
 292                     CallStackEntry entry = (CallStackEntry) element;
 293                     if (entry.getFunctionName().length() > 0) {
 294                         return STACKFRAME_IMAGE;
 295                     }
 296                 }
 297             }
 298             return null;
 299         }
 300
 301         @Override
 302         public String getColumnText(Object element, int columnIndex) {
 303             if (element instanceof CallStackEntry) {
 304                 CallStackEntry entry = (CallStackEntry) element;
 305                 if (columnIndex == 0) {
 306                     return entry.getFunctionName();
 307                 } else if (columnIndex == 1 && entry.getFunctionName().length() > 0) {
 308                     int depth = entry.getStackLevel();
 309                     return Integer.toString(depth);
 310                 } else if (columnIndex == 2 && entry.getFunctionName().length() > 0) {
 311                     ITmfTimestamp ts = new TmfTimestamp(entry.getFunctionEntryTime(), ITmfTimestamp.NANOSECOND_SCALE);
 312                     return ts.toString();
 313                 } else if (columnIndex == 3 && entry.getFunctionName().length() > 0) {
 314                     ITmfTimestamp ts = new TmfTimestamp(entry.getFunctionExitTime(), ITmfTimestamp.NANOSECOND_SCALE);
 315                     return ts.toString();
 316                 } else if (columnIndex == 4 && entry.getFunctionName().length() > 0) {
 317                     ITmfTimestamp ts = new TmfTimestampDelta(entry.getFunctionExitTime() - entry.getFunctionEntryTime(), ITmfTimestamp.NANOSECOND_SCALE);
 318                     return ts.toString();
 319                 }
 320             } else if (element instanceof ITimeGraphEntry) {
 321                 if (columnIndex == 0) {
 322                     return ((ITimeGraphEntry) element).getName();
 323                 }
 324             }
 325             return ""; //$NON-NLS-1$
 326         }
 327
 328     }
 329
 330     private class CallStackFilterContentProvider extends TimeGraphContentProvider {
 331         @Override
 332         public boolean hasChildren(Object element) {
 333             if (element instanceof TraceEntry) {
 334                 return super.hasChildren(element);
 335             }
 336             return false;
 337         }
 338
 339         @Override
 340         public ITimeGraphEntry[] getChildren(Object parentElement) {
 341             if (parentElement instanceof TraceEntry) {
 342                 return super.getChildren(parentElement);
 343             }
 344             return new ITimeGraphEntry[0];
 345         }
 346     }
 347
 348     // ------------------------------------------------------------------------
 349     // Constructors
 350     // ------------------------------------------------------------------------
 351
 352     /**
 353      * Default constructor
 354      */
 355     public CallStackView() {
 356         super(ID, new CallStackPresentationProvider());
 357         ((CallStackPresentationProvider) getPresentationProvider()).setCallStackView(this);
 358         setTreeColumns(COLUMN_NAMES);
 359         setTreeLabelProvider(new CallStackTreeLabelProvider());
 360         setEntryComparator(new CallStackComparator());
 361         setFilterColumns(FILTER_COLUMN_NAMES);
 362         setFilterContentProvider(new CallStackFilterContentProvider());
 363         setFilterLabelProvider(new CallStackTreeLabelProvider());
 364     }
 365
 366     // ------------------------------------------------------------------------
 367     // ViewPart
 368     // ------------------------------------------------------------------------
 369
 370     @Override
 371     public void createPartControl(Composite parent) {
 372         super.createPartControl(parent);
 373
 374         getTimeGraphViewer().addTimeListener(new ITimeGraphTimeListener() {
 375             @Override
 376             public void timeSelected(TimeGraphTimeEvent event) {
 377                 synchingToTime(event.getBeginTime());
 378             }
 379         });
 380
 381         getTimeGraphCombo().getTreeViewer().addDoubleClickListener(new IDoubleClickListener() {
 382             @Override
 383             public void doubleClick(DoubleClickEvent event) {
 384                 Object selection = ((IStructuredSelection) event.getSelection()).getFirstElement();
 385                 if (selection instanceof CallStackEntry) {
 386                     CallStackEntry entry = (CallStackEntry) selection;
 387                     if (entry.getFunctionName().length() > 0) {
 388                         long entryTime = entry.getFunctionEntryTime();
 389                         long exitTime = entry.getFunctionExitTime();
 390                         long spacingTime = (long) ((exitTime - entryTime) * SPACING_RATIO);
 391                         entryTime -= spacingTime;
 392                         exitTime += spacingTime;
 393                         TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(entryTime), new TmfNanoTimestamp(exitTime));
 394                         broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
 395                         getTimeGraphViewer().setStartFinishTime(entryTime, exitTime);
 396                         startZoomThread(entryTime, exitTime);
 397                     }
 398                 }
 399             }
 400         });
 401
 402         getTimeGraphViewer().getTimeGraphControl().addMouseListener(new MouseAdapter() {
 403             @Override
 404             public void mouseDoubleClick(MouseEvent e) {
 405                 TimeGraphControl timeGraphControl = getTimeGraphViewer().getTimeGraphControl();
 406                 ISelection selection = timeGraphControl.getSelection();
 407                 if (selection instanceof TimeGraphSelection) {
 408                     Object o = ((TimeGraphSelection) selection).getFirstElement();
 409                     if (o instanceof CallStackEvent) {
 410                         CallStackEvent event = (CallStackEvent) o;
 411                         long startTime = event.getTime();
 412                         long endTime = startTime + event.getDuration();
 413                         long spacingTime = (long) ((endTime - startTime) * SPACING_RATIO);
 414                         startTime -= spacingTime;
 415                         endTime += spacingTime;
 416                         TmfTimeRange range = new TmfTimeRange(new TmfNanoTimestamp(startTime), new TmfNanoTimestamp(endTime));
 417                         broadcast(new TmfWindowRangeUpdatedSignal(CallStackView.this, range));
 418                         getTimeGraphViewer().setStartFinishTime(startTime, endTime);
 419                         startZoomThread(startTime, endTime);
 420                     }
 421                 }
 422             }
 423         });
 424
 425         contributeToActionBars();
 426         createContextMenu();
 427         loadSortOption();
 428
 429         IEditorPart editor = getSite().getPage().getActiveEditor();
 430         if (editor instanceof ITmfTraceEditor) {
 431             ITmfTrace trace = ((ITmfTraceEditor) editor).getTrace();
 432             if (trace != null) {
 433                 traceSelected(new TmfTraceSelectedSignal(this, trace));
 434             }
 435         }
 436     }
 437
 438     /**
 439      * Handler for the selection range signal.
 440      *
 441      * @param signal
 442      *            The incoming signal
 443      * @since 1.0
 444      */
 445     @Override
 446     @TmfSignalHandler
 447     public void selectionRangeUpdated(final TmfSelectionRangeUpdatedSignal signal) {
 448
 449         fSavedTimeSyncSignal = isPinned() ? new TmfSelectionRangeUpdatedSignal(signal.getSource(), signal.getBeginTime(), signal.getEndTime()) : null;
 450
 451         if (signal.getSource() == this || getTrace() == null || isPinned()) {
 452             return;
 453         }
 454         final long beginTime = signal.getBeginTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 455         final long endTime = signal.getEndTime().normalize(0, ITmfTimestamp.NANOSECOND_SCALE).getValue();
 456         Display.getDefault().asyncExec(new Runnable() {
 457             @Override
 458             public void run() {
 459                 if (getTimeGraphCombo().isDisposed()) {
 460                     return;
 461                 }
 462                 if (beginTime == endTime) {
 463                     getTimeGraphViewer().setSelectedTime(beginTime, true);
 464                 } else {
 465                     getTimeGraphViewer().setSelectionRange(beginTime, endTime, true);
 466                 }
 467                 synchingToTime(beginTime);
 468                 startZoomThread(getTimeGraphViewer().getTime0(), getTimeGraphViewer().getTime1());
 469                 List<TimeGraphEntry> entryList = getEntryList(getTrace());
 470                 if (entryList == null) {
 471                     return;
 472                 }
 473                 TimeGraphViewer viewer = getTimeGraphViewer();
 474                 for (TimeGraphEntry traceEntry : entryList) {
 475                     for (ITimeGraphEntry child : traceEntry.getChildren()) {
 476                         ThreadEntry threadEntry = (ThreadEntry) child;
 477                         ITmfStateSystem ss = threadEntry.getStateSystem();
 478                         if (ss == null || beginTime < ss.getStartTime() || beginTime > ss.getCurrentEndTime()) {
 479                             continue;
 480                         }
 481                         try {
 482                             int quark = threadEntry.getCallStackQuark();
 483                             ITmfStateInterval stackInterval = ss.querySingleState(beginTime, quark);
 484                             if (beginTime == stackInterval.getStartTime()) {
 485                                 int stackLevel = stackInterval.getStateValue().unboxInt();
 486                                 ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 487                                 getTimeGraphCombo().setSelection(selectedEntry);
 488                                 viewer.getTimeGraphControl().fireSelectionChanged();
 489                                 break;
 490                             }
 491                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 492                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 493                         }
 494                     }
 495                 }
 496             }
 497         });
 498     }
 499
 500     // ------------------------------------------------------------------------
 501     // Internal
 502     // ------------------------------------------------------------------------
 503
 504     @Override
 505     protected void buildEventList(final ITmfTrace trace, final ITmfTrace parentTrace, final IProgressMonitor monitor) {
 506         if (monitor.isCanceled()) {
 507             return;
 508         }
 509         AbstractCallStackAnalysis module = getCallStackModule(trace);
 510         if (module == null) {
 511             addUnavailableEntry(trace, parentTrace);
 512             return;
 513         }
 514         ITmfStateSystem ss = module.getStateSystem();
 515         if (ss == null) {
 516             addUnavailableEntry(trace, parentTrace);
 517             return;
 518         }
 519
 520         Map<ITmfTrace, TraceEntry> traceEntryMap = new HashMap<>();
 521         Map<Integer, ThreadEntry> threadEntryMap = new HashMap<>();
 522         String[] threadPaths = module.getThreadsPattern();
 523
 524         long start = ss.getStartTime();
 525
 526         boolean complete = false;
 527         while (!complete) {
 528             if (monitor.isCanceled()) {
 529                 return;
 530             }
 531             complete = ss.waitUntilBuilt(BUILD_UPDATE_TIMEOUT);
 532             if (ss.isCancelled()) {
 533                 return;
 534             }
 535             long end = ss.getCurrentEndTime();
 536             if (start == end && !complete) { // when complete execute one last time regardless of end time
 537                 continue;
 538             }
 539             List<Integer> threadQuarks = ss.getQuarks(threadPaths);
 540             TraceEntry traceEntry = traceEntryMap.get(trace);
 541             if (traceEntry == null) {
 542                 traceEntry = new TraceEntry(trace.getName(), start, end + 1);
 543                 traceEntryMap.put(trace, traceEntry);
 544                 traceEntry.sortChildren(fThreadComparator);
 545                 addToEntryList(parentTrace, Collections.singletonList(traceEntry));
 546             } else {
 547                 traceEntry.updateEndTime(end);
 548             }
 549             for (int i = 0; i < threadQuarks.size(); i++) {
 550                 if (monitor.isCanceled()) {
 551                     return;
 552                 }
 553                 int threadQuark = threadQuarks.get(i);
 554                 try {
 555                     String[] callStackPath = module.getCallStackPath();
 556                     int callStackQuark = ss.getQuarkRelative(threadQuark, callStackPath);
 557                     String threadName = ss.getAttributeName(threadQuark);
 558                     long threadEnd = end + 1;
 559                     ITmfStateInterval endInterval = ss.querySingleState(ss.getCurrentEndTime(), callStackQuark);
 560                     if (endInterval.getStateValue().isNull() && endInterval.getStartTime() != ss.getStartTime()) {
 561                         threadEnd = endInterval.getStartTime();
 562                     }
 563                     ThreadEntry threadEntry = threadEntryMap.get(threadQuark);
 564                     if (threadEntry == null) {
 565                         long threadId = ss.querySingleState(ss.getCurrentEndTime(), threadQuark).getStateValue().unboxLong();
 566                         long threadStart = start;
 567                         ITmfStateInterval startInterval = ss.querySingleState(start, callStackQuark);
 568                         if (startInterval.getStateValue().isNull()) {
 569                             threadStart = Math.min(startInterval.getEndTime() + 1, end + 1);
 570                         }
 571                         threadEntry = new ThreadEntry(ss, threadName, threadId, callStackQuark, threadStart, threadEnd);
 572                         threadEntryMap.put(threadQuark, threadEntry);
 573                         traceEntry.addChild(threadEntry);
 574                     } else {
 575                         threadEntry.updateEndTime(threadEnd);
 576                     }
 577                     int level = 1;
 578                     for (int stackLevelQuark : ss.getSubAttributes(callStackQuark, false)) {
 579                         if (level > threadEntry.getChildren().size()) {
 580                             CallStackEntry callStackEntry = new CallStackEntry(threadName, stackLevelQuark, level, trace, ss);
 581                             threadEntry.addChild(callStackEntry);
 582                         }
 583                         level++;
 584                     }
 585                 } catch (AttributeNotFoundException e) {
 586                     Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 587                 } catch (StateSystemDisposedException e) {
 588                     /* Ignored */
 589                 }
 590             }
 591             if (parentTrace == getTrace()) {
 592                 synchronized (this) {
 593                     setStartTime(getStartTime() == SWT.DEFAULT ? start : Math.min(getStartTime(), start));
 594                     setEndTime(getEndTime() == SWT.DEFAULT ? end + 1 : Math.max(getEndTime(), end + 1));
 595                 }
 596                 synchingToTime(getTimeGraphViewer().getSelectionBegin());
 597                 refresh();
 598             }
 599             for (ITimeGraphEntry threadEntry : traceEntry.getChildren()) {
 600                 for (ITimeGraphEntry callStackEntry : threadEntry.getChildren()) {
 601                     if (monitor.isCanceled()) {
 602                         return;
 603                     }
 604                     buildStatusEvents(parentTrace, (CallStackEntry) callStackEntry, monitor, start, end);
 605                 }
 606             }
 607             start = end;
 608         }
 609     }
 610
 611     private void addUnavailableEntry(ITmfTrace trace, ITmfTrace parentTrace) {
 612         String name = Messages.CallStackView_StackInfoNotAvailable + ' ' + '(' + trace.getName() + ')';
 613         TraceEntry unavailableEntry = new TraceEntry(name, 0, 0);
 614         addToEntryList(parentTrace, Collections.singletonList(unavailableEntry));
 615         if (parentTrace == getTrace()) {
 616             refresh();
 617         }
 618     }
 619
 620     private void buildStatusEvents(ITmfTrace trace, CallStackEntry entry, @NonNull IProgressMonitor monitor, long start, long end) {
 621         ITmfStateSystem ss = entry.getStateSystem();
 622         long resolution = Math.max(1, (end - ss.getStartTime()) / getDisplayWidth());
 623         List<ITimeEvent> eventList = getEventList(entry, start, end + 1, resolution, monitor);
 624         if (eventList != null) {
 625             for (ITimeEvent event : eventList) {
 626                 entry.addEvent(event);
 627             }
 628         }
 629         if (trace == getTrace()) {
 630             redraw();
 631         }
 632     }
 633
 634     /**
 635      * @since 2.0
 636      */
 637     @Override
 638     protected final List<ITimeEvent> getEventList(TimeGraphEntry tgentry, long startTime, long endTime, long resolution, IProgressMonitor monitor) {
 639         if (!(tgentry instanceof CallStackEntry)) {
 640             return null;
 641         }
 642         CallStackEntry entry = (CallStackEntry) tgentry;
 643         ITmfStateSystem ss = entry.getStateSystem();
 644         long start = Math.max(startTime, ss.getStartTime());
 645         long end = Math.min(endTime, ss.getCurrentEndTime() + 1);
 646         if (end <= start) {
 647             return null;
 648         }
 649         List<ITimeEvent> eventList = null;
 650         try {
 651             List<ITmfStateInterval> stackIntervals = StateSystemUtils.queryHistoryRange(ss, entry.getQuark(), start, end - 1, resolution, monitor);
 652             eventList = new ArrayList<>(stackIntervals.size());
 653             long lastEndTime = -1;
 654             boolean lastIsNull = true;
 655             for (ITmfStateInterval statusInterval : stackIntervals) {
 656                 if (monitor.isCanceled()) {
 657                     return null;
 658                 }
 659                 long time = statusInterval.getStartTime();
 660                 long duration = statusInterval.getEndTime() - time + 1;
 661                 if (!statusInterval.getStateValue().isNull()) {
 662                     final int modulo = CallStackPresentationProvider.NUM_COLORS / 2;
 663                     int value = statusInterval.getStateValue().toString().hashCode() % modulo + modulo;
 664                     eventList.add(new CallStackEvent(entry, time, duration, value));
 665                     lastIsNull = false;
 666                 } else {
 667                     if (lastEndTime == -1) {
 668                         // add null event if it intersects the start time
 669                         eventList.add(new NullTimeEvent(entry, time, duration));
 670                     } else {
 671                         if (lastEndTime != time && lastIsNull) {
 672                             // add unknown event if between two null states
 673                             eventList.add(new TimeEvent(entry, lastEndTime, time - lastEndTime));
 674                         }
 675                         if (time + duration >= endTime) {
 676                             // add null event if it intersects the end time
 677                             eventList.add(new NullTimeEvent(entry, time, duration));
 678                         }
 679                     }
 680                     lastIsNull = true;
 681                 }
 682                 lastEndTime = time + duration;
 683             }
 684         } catch (AttributeNotFoundException e) {
 685             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 686         } catch (TimeRangeException e) {
 687             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 688         } catch (StateSystemDisposedException e) {
 689             /* Ignored */
 690         }
 691         return eventList;
 692     }
 693
 694     /**
 695      * @since 2.0
 696      */
 697     @Override
 698     protected void synchingToTime(long time) {
 699         List<TimeGraphEntry> entryList = getEntryList(getTrace());
 700         if (entryList == null) {
 701             return;
 702         }
 703         for (TimeGraphEntry traceEntry : entryList) {
 704             for (ITimeGraphEntry threadEntry : traceEntry.getChildren()) {
 705                 ITmfStateSystem ss = ((ThreadEntry) threadEntry).getStateSystem();
 706                 if (ss == null) {
 707                     continue;
 708                 }
 709                 if (ss.isCancelled()) {
 710                     continue;
 711                 }
 712                 if (time < ss.getStartTime() || time > ss.getCurrentEndTime()) {
 713                     continue;
 714                 }
 715                 for (ITimeGraphEntry child : threadEntry.getChildren()) {
 716                     CallStackEntry callStackEntry = (CallStackEntry) child;
 717                     try {
 718                         ITmfStateInterval stackLevelInterval = ss.querySingleState(time, callStackEntry.getQuark());
 719                         ITmfStateValue nameValue = stackLevelInterval.getStateValue();
 720                         String name = ""; //$NON-NLS-1$
 721                         try {
 722                             if (nameValue.getType() == Type.STRING) {
 723                                 String address = nameValue.unboxStr();
 724                                 name = getFunctionName(address);
 725                             } else if (nameValue.getType() == Type.INTEGER) {
 726                                 name = "0x" + Integer.toHexString(nameValue.unboxInt()); //$NON-NLS-1$
 727                             } else if (nameValue.getType() == Type.LONG) {
 728                                 name = "0x" + Long.toHexString(nameValue.unboxLong()); //$NON-NLS-1$
 729                             }
 730                         } catch (StateValueTypeException e) {
 731                         }
 732                         callStackEntry.setFunctionName(name);
 733                         if (name.length() > 0) {
 734                             callStackEntry.setFunctionEntryTime(stackLevelInterval.getStartTime());
 735                             callStackEntry.setFunctionExitTime(stackLevelInterval.getEndTime() + 1);
 736                         }
 737                     } catch (AttributeNotFoundException e) {
 738                         Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 739                     } catch (StateSystemDisposedException e) {
 740                         /* Ignored */
 741                     }
 742                 }
 743             }
 744         }
 745         if (Display.getCurrent() != null) {
 746             getTimeGraphCombo().refresh();
 747         }
 748     }
 749
 750     private void makeActions() {
 751         fPreviousItemAction = getTimeGraphViewer().getPreviousItemAction();
 752         fPreviousItemAction.setText(Messages.TmfTimeGraphViewer_PreviousItemActionNameText);
 753         fPreviousItemAction.setToolTipText(Messages.TmfTimeGraphViewer_PreviousItemActionToolTipText);
 754         fNextItemAction = getTimeGraphViewer().getNextItemAction();
 755         fNextItemAction.setText(Messages.TmfTimeGraphViewer_NextItemActionNameText);
 756         fNextItemAction.setToolTipText(Messages.TmfTimeGraphViewer_NextItemActionToolTipText);
 757     }
 758
 759     private void contributeToActionBars() {
 760         // Create pin action
 761         contributePinActionToToolBar();
 762         fPinAction.addPropertyChangeListener(new IPropertyChangeListener() {
 763             @Override
 764             public void propertyChange(PropertyChangeEvent event) {
 765                 if (IAction.CHECKED.equals(event.getProperty()) && !isPinned()) {
 766                     if (fSavedRangeSyncSignal != null) {
 767                         windowRangeUpdated(fSavedRangeSyncSignal);
 768                         fSavedRangeSyncSignal = null;
 769                     }
 770
 771                     if (fSavedTimeSyncSignal != null) {
 772                         selectionRangeUpdated(fSavedTimeSyncSignal);
 773                         fSavedTimeSyncSignal = null;
 774                     }
 775                 }
 776             }
 777         });
 778     }
 779
 780     /**
 781      * @since 2.0
 782      */
 783     @Override
 784     protected void fillLocalToolBar(IToolBarManager manager) {
 785         makeActions();
 786         manager.add(getImportBinaryAction());
 787         manager.add(getImportMappingAction());
 788         manager.add(new Separator());
 789         manager.add(getSortByNameAction());
 790         manager.add(getSortByIdAction());
 791         manager.add(getSortByTimeAction());
 792         manager.add(new Separator());
 793         manager.add(getTimeGraphCombo().getShowFilterDialogAction());
 794         manager.add(new Separator());
 795         manager.add(getTimeGraphViewer().getResetScaleAction());
 796         manager.add(getPreviousEventAction());
 797         manager.add(getNextEventAction());
 798         manager.add(new Separator());
 799         manager.add(getTimeGraphViewer().getToggleBookmarkAction());
 800         manager.add(getTimeGraphViewer().getPreviousMarkerAction());
 801         manager.add(getTimeGraphViewer().getNextMarkerAction());
 802         manager.add(new Separator());
 803         manager.add(fPreviousItemAction);
 804         manager.add(fNextItemAction);
 805         manager.add(getTimeGraphViewer().getZoomInAction());
 806         manager.add(getTimeGraphViewer().getZoomOutAction());
 807     }
 808
 809     private void createContextMenu() {
 810         final MenuManager contextMenu = new MenuManager();
 811         contextMenu.add(getSortByNameAction());
 812         contextMenu.add(getSortByIdAction());
 813         contextMenu.add(getSortByTimeAction());
 814
 815         Tree tree = getTimeGraphCombo().getTreeViewer().getTree();
 816         Menu menu = contextMenu.createContextMenu(tree);
 817         tree.setMenu(menu);
 818     }
 819
 820     /**
 821      * Get the the next event action.
 822      *
 823      * @return The action object
 824      */
 825     private Action getNextEventAction() {
 826         if (fNextEventAction == null) {
 827             fNextEventAction = new Action() {
 828                 @Override
 829                 public void run() {
 830                     TimeGraphViewer viewer = getTimeGraphViewer();
 831                     ITimeGraphEntry entry = viewer.getSelection();
 832                     if (entry instanceof CallStackEntry) {
 833                         try {
 834                             CallStackEntry callStackEntry = (CallStackEntry) entry;
 835                             ITmfStateSystem ss = callStackEntry.getStateSystem();
 836                             long time = Math.max(ss.getStartTime(), Math.min(ss.getCurrentEndTime(), viewer.getSelectionBegin()));
 837                             ThreadEntry threadEntry = (ThreadEntry) callStackEntry.getParent();
 838                             int quark = ss.getParentAttributeQuark(callStackEntry.getQuark());
 839                             ITmfStateInterval stackInterval = ss.querySingleState(time, quark);
 840                             long newTime = stackInterval.getEndTime() + 1;
 841                             viewer.setSelectedTimeNotify(newTime, true);
 842                             stackInterval = ss.querySingleState(Math.min(ss.getCurrentEndTime(), newTime), quark);
 843                             int stackLevel = stackInterval.getStateValue().unboxInt();
 844                             ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 845                             getTimeGraphCombo().setSelection(selectedEntry);
 846                             viewer.getTimeGraphControl().fireSelectionChanged();
 847                             startZoomThread(viewer.getTime0(), viewer.getTime1());
 848
 849                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 850                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 851                         }
 852                     }
 853                 }
 854             };
 855
 856             fNextEventAction.setText(Messages.TmfTimeGraphViewer_NextEventActionNameText);
 857             fNextEventAction.setToolTipText(Messages.TmfTimeGraphViewer_NextEventActionToolTipText);
 858             fNextEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(ITmfImageConstants.IMG_UI_NEXT_EVENT));
 859         }
 860
 861         return fNextEventAction;
 862     }
 863
 864     /**
 865      * Get the previous event action.
 866      *
 867      * @return The Action object
 868      */
 869     private Action getPreviousEventAction() {
 870         if (fPrevEventAction == null) {
 871             fPrevEventAction = new Action() {
 872                 @Override
 873                 public void run() {
 874                     TimeGraphViewer viewer = getTimeGraphCombo().getTimeGraphViewer();
 875                     ITimeGraphEntry entry = viewer.getSelection();
 876                     if (entry instanceof CallStackEntry) {
 877                         try {
 878                             CallStackEntry callStackEntry = (CallStackEntry) entry;
 879                             ITmfStateSystem ss = callStackEntry.getStateSystem();
 880                             long time = Math.max(ss.getStartTime(), Math.min(ss.getCurrentEndTime(), viewer.getSelectionBegin()));
 881                             ThreadEntry threadEntry = (ThreadEntry) callStackEntry.getParent();
 882                             int quark = ss.getParentAttributeQuark(callStackEntry.getQuark());
 883                             ITmfStateInterval stackInterval = ss.querySingleState(time, quark);
 884                             if (stackInterval.getStartTime() == time && time > ss.getStartTime()) {
 885                                 stackInterval = ss.querySingleState(time - 1, quark);
 886                             }
 887                             viewer.setSelectedTimeNotify(stackInterval.getStartTime(), true);
 888                             int stackLevel = stackInterval.getStateValue().unboxInt();
 889                             ITimeGraphEntry selectedEntry = threadEntry.getChildren().get(Math.max(0, stackLevel - 1));
 890                             getTimeGraphCombo().setSelection(selectedEntry);
 891                             viewer.getTimeGraphControl().fireSelectionChanged();
 892                             startZoomThread(viewer.getTime0(), viewer.getTime1());
 893
 894                         } catch (AttributeNotFoundException | TimeRangeException | StateSystemDisposedException | StateValueTypeException e) {
 895                             Activator.getDefault().logError("Error querying state system", e); //$NON-NLS-1$
 896                         }
 897                     }
 898                 }
 899             };
 900
 901             fPrevEventAction.setText(Messages.TmfTimeGraphViewer_PreviousEventActionNameText);
 902             fPrevEventAction.setToolTipText(Messages.TmfTimeGraphViewer_PreviousEventActionToolTipText);
 903             fPrevEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(ITmfImageConstants.IMG_UI_PREV_EVENT));
 904         }
 905
 906         return fPrevEventAction;
 907     }
 908
 909     private static @Nullable AbstractCallStackAnalysis getCallStackModule(@NonNull ITmfTrace trace) {
 910         /*
 911          * Since we cannot know the exact analysis ID (in separate plugins), we
 912          * will search using the analysis type.
 913          */
 914         Iterable<AbstractCallStackAnalysis> modules =
 915                 TmfTraceUtils.getAnalysisModulesOfClass(trace, AbstractCallStackAnalysis.class);
 916         Iterator<AbstractCallStackAnalysis> it = modules.iterator();
 917         if (!it.hasNext()) {
 918             /* This trace does not provide a call-stack analysis */
 919             return null;
 920         }
 921
 922         /*
 923          * We only look at the first module we find.
 924          *
 925          * TODO Handle the advanced case where one trace provides more than one
 926          * call-stack analysis.
 927          */
 928         AbstractCallStackAnalysis module = it.next();
 929         /* This analysis is not automatic, we need to schedule it on-demand */
 930         module.schedule();
 931         module.waitForInitialization();
 932         return module;
 933     }
 934
 935     // ------------------------------------------------------------------------
 936     // Methods related to function name mapping
 937     // ------------------------------------------------------------------------
 938
 939     /**
 940      * Common code for all import file mapping actions
 941      */
 942     private abstract class AbstractImportFileMappingAction extends Action {
 943         private final String fDialogTitle;
 944
 945         private AbstractImportFileMappingAction(String dialogTitle) {
 946             fDialogTitle = dialogTitle;
 947         }
 948
 949         @Override
 950         public void run() {
 951             FileDialog dialog = new FileDialog(getViewSite().getShell());
 952             dialog.setText(fDialogTitle);
 953             final String filePath = dialog.open();
 954             if (filePath == null) {
 955                 /* No file was selected, don't change anything */
 956                 return;
 957             }
 958
 959             /*
 960              * Start the mapping import in a separate thread (we do not want to
 961              * UI thread to do this).
 962              */
 963             Job job = new Job(Messages.CallStackView_ImportMappingJobName) {
 964                 @Override
 965                 public IStatus run(IProgressMonitor monitor) {
 966                     fNameMapping = doMapping(new File(filePath));
 967
 968                     /* Refresh call stack entries and event labels */
 969                     Display.getDefault().asyncExec(new Runnable() {
 970                         @Override
 971                         public void run() {
 972                             synchingToTime(getTimeGraphViewer().getSelectionBegin());
 973                         }
 974                     });
 975                     return Status.OK_STATUS;
 976                 }
 977             };
 978             job.schedule();
 979         }
 980
 981         abstract Map<String, String> doMapping(File file);
 982     }
 983
 984     /**
 985      * Toolbar icon to import the function address-to-name mapping file.
 986      */
 987     private Action getImportMappingAction() {
 988         if (fImportMappingAction != null) {
 989             return fImportMappingAction;
 990         }
 991         fImportMappingAction = new AbstractImportFileMappingAction(Messages.CallStackView_ImportMappingDialogTitle) {
 992             @Override
 993             Map<String, String> doMapping(File file) {
 994                 return FunctionNameMapper.mapFromNmTextFile(file);
 995             }
 996         };
 997
 998         fImportMappingAction.setText(Messages.CallStackView_ImportMappingButtonText);
 999         fImportMappingAction.setToolTipText(Messages.CallStackView_ImportMappingButtonTooltip);
1000         fImportMappingAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(IMPORT_MAPPING_ICON_PATH));
1001
1002         return fImportMappingAction;
1003     }
1004
1005     private Action getSortByNameAction() {
1006         if (fSortByNameAction == null) {
1007             fSortByNameAction = new Action(Messages.CallStackView_SortByThreadName, IAction.AS_CHECK_BOX) {
1008                 @Override
1009                 public void run() {
1010                     if (fSortOption == SortOption.BY_NAME) {
1011                         saveSortOption(SortOption.BY_NAME_REV);
1012                     } else {
1013                         saveSortOption(SortOption.BY_NAME);
1014                     }
1015                 }
1016             };
1017             fSortByNameAction.setToolTipText(Messages.CallStackView_SortByThreadName);
1018             fSortByNameAction.setImageDescriptor(SORT_BY_NAME_ICON);
1019         }
1020         return fSortByNameAction;
1021     }
1022
1023     private Action getSortByIdAction() {
1024         if (fSortByIdAction == null) {
1025             fSortByIdAction = new Action(Messages.CallStackView_SortByThreadId, IAction.AS_CHECK_BOX) {
1026                 @Override
1027                 public void run() {
1028                     if (fSortOption == SortOption.BY_ID) {
1029                         saveSortOption(SortOption.BY_ID_REV);
1030                     } else {
1031                         saveSortOption(SortOption.BY_ID);
1032                     }
1033                 }
1034             };
1035             fSortByIdAction.setToolTipText(Messages.CallStackView_SortByThreadId);
1036             fSortByIdAction.setImageDescriptor(SORT_BY_ID_ICON);
1037         }
1038         return fSortByIdAction;
1039     }
1040
1041     private Action getSortByTimeAction() {
1042         if (fSortByTimeAction == null) {
1043             fSortByTimeAction = new Action(Messages.CallStackView_SortByThreadTime, IAction.AS_CHECK_BOX) {
1044                 @Override
1045                 public void run() {
1046                     if (fSortOption == SortOption.BY_TIME) {
1047                         saveSortOption(SortOption.BY_TIME_REV);
1048                     } else {
1049                         saveSortOption(SortOption.BY_TIME);
1050                     }
1051                 }
1052             };
1053             fSortByTimeAction.setToolTipText(Messages.CallStackView_SortByThreadTime);
1054             fSortByTimeAction.setImageDescriptor(SORT_BY_TIME_ICON);
1055         }
1056         return fSortByTimeAction;
1057     }
1058
1059     private void loadSortOption() {
1060         IDialogSettings settings = Activator.getDefault().getDialogSettings();
1061         IDialogSettings section = settings.getSection(getClass().getName());
1062         if (section == null) {
1063             return;
1064         }
1065         String sortOption = section.get(SORT_OPTION_KEY);
1066         if (sortOption == null) {
1067             return;
1068         }
1069
1070         // reset defaults
1071         getSortByNameAction().setChecked(false);
1072         getSortByNameAction().setImageDescriptor(SORT_BY_NAME_ICON);
1073         getSortByIdAction().setChecked(false);
1074         getSortByIdAction().setImageDescriptor(SORT_BY_ID_ICON);
1075         getSortByTimeAction().setChecked(false);
1076         getSortByTimeAction().setImageDescriptor(SORT_BY_TIME_ICON);
1077
1078         if (sortOption.equals(SortOption.BY_NAME.name())) {
1079             fSortOption = SortOption.BY_NAME;
1080             fThreadComparator = new ThreadNameComparator(false);
1081             getSortByNameAction().setChecked(true);
1082         } else if (sortOption.equals(SortOption.BY_NAME_REV.name())) {
1083             fSortOption = SortOption.BY_NAME_REV;
1084             fThreadComparator = new ThreadNameComparator(true);
1085             getSortByNameAction().setChecked(true);
1086             getSortByNameAction().setImageDescriptor(SORT_BY_NAME_REV_ICON);
1087         } else if (sortOption.equals(SortOption.BY_ID.name())) {
1088             fSortOption = SortOption.BY_ID;
1089             fThreadComparator = new ThreadIdComparator(false);
1090             getSortByIdAction().setChecked(true);
1091         } else if (sortOption.equals(SortOption.BY_ID_REV.name())) {
1092             fSortOption = SortOption.BY_ID_REV;
1093             fThreadComparator = new ThreadIdComparator(true);
1094             getSortByIdAction().setChecked(true);
1095             getSortByIdAction().setImageDescriptor(SORT_BY_ID_REV_ICON);
1096         } else if (sortOption.equals(SortOption.BY_TIME.name())) {
1097             fSortOption = SortOption.BY_TIME;
1098             fThreadComparator = new ThreadTimeComparator(false);
1099             getSortByTimeAction().setChecked(true);
1100         } else if (sortOption.equals(SortOption.BY_TIME_REV.name())) {
1101             fSortOption = SortOption.BY_TIME_REV;
1102             fThreadComparator = new ThreadTimeComparator(true);
1103             getSortByTimeAction().setChecked(true);
1104             getSortByTimeAction().setImageDescriptor(SORT_BY_TIME_REV_ICON);
1105         }
1106     }
1107
1108     private void saveSortOption(SortOption sortOption) {
1109         IDialogSettings settings = Activator.getDefault().getDialogSettings();
1110         IDialogSettings section = settings.getSection(getClass().getName());
1111         if (section == null) {
1112             section = settings.addNewSection(getClass().getName());
1113         }
1114         section.put(SORT_OPTION_KEY, sortOption.name());
1115         loadSortOption();
1116         List<TimeGraphEntry> entryList = getEntryList(getTrace());
1117         if (entryList == null) {
1118             return;
1119         }
1120         for (TimeGraphEntry traceEntry : entryList) {
1121             traceEntry.sortChildren(fThreadComparator);
1122         }
1123         refresh();
1124     }
1125
1126     /**
1127      * Toolbar icon to import the function address-to-name mapping binary file.
1128      */
1129     private Action getImportBinaryAction() {
1130         if (fImportBinaryFileMappingAction != null) {
1131             return fImportBinaryFileMappingAction;
1132         }
1133
1134         fImportBinaryFileMappingAction = new AbstractImportFileMappingAction(Messages.CallStackView_ImportBinaryFileDialogTitle) {
1135             @Override
1136             Map<String, String> doMapping(File file) {
1137                 return FunctionNameMapper.mapFromBinaryFile(file);
1138             }
1139         };
1140
1141         fImportBinaryFileMappingAction.setText(Messages.CallStackView_ImportBinaryFileButtonText);
1142         fImportBinaryFileMappingAction.setToolTipText(Messages.CallStackView_ImportBinaryFileButtonTooltip);
1143         fImportBinaryFileMappingAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(IMPORT_BINARY_ICON_PATH));
1144
1145         return fImportBinaryFileMappingAction;
1146     }
1147
1148     String getFunctionName(String address) {
1149         if (fNameMapping == null) {
1150             /* No mapping available, just print the addresses */
1151             return address;
1152         }
1153         String ret = fNameMapping.get(address);
1154         if (ret == null) {
1155             /*
1156              * We didn't find this address in the mapping file, just use the
1157              * address
1158              */
1159             return address;
1160         }
1161         return ret;
1162     }
1163
1164 }