package org.eclipse.tracecompass.internal.analysis.os.linux.ui.views.controlflow;
+import static org.eclipse.tracecompass.common.core.NonNullUtils.checkNotNull;
+
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.ISchedulingRule;
+import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.IDialogSettings;
+import org.eclipse.jface.util.IPropertyChangeListener;
+import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Event;
import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelAnalysisModule;
+import org.eclipse.tracecompass.analysis.os.linux.core.kernel.KernelTidAspect;
import org.eclipse.tracecompass.common.core.StreamUtils.StreamFlattener;
import org.eclipse.tracecompass.internal.analysis.os.linux.core.kernel.Attributes;
import org.eclipse.tracecompass.internal.analysis.os.linux.ui.Activator;
import org.eclipse.tracecompass.internal.analysis.os.linux.ui.Messages;
import org.eclipse.tracecompass.internal.analysis.os.linux.ui.actions.FollowThreadAction;
+import org.eclipse.tracecompass.internal.analysis.os.linux.ui.views.controlflow.filters.ActiveThreadsFilter;
+import org.eclipse.tracecompass.internal.analysis.os.linux.ui.views.controlflow.filters.DynamicFilterDialog;
import org.eclipse.tracecompass.statesystem.core.ITmfStateSystem;
import org.eclipse.tracecompass.statesystem.core.exceptions.AttributeNotFoundException;
import org.eclipse.tracecompass.statesystem.core.exceptions.StateSystemDisposedException;
import org.eclipse.tracecompass.statesystem.core.exceptions.TimeRangeException;
import org.eclipse.tracecompass.statesystem.core.interval.ITmfStateInterval;
import org.eclipse.tracecompass.statesystem.core.statevalue.ITmfStateValue;
+import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSelectionRangeUpdatedSignal;
import org.eclipse.tracecompass.tmf.core.signal.TmfSignalHandler;
+import org.eclipse.tracecompass.tmf.core.signal.TmfSignalManager;
import org.eclipse.tracecompass.tmf.core.signal.TmfTraceSelectedSignal;
import org.eclipse.tracecompass.tmf.core.statesystem.TmfStateSystemAnalysisModule;
+import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
+import org.eclipse.tracecompass.tmf.core.trace.TmfTraceUtils;
import org.eclipse.tracecompass.tmf.core.util.Pair;
import org.eclipse.tracecompass.tmf.ui.views.timegraph.AbstractStateSystemTimeGraphView;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.ILinkEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeEvent;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeGraphEntry;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.model.TimeLinkEvent;
+import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.TimeGraphControl;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils.Resolution;
import org.eclipse.tracecompass.tmf.ui.widgets.timegraph.widgets.Utils.TimeFormat;
+import org.eclipse.ui.PlatformUI;
+import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
/**
/**
* View ID.
*/
- public static final String ID = "org.eclipse.tracecompass.analysis.os.linux.views.controlflow"; //$NON-NLS-1$
+ public static final @NonNull String ID = "org.eclipse.tracecompass.analysis.os.linux.views.controlflow"; //$NON-NLS-1$
+
+ private static final String ICONS_PATH = "icons/"; //$NON-NLS-1$
+ private static final String OPTIMIZE_ICON = ICONS_PATH + "elcl16/Optimization.png"; //$NON-NLS-1$
private static final String PROCESS_COLUMN = Messages.ControlFlowView_processColumn;
private static final String TID_COLUMN = Messages.ControlFlowView_tidColumn;
private static final String PTID_COLUMN = Messages.ControlFlowView_ptidColumn;
private static final String BIRTH_TIME_COLUMN = Messages.ControlFlowView_birthTimeColumn;
+ private static final String INVISIBLE_COLUMN = Messages.ControlFlowView_invisibleColumn;
+ private Action fOptimizationAction;
+
+ private static final String NEXT_EVENT_ICON_PATH = "icons/elcl16/shift_r_edit.gif"; //$NON-NLS-1$
+ private static final String PREV_EVENT_ICON_PATH = "icons/elcl16/shift_l_edit.gif"; //$NON-NLS-1$
private static final String[] COLUMN_NAMES = new String[] {
PROCESS_COLUMN,
private static final Comparator<ITimeGraphEntry>[] COLUMN_COMPARATORS;
+ private final Function<Collection<ILinkEvent>, Map<Integer, Long>> UPDATE_SCHEDULING_COLUMN_ALGO = new NaiveOptimizationAlgorithm();
+
private static final int INITIAL_SORT_COLUMN_INDEX = 3;
static {
COLUMN_COMPARATORS = l.toArray(new Comparator[l.size()]);
}
+ /**
+ * Mutex rule for search action jobs, making sure they execute sequentially
+ */
+ private final ISchedulingRule fSearchActionMutexRule = new ISchedulingRule() {
+ @Override
+ public boolean isConflicting(ISchedulingRule rule) {
+ return (rule == this);
+ }
+
+ @Override
+ public boolean contains(ISchedulingRule rule) {
+ return (rule == this);
+ }
+ };
+
private final Set<ITmfTrace> fFlatTraces = new HashSet<>();
private IAction fFlatAction;
private IAction fHierarchicalAction;
+ private @NonNull ActiveThreadsFilter fActiveThreadsFilter = new ActiveThreadsFilter(null, false);
+
+ private final ActiveThreadsFilterAction fActiveThreadsRapidToggle = new ActiveThreadsFilterAction();
+
+ class ActiveThreadsFilterAction extends Action {
+ public ActiveThreadsFilterAction() {
+ super(PackageMessages.ControlFlowView_DynamicFiltersActiveThreadToggleLabel, IAction.AS_CHECK_BOX);
+ setToolTipText(PackageMessages.ControlFlowView_DynamicFiltersActiveThreadToggleToolTip);
+ addPropertyChangeListener(new IPropertyChangeListener() {
+ @Override
+ public void propertyChange(PropertyChangeEvent event) {
+ if (!(event.getNewValue() instanceof Boolean)) {
+ return;
+ }
+
+ Boolean enabled = (Boolean) event.getNewValue();
+
+ /* Always remove the previous Active Threads filter */
+ getTimeGraphCombo().removeFilter(fActiveThreadsFilter);
+
+ if (enabled) {
+ fActiveThreadsFilter.setEnabled(true);
+ getTimeGraphCombo().addFilter(fActiveThreadsFilter);
+
+ /* Use flat representation */
+ if (fFlatAction != null) {
+ applyFlatPresentation();
+ fFlatAction.setChecked(true);
+ fHierarchicalAction.setChecked(false);
+ }
+ } else {
+ fActiveThreadsFilter.setEnabled(false);
+ }
+
+ refresh();
+ }
+ });
+ }
+ }
+
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
@Override
protected void fillLocalToolBar(IToolBarManager manager) {
+ // add "Optimization" Button to local tool bar of Controlflow
+ IAction optimizationAction = getOptimizationAction();
+ manager.add(optimizationAction);
+
+ // add a separator to local tool bar
+ manager.add(new Separator());
+
super.fillLocalToolBar(manager);
IDialogSettings settings = Activator.getDefault().getDialogSettings();
IDialogSettings section = settings.getSection(getClass().getName());
followArrowFwdAction.setText(Messages.ControlFlowView_followCPUFwdText);
followArrowFwdAction.setToolTipText(Messages.ControlFlowView_followCPUFwdText);
manager.add(followArrowFwdAction);
+
+ IAction previousEventAction = new SearchEventAction(false, PackageMessages.ControlFlowView_PreviousEventJobName);
+ previousEventAction.setText(PackageMessages.ControlFlowView_PreviousEventActionName);
+ previousEventAction.setToolTipText(PackageMessages.ControlFlowView_PreviousEventActionTooltip);
+ previousEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(PREV_EVENT_ICON_PATH));
+ manager.add(previousEventAction);
+
+ IAction nextEventAction = new SearchEventAction(true, PackageMessages.ControlFlowView_NextEventJobName);
+ nextEventAction.setText(PackageMessages.ControlFlowView_NextEventActionName);
+ nextEventAction.setToolTipText(PackageMessages.ControlFlowView_NextEventActionTooltip);
+ nextEventAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(NEXT_EVENT_ICON_PATH));
+ manager.add(nextEventAction);
+ }
+
+ private IAction getOptimizationAction() {
+ if (fOptimizationAction == null) {
+ fOptimizationAction = new OptimizationAction();
+ fOptimizationAction.setImageDescriptor(Activator.getDefault().getImageDescripterFromPath(OPTIMIZE_ICON));
+ fOptimizationAction.setText(Messages.ControlFlowView_optimizeLabel);
+ fOptimizationAction.setToolTipText(Messages.ControlFlowView_optimizeToolTip);
+ }
+ return fOptimizationAction;
}
@Override
protected void fillLocalMenu(IMenuManager manager) {
super.fillLocalMenu(manager);
- final MenuManager item = new MenuManager(Messages.ControlFlowView_threadPresentation);
+
+ MenuManager item = new MenuManager(Messages.ControlFlowView_threadPresentation);
fFlatAction = createFlatAction();
item.add(fFlatAction);
item.add(fHierarchicalAction);
manager.add(item);
+ item = new MenuManager(PackageMessages.ControlFlowView_DynamicFiltersMenuLabel);
+ item.add(fActiveThreadsRapidToggle);
+ item.add(new Separator());
+
+ IAction dynamicFiltersConfigureAction = createDynamicFilterConfigureAction();
+ item.add(dynamicFiltersConfigureAction);
+
+ manager.add(item);
+ }
+
+
+
+ /**
+ * Base Action for the "Go to Next/Previous Event for thread" actions
+ */
+ private class SearchEventAction extends Action {
+
+ private final boolean ifDirection;
+ private final String ifJobName;
+
+ /**
+ * Constructor
+ *
+ * @param direction
+ * The direction of the search, "true" for forwards and
+ * "false" for backwards.
+ * @param jobName
+ * The name of the job that will be spawned
+ */
+ public SearchEventAction(boolean direction, String jobName) {
+ ifDirection = direction;
+ ifJobName = jobName;
+ }
+
+ @Override
+ public void run() {
+ Job job = new Job(ifJobName) {
+ @Override
+ protected IStatus run(IProgressMonitor monitor) {
+ TimeGraphControl ctrl = getTimeGraphViewer().getTimeGraphControl();
+ ITimeGraphEntry traceEntry = ctrl.getSelectedTrace();
+
+ long ts = getTimeGraphViewer().getSelectionBegin();
+ ITimeEvent selectedState = Utils.findEvent(traceEntry, ts, 0);
+
+ if (selectedState == null) {
+ /* No selection currently in the view, do nothing */
+ return Status.OK_STATUS;
+ }
+ ITimeGraphEntry entry = selectedState.getEntry();
+ if (!(entry instanceof ControlFlowEntry)) {
+ return Status.OK_STATUS;
+ }
+ ControlFlowEntry cfEntry = (ControlFlowEntry) entry;
+ int tid = cfEntry.getThreadId();
+
+ ITmfTrace trace = cfEntry.getTrace();
+ ITmfContext ctx = trace.seekEvent(TmfTimestamp.fromNanos(ts));
+ long rank = ctx.getRank();
+ ctx.dispose();
+
+ Predicate<@NonNull ITmfEvent> predicate = event -> {
+ /*
+ * TODO Specific to the Control Flow View and kernel
+ * traces for now. Could be eventually generalized to
+ * anything represented by the time graph row.
+ */
+ Integer eventTid = KernelTidAspect.INSTANCE.resolve(event);
+ return (eventTid != null && eventTid.intValue() == tid);
+ };
+
+ ITmfEvent event = (ifDirection ?
+ TmfTraceUtils.getNextEventMatching(cfEntry.getTrace(), rank, predicate, monitor) :
+ TmfTraceUtils.getPreviousEventMatching(cfEntry.getTrace(), rank, predicate, monitor));
+ if (event != null) {
+ TmfSignalManager.dispatchSignal(new TmfSelectionRangeUpdatedSignal(this, event.getTimestamp()));
+ }
+ return Status.OK_STATUS;
+
+ }
+ };
+ /*
+ * Make subsequent jobs not run concurrently, but wait after one
+ * another.
+ */
+ job.setRule(fSearchActionMutexRule);
+ job.schedule();
+ }
+ }
+
+ private IAction createDynamicFilterConfigureAction() {
+ return new Action(PackageMessages.ControlFlowView_DynamicFiltersConfigureLabel, IAction.AS_PUSH_BUTTON) {
+ @Override
+ public void run() {
+ DynamicFilterDialog dialog = new DynamicFilterDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), fActiveThreadsFilter);
+ if (dialog.open() == Window.OK) {
+ /* Remove the previous Active Threads filter */
+ checkNotNull(getTimeGraphCombo()).removeFilter(fActiveThreadsFilter);
+
+ ActiveThreadsFilter newFilter = dialog.getActiveThreadsResult();
+ ActiveThreadsFilter previousFilter = fActiveThreadsFilter;
+
+ /* Set the filter to the view */
+ fActiveThreadsFilter = newFilter;
+
+ boolean enabled = fActiveThreadsFilter.isEnabled();
+ if (enabled) {
+ checkNotNull(getTimeGraphCombo()).addFilter(newFilter);
+ }
+
+ /*
+ * Prevent double refresh from change state of setChecked
+ * and ensure that a refresh is done if the mode of the
+ * filter is changed or options are changed
+ */
+ if (previousFilter.isEnabled() && newFilter.isEnabled()) {
+ boolean changed = !Objects.equal(previousFilter.getCpuRanges(), newFilter.getCpuRanges()) || previousFilter.isCpuRangesBased() != newFilter.isCpuRangesBased();
+ if (changed) {
+ refresh();
+ }
+ } else {
+ fActiveThreadsRapidToggle.setChecked(enabled);
+ }
+ }
+ }
+ };
}
private IAction createHierarchicalAction() {
for (TimeGraphEntry traceEntry : getEntryList(ss)) {
List<ControlFlowEntry> currentRootList = traceEntry.getChildren().stream()
.filter(e -> e instanceof ControlFlowEntry)
- .map(e -> (ControlFlowEntry) e).collect(Collectors.toList());
+ .map(e -> (ControlFlowEntry) e)
+ .collect(Collectors.toList());
addEntriesToHierarchicalTree(currentRootList, traceEntry);
}
}
IAction action = new Action(Messages.ControlFlowView_flatViewLabel, IAction.AS_RADIO_BUTTON) {
@Override
public void run() {
- ITmfTrace parentTrace = getTrace();
- synchronized (fFlatTraces) {
- fFlatTraces.add(parentTrace);
- for (ITmfTrace trace : TmfTraceManager.getTraceSet(parentTrace)) {
- final ITmfStateSystem ss = TmfStateSystemAnalysisModule.getStateSystem(trace, KernelAnalysisModule.ID);
- for (TimeGraphEntry traceEntry : getEntryList(ss)) {
- hierarchicalToFlatTree(traceEntry);
- }
- }
- }
+ applyFlatPresentation();
refresh();
}
};
+ action.setChecked(true);
action.setToolTipText(Messages.ControlFlowView_flatViewToolTip);
return action;
}
+ private void applyFlatPresentation() {
+ ITmfTrace parentTrace = getTrace();
+ synchronized (fFlatTraces) {
+ fFlatTraces.add(parentTrace);
+ for (ITmfTrace trace : TmfTraceManager.getTraceSet(parentTrace)) {
+ final ITmfStateSystem ss = TmfStateSystemAnalysisModule.getStateSystem(trace, KernelAnalysisModule.ID);
+ List<@NonNull TimeGraphEntry> entryList = getEntryList(ss);
+ if (entryList != null) {
+ for (TimeGraphEntry traceEntry : entryList) {
+ hierarchicalToFlatTree(traceEntry);
+ }
+ }
+ }
+ }
+ }
+
@Override
protected String getNextText() {
return Messages.ControlFlowView_nextProcessActionNameText;
return Messages.ControlFlowView_previousProcessActionToolTipText;
}
+ /**
+ * Get the optimization function for the scheduling column. In the base
+ * implementation, this optimizes by Line arrows, but can be overidden.
+ * <p>
+ * It takes a collection of link events, looking at the entries being
+ * linked, and returns a list of the proposed order. The list of indexes
+ * should be in ascending order. There can be duplicates, but the values and
+ * order should always be the same for the same input.
+ *
+ * @return the returned column order, where the integer is the tid of the
+ * entry, and the return value is the position, there can be
+ * duplicates.
+ */
+ public Function<Collection<ILinkEvent>, Map<Integer, Long>> getUpdatedSchedulingColumn() {
+ return UPDATE_SCHEDULING_COLUMN_ALGO;
+ }
+
+ /**
+ * This is an optimization action used to find cliques of entries due to
+ * links and put them closer together
+ *
+ * @author Samuel Gagnon
+ */
+ private final class OptimizationAction extends Action {
+
+ @Override
+ public void runWithEvent(Event event) {
+ ITmfTrace trace = getTrace();
+ if (trace == null) {
+ return;
+ }
+
+ createFlatAction().run();
+
+ /*
+ * This method only returns the arrows in the current time interval
+ * [a,b] of ControlFlowView. Thus, we only optimize for that time
+ * interval
+ */
+ List<ILinkEvent> arrows = getTimeGraphViewer().getTimeGraphControl().getArrows();
+ final ITmfStateSystem ss = TmfStateSystemAnalysisModule.getStateSystem(trace, KernelAnalysisModule.ID);
+ List<TimeGraphEntry> currentList = getEntryList(ss);
+
+ Map<Integer, Long> orderedTidMap = getUpdatedSchedulingColumn().apply(arrows);
+
+ /*
+ * Now that we have our list of ordered tid, it's time to assign a
+ * position for each threads in the view. For this, we assign a
+ * value to an invisible column and sort according to the values in
+ * this column.
+ */
+ for (TimeGraphEntry entry : currentList) {
+ if (entry instanceof TraceEntry) {
+ for (TimeGraphEntry child : ((TraceEntry) entry).getChildren()) {
+ if (child instanceof ControlFlowEntry) {
+ ControlFlowEntry cEntry = (ControlFlowEntry) child;
+ /*
+ * If the thread is in our list, we give it a
+ * position. Otherwise, it means there's no activity
+ * in the current interval for that thread. We set
+ * its position to Long.MAX_VALUE so it goes to the
+ * bottom.
+ */
+ cEntry.setSchedulingPosition(orderedTidMap.getOrDefault(cEntry.getThreadId(), Long.MAX_VALUE));
+ }
+ }
+ }
+ }
+
+ setEntryComparator(ControlFlowColumnComparators.SCHEDULING_COLUMN_COMPARATOR);
+ refresh();
+ }
+
+ }
+
/**
* @author gbastien
*
}
} else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_birthTimeColumn)) {
return Utils.formatTime(entry.getStartTime(), TimeFormat.CALENDAR, Resolution.NANOSEC);
+ } else if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_traceColumn)) {
+ return entry.getTrace().getName();
+ } else if (COLUMN_NAMES[columnIndex].equals(INVISIBLE_COLUMN)) {
+ return Long.toString(entry.getSchedulingPosition());
}
return ""; //$NON-NLS-1$
}
@Override
public void traceSelected(TmfTraceSelectedSignal signal) {
super.traceSelected(signal);
+
+ /* Update the Flat and Hierarchical actions */
synchronized (fFlatTraces) {
if (fFlatTraces.contains(signal.getTrace())) {
fHierarchicalAction.setChecked(false);
fHierarchicalAction.setChecked(true);
}
}
+
+ /* Update the Dynamic Filters related actions */
+ ViewerFilter activeThreadFilter = null;
+ ViewerFilter[] traceFilters = getFiltersMap().get(signal.getTrace());
+ if (traceFilters != null) {
+ activeThreadFilter = getActiveThreadsFilter(traceFilters);
+ }
+
+ if (activeThreadFilter == null) {
+ fActiveThreadsFilter = new ActiveThreadsFilter(null, false);
+ } else {
+ fActiveThreadsFilter = (@NonNull ActiveThreadsFilter) checkNotNull(activeThreadFilter);
+ }
+
+ fActiveThreadsRapidToggle.setChecked(fActiveThreadsFilter.isEnabled());
}
// ------------------------------------------------------------------------
continue;
}
- int execNameQuark;
- int ppidQuark;
- try {
- execNameQuark = ssq.getQuarkRelative(threadQuark, Attributes.EXEC_NAME);
- ppidQuark = ssq.getQuarkRelative(threadQuark, Attributes.PPID);
- } catch (AttributeNotFoundException e) {
+ int execNameQuark = ssq.optQuarkRelative(threadQuark, Attributes.EXEC_NAME);
+ int ppidQuark = ssq.optQuarkRelative(threadQuark, Attributes.PPID);
+ if (execNameQuark == ITmfStateSystem.INVALID_ATTRIBUTE) {
/* No information on this thread (yet?), skip it for now */
continue;
}
ITmfStateInterval lastExecNameInterval = prevFullState == null || execNameQuark >= prevFullState.size() ? null : prevFullState.get(execNameQuark);
long lastExecNameStartTime = lastExecNameInterval == null ? -1 : lastExecNameInterval.getStartTime();
long lastExecNameEndTime = lastExecNameInterval == null ? -1 : lastExecNameInterval.getEndTime() + 1;
- long lastPpidStartTime = prevFullState == null || ppidQuark >= prevFullState.size() ? -1 : prevFullState.get(ppidQuark).getStartTime();
+ long lastPpidStartTime = prevFullState == null || ppidQuark >= prevFullState.size() || ppidQuark == ITmfStateSystem.INVALID_ATTRIBUTE ? -1 : prevFullState.get(ppidQuark).getStartTime();
for (List<ITmfStateInterval> fullState : fullStates) {
if (monitor.isCanceled()) {
return;
continue;
}
ITmfStateInterval execNameInterval = fullState.get(execNameQuark);
- ITmfStateInterval ppidInterval = fullState.get(ppidQuark);
+ ITmfStateInterval ppidInterval = ppidQuark == ITmfStateSystem.INVALID_ATTRIBUTE ? null : fullState.get(ppidQuark);
long startTime = execNameInterval.getStartTime();
long endTime = execNameInterval.getEndTime() + 1;
- if (startTime == lastExecNameStartTime && ppidInterval.getStartTime() == lastPpidStartTime) {
+ if (startTime == lastExecNameStartTime && ppidInterval != null && ppidInterval.getStartTime() == lastPpidStartTime) {
continue;
}
boolean isNull = execNameInterval.getStateValue().isNull();
*/
try {
execNameInterval = ssq.querySingleState(startTime - 1, execNameQuark);
- ppidInterval = ssq.querySingleState(startTime - 1, ppidQuark);
+ ppidInterval = ppidQuark == ITmfStateSystem.INVALID_ATTRIBUTE ? null : ssq.querySingleState(startTime - 1, ppidQuark);
startTime = execNameInterval.getStartTime();
endTime = execNameInterval.getEndTime() + 1;
- } catch (AttributeNotFoundException e) {
- Activator.getDefault().logError(e.getMessage());
} catch (StateSystemDisposedException e) {
/* ignored */
}
if (!execNameInterval.getStateValue().isNull() &&
execNameInterval.getStateValue().getType() == ITmfStateValue.Type.STRING) {
String execName = execNameInterval.getStateValue().unboxStr();
- int ppid = ppidInterval.getStateValue().unboxInt();
+ int ppid = ppidInterval == null ? -1 : ppidInterval.getStateValue().unboxInt();
ControlFlowEntry entry = entryMap.get(entryKey);
if (entry == null) {
entry = new ControlFlowEntry(threadQuark, trace, execName, threadId, ppid, startTime, endTime);
}
lastExecNameStartTime = startTime;
lastExecNameEndTime = endTime;
- lastPpidStartTime = ppidInterval.getStartTime();
+ lastPpidStartTime = ppidInterval == null ? -1 : ppidInterval.getStartTime();
}
}
synchronized (fFlatTraces) {
if (parent.getThreadId() == entry.getParentThreadId() &&
!(entry.getStartTime() > parent.getEndTime() ||
entry.getEndTime() < parent.getStartTime())) {
- parent.addChild(entry);
root = false;
if (rootList.contains(entry)) {
traceEntry.removeChild(entry);
}
+ parent.addChild(entry);
break;
}
}
}
ControlFlowEntry entry = (ControlFlowEntry) tgentry;
try {
- int threadQuark = entry.getThreadQuark();
- int statusQuark = ss.getQuarkRelative(threadQuark, Attributes.STATUS);
+ int statusQuark = entry.getThreadQuark();
eventList = new ArrayList<>(fullStates.size());
ITmfStateInterval lastInterval = prevFullState == null || statusQuark >= prevFullState.size() ? null : prevFullState.get(statusQuark);
long lastStartTime = lastInterval == null ? -1 : lastInterval.getStartTime();
lastStartTime = time;
lastEndTime = time + duration;
}
- } catch (AttributeNotFoundException | TimeRangeException e) {
+ } catch (TimeRangeException e) {
Activator.getDefault().logError(e.getMessage());
}
return eventList;
ITmfStateInterval currentThreadInterval = ssq.querySingleState(time, currentThreadQuark);
int currentThread = currentThreadInterval.getStateValue().unboxInt();
if (currentThread > 0) {
- int statusQuark = ssq.getQuarkAbsolute(Attributes.THREADS, Integer.toString(currentThread), Attributes.STATUS);
+ int statusQuark = ssq.getQuarkAbsolute(Attributes.THREADS, Integer.toString(currentThread));
ITmfStateInterval statusInterval = ssq.querySingleState(time, statusQuark);
if (statusInterval.getStartTime() == time) {
thread = currentThread;
long end = Math.min(currentThreadInterval.getEndTime() + 1, ss.getCurrentEndTime());
currentThreadIntervals.add(ss.querySingleState(end, currentThreadQuark));
}
- } catch (AttributeNotFoundException e) {
- Activator.getDefault().logError(e.getMessage());
- return list;
} catch (StateSystemDisposedException e) {
/* Ignored */
return list;
}
return null;
}
+
+ private static ActiveThreadsFilter getActiveThreadsFilter(ViewerFilter[] filters) {
+ return (ActiveThreadsFilter) Arrays.stream(filters).filter(filter -> filter instanceof ActiveThreadsFilter).findFirst().orElse(null);
+ }
+
+ @Override
+ protected void updateFilters() {
+ super.updateFilters();
+ fActiveThreadsFilter.updateData();
+ }
+
}
projects / deliverable / tracecompass.git / blobdiff