* Patrick Tasse - Initial API and implementation
* Geneviève Bastien - Move code to provide base classes for time graph view
* Christian Mansky - Add check active / uncheck inactive buttons
+ * Mahdi Zolnouri & Samuel Gagnon - Add flat / hierarchical button
*******************************************************************************/
package org.eclipse.tracecompass.internal.analysis.os.linux.ui.views.controlflow;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
+import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
+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.Job;
import org.eclipse.jdt.annotation.NonNull;
import org.eclipse.jdt.annotation.Nullable;
+import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
+import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.widgets.Composite;
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.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.ITmfTimestamp;
+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;
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 TRACE_COLUMN = Messages.ControlFlowView_traceColumn;
+
+ private static final String NEXT_EVENT_ICON_PATH = "icons/obj16/shift_r_edit.gif"; //$NON-NLS-1$
+ private static final String PREV_EVENT_ICON_PATH = "icons/obj16/shift_l_edit.gif"; //$NON-NLS-1$
private static final String[] COLUMN_NAMES = new String[] {
PROCESS_COLUMN,
TID_COLUMN,
PTID_COLUMN,
- BIRTH_TIME_COLUMN,
- TRACE_COLUMN
+ BIRTH_TIME_COLUMN
};
private static final String[] FILTER_COLUMN_NAMES = new String[] {
builder.add(ControlFlowColumnComparators.PROCESS_NAME_COLUMN_COMPARATOR)
.add(ControlFlowColumnComparators.TID_COLUMN_COMPARATOR)
.add(ControlFlowColumnComparators.PTID_COLUMN_COMPARATOR)
- .add(ControlFlowColumnComparators.BIRTH_TIME_COLUMN_COMPARATOR)
- .add(ControlFlowColumnComparators.TRACE_COLUMN_COMPARATOR);
+ .add(ControlFlowColumnComparators.BIRTH_TIME_COLUMN_COMPARATOR);
List<Comparator<ITimeGraphEntry>> l = builder.build();
COLUMN_COMPARATORS = l.toArray(new Comparator[l.size()]);
}
+ private final Set<ITmfTrace> fFlatTraces = new HashSet<>();
+
+ private IAction fFlatAction;
+
+ private IAction fHierarchicalAction;
+
// ------------------------------------------------------------------------
// Constructors
// ------------------------------------------------------------------------
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);
+ }
+
+ @Override
+ protected void fillLocalMenu(IMenuManager manager) {
+ super.fillLocalMenu(manager);
+ final MenuManager item = new MenuManager(Messages.ControlFlowView_threadPresentation);
+ fFlatAction = createFlatAction();
+ item.add(fFlatAction);
+
+ fHierarchicalAction = createHierarchicalAction();
+ item.add(fHierarchicalAction);
+ 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() {
+ TimeGraphControl ctrl = getTimeGraphViewer().getTimeGraphControl();
+
+ ITimeGraphEntry traceEntry = ctrl.getSelectedTrace();
+ long ts = ctrl.getTimeDataProvider().getSelectionBegin();
+ ITmfTimestamp ts2 = TmfTraceManager.getInstance().getCurrentTraceContext().getSelectionRange().getStartTime();
+ ITimeEvent selectedState = Utils.findEvent(traceEntry, ts, 0);
+
+ if (selectedState == null) {
+ return;
+ }
+ ITimeGraphEntry entry = selectedState.getEntry();
+ if (!(entry instanceof ControlFlowEntry)) {
+ return;
+ }
+ ControlFlowEntry cfEntry = (ControlFlowEntry) entry;
+ int tid = cfEntry.getThreadId();
+
+ Job job = new Job(ifJobName) {
+ @Override
+ protected IStatus run(IProgressMonitor monitor) {
+ ITmfTrace trace = cfEntry.getTrace();
+ ITmfContext ctx = trace.seekEvent(ts2);
+ long rank = ctx.getRank();
+
+ Predicate<@NonNull ITmfEvent> predicate = event -> {
+ Integer eventTid = KernelTidAspect.INSTANCE.resolve(event);
+ return (eventTid != null && eventTid.intValue() == tid);
+ };
+
+ ITmfEvent event = (ifDirection ?
+ TmfTraceUtils.getNextEventMatching(cfEntry.getTrace(), rank, predicate) :
+ TmfTraceUtils.getPreviousEventMatching(cfEntry.getTrace(), rank, predicate));
+ if (event != null) {
+ TmfSignalManager.dispatchSignal(new TmfSelectionRangeUpdatedSignal(this, event.getTimestamp()));
+ }
+ return Status.OK_STATUS;
+ }
+ };
+ job.schedule();
+ }
+ }
+
+ private IAction createHierarchicalAction() {
+ IAction action = new Action(Messages.ControlFlowView_hierarchicalViewLabel, IAction.AS_RADIO_BUTTON) {
+ @Override
+ public void run() {
+ ITmfTrace parentTrace = getTrace();
+ synchronized (fFlatTraces) {
+ fFlatTraces.remove(parentTrace);
+ for (ITmfTrace trace : TmfTraceManager.getTraceSet(parentTrace)) {
+ final ITmfStateSystem ss = TmfStateSystemAnalysisModule.getStateSystem(trace, KernelAnalysisModule.ID);
+ for (TimeGraphEntry traceEntry : getEntryList(ss)) {
+ List<ControlFlowEntry> currentRootList = traceEntry.getChildren().stream()
+ .filter(e -> e instanceof ControlFlowEntry)
+ .map(e -> (ControlFlowEntry) e).collect(Collectors.toList());
+ addEntriesToHierarchicalTree(currentRootList, traceEntry);
+ }
+ }
+ }
+ refresh();
+ }
+ };
+ action.setChecked(true);
+ action.setToolTipText(Messages.ControlFlowView_hierarchicalViewToolTip);
+ return action;
+ }
+
+ private IAction createFlatAction() {
+ 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);
+ }
+ }
+ }
+ refresh();
+ }
+ };
+ action.setToolTipText(Messages.ControlFlowView_flatViewToolTip);
+ return action;
}
@Override
@Override
public String getColumnText(Object element, int columnIndex) {
+ if (element instanceof TraceEntry) {
+ if (columnIndex == 0) {
+ return ((TraceEntry) element).getName();
+ }
+ return ""; //$NON-NLS-1$
+ }
ControlFlowEntry entry = (ControlFlowEntry) element;
if (COLUMN_NAMES[columnIndex].equals(Messages.ControlFlowView_processColumn)) {
}
} 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();
}
return ""; //$NON-NLS-1$
}
@Override
public String getColumnText(Object element, int columnIndex) {
+ if (element instanceof TraceEntry) {
+ if (columnIndex == 0) {
+ return ((TraceEntry) element).getName();
+ }
+ return ""; //$NON-NLS-1$
+ }
ControlFlowEntry entry = (ControlFlowEntry) element;
if (columnIndex == 0) {
}
+ private static class TraceEntry extends TimeGraphEntry {
+
+ public TraceEntry(String name, long startTime, long endTime) {
+ super(name, startTime, endTime);
+ }
+
+ @Override
+ public boolean hasTimeEvents() {
+ return false;
+ }
+ }
+
+ @TmfSignalHandler
+ @Override
+ public void traceClosed(org.eclipse.tracecompass.tmf.core.signal.TmfTraceClosedSignal signal) {
+ super.traceClosed(signal);
+ synchronized (fFlatTraces) {
+ fFlatTraces.remove(signal.getTrace());
+ }
+ }
+
+ @TmfSignalHandler
+ @Override
+ public void traceSelected(TmfTraceSelectedSignal signal) {
+ super.traceSelected(signal);
+ synchronized (fFlatTraces) {
+ if (fFlatTraces.contains(signal.getTrace())) {
+ fHierarchicalAction.setChecked(false);
+ fFlatAction.setChecked(true);
+ } else {
+ fFlatAction.setChecked(false);
+ fHierarchicalAction.setChecked(true);
+ }
+ }
+ }
+
// ------------------------------------------------------------------------
// Internal
// ------------------------------------------------------------------------
}
final List<ControlFlowEntry> entryList = new ArrayList<>();
- /** Map of view entries, key is a pair [threadId, cpuId] */
+ /** Map of trace entries */
+ Map<ITmfTrace, TraceEntry> traceEntryMap = new HashMap<>();
+ /** Map of control flow entries, key is a pair [threadId, cpuId] */
final Map<Pair<Integer, Integer>, ControlFlowEntry> entryMap = new HashMap<>();
long start = ssq.getStartTime();
if (start == end && !complete) { // when complete execute one last time regardless of end time
continue;
}
+
+ TraceEntry aTraceEntry = traceEntryMap.get(trace);
+ if (aTraceEntry == null) {
+ aTraceEntry = new TraceEntry(trace.getName(), start, end + 1);
+ traceEntryMap.put(trace, aTraceEntry);
+ addToEntryList(parentTrace, ssq, Collections.singletonList(aTraceEntry));
+ } else {
+ aTraceEntry.updateEndTime(end + 1);
+ }
+ final TraceEntry traceEntry = aTraceEntry;
+
final long resolution = Math.max(1, (end - ssq.getStartTime()) / getDisplayWidth());
setEndTime(Math.max(getEndTime(), end + 1));
final List<Integer> threadQuarks = ssq.getQuarks(Attributes.THREADS, "*"); //$NON-NLS-1$
ppidInterval = ssq.querySingleState(startTime - 1, ppidQuark);
startTime = execNameInterval.getStartTime();
endTime = execNameInterval.getEndTime() + 1;
- } catch (AttributeNotFoundException e) {
- Activator.getDefault().logError(e.getMessage());
} catch (StateSystemDisposedException e) {
/* ignored */
}
lastPpidStartTime = ppidInterval.getStartTime();
}
}
- updateTree(entryList, parentTrace, ssq);
+ synchronized (fFlatTraces) {
+ if (fFlatTraces.contains(parentTrace)) {
+ addEntriesToFlatTree(entryList, traceEntry);
+ } else {
+ addEntriesToHierarchicalTree(entryList, traceEntry);
+ }
+ }
}
});
queryFullStates(ssq, ssq.getStartTime(), end, resolution, monitor, new IQueryHandler() {
@Override
public void handle(@NonNull List<List<ITmfStateInterval>> fullStates, @Nullable List<ITmfStateInterval> prevFullState) {
- for (final TimeGraphEntry entry : getEntryList(ssq)) {
+ for (final TimeGraphEntry entry : traceEntry.getChildren()) {
if (monitor.isCanceled()) {
return;
}
}
}
- private void updateTree(List<ControlFlowEntry> entryList, ITmfTrace parentTrace, ITmfStateSystem ss) {
- List<TimeGraphEntry> rootListToAdd = new ArrayList<>();
- List<TimeGraphEntry> rootListToRemove = new ArrayList<>();
- List<TimeGraphEntry> rootList = getEntryList(ss);
+ /**
+ * Add entries to the traces's child list in a flat fashion (no hierarchy).
+ * If one entry has children, we do a depth first search to add each child
+ * to the trace's child list and update the parent and child relations.
+ */
+ private static void hierarchicalToFlatTree(TimeGraphEntry traceEntry) {
+ List<@NonNull TimeGraphEntry> rootList = traceEntry.getChildren();
+ // We visit the children of every entry to add
+ StreamFlattener<TimeGraphEntry> sf = new StreamFlattener<>(entry -> entry.getChildren().stream());
+ Stream<TimeGraphEntry> allEntries = rootList.stream().flatMap(entry -> sf.flatten(entry));
+
+ // We add every entry that is missing from the trace's entry list
+ List<@NonNull TimeGraphEntry> rootListToAdd = allEntries
+ .filter(entry -> !rootList.contains(entry))
+ .collect(Collectors.toList());
+ rootList.forEach(entry -> {
+ entry.clearChildren();
+ });
+ rootListToAdd.forEach(entry -> {
+ traceEntry.addChild(entry);
+ entry.clearChildren();
+ });
+ }
+
+ /**
+ * Add entries to the traces's child list in a flat fashion (no hierarchy).
+ */
+ private static void addEntriesToFlatTree(List<@NonNull ControlFlowEntry> entryList, TimeGraphEntry traceEntry) {
+ List<TimeGraphEntry> rootList = traceEntry.getChildren();
+ for (ControlFlowEntry entry : entryList) {
+ if (!rootList.contains(entry)) {
+ traceEntry.addChild(entry);
+ }
+ }
+ }
+
+ /**
+ * Add entries to the trace's child list in a hierarchical fashion.
+ */
+ private static void addEntriesToHierarchicalTree(List<ControlFlowEntry> entryList, TimeGraphEntry traceEntry) {
+ List<TimeGraphEntry> rootList = traceEntry.getChildren();
for (ControlFlowEntry entry : entryList) {
- boolean root = (entry.getParent() == null);
+ boolean root = (entry.getParent() == null || entry.getParent() == traceEntry);
if (root && entry.getParentThreadId() > 0) {
for (ControlFlowEntry parent : entryList) {
/*
entry.getEndTime() < parent.getStartTime())) {
parent.addChild(entry);
root = false;
- if (rootList != null && rootList.contains(entry)) {
- rootListToRemove.add(entry);
+ if (rootList.contains(entry)) {
+ traceEntry.removeChild(entry);
}
break;
}
}
}
- if (root && (rootList == null || !rootList.contains(entry))) {
- rootListToAdd.add(entry);
+ if (root && (!rootList.contains(entry))) {
+ traceEntry.addChild(entry);
}
}
-
- addToEntryList(parentTrace, ss, rootListToAdd);
- removeFromEntryList(parentTrace, ss, rootListToRemove);
}
private void buildStatusEvents(ITmfTrace trace, ITmfTrace parentTrace, ITmfStateSystem ss, @NonNull List<List<ITmfStateInterval>> fullStates,
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 list;
}
- private ControlFlowEntry findEntry(List<? extends ITimeGraphEntry> entryList, ITmfTrace trace, int threadId) {
- for (ITimeGraphEntry entry : entryList) {
+ private ControlFlowEntry findEntry(List<TimeGraphEntry> entryList, ITmfTrace trace, int threadId) {
+ for (TimeGraphEntry entry : entryList) {
if (entry instanceof ControlFlowEntry) {
ControlFlowEntry controlFlowEntry = (ControlFlowEntry) entry;
if (controlFlowEntry.getThreadId() == threadId && controlFlowEntry.getTrace() == trace) {
return controlFlowEntry;
- } else if (entry.hasChildren()) {
- controlFlowEntry = findEntry(entry.getChildren(), trace, threadId);
- if (controlFlowEntry != null) {
- return controlFlowEntry;
- }
+ }
+ }
+ if (entry.hasChildren()) {
+ ControlFlowEntry controlFlowEntry = findEntry(entry.getChildren(), trace, threadId);
+ if (controlFlowEntry != null) {
+ return controlFlowEntry;
}
}
}
projects / deliverable / tracecompass.git / blobdiff