From fbf1eaa8f37c17ebda65f7e23e42660bc9d2d138 Mon Sep 17 00:00:00 2001 From: Marco Miller Date: Fri, 30 Dec 2022 10:28:30 -0500 Subject: [PATCH] callstack: Bring incubated ICallGraphProvider in Add ICallGraphProvider from Incubator in turn, as well as its necessary dependencies. Skip ICalledFunction thus reuse the sibling profiling.core one, which only differs in contract; Incubator's has no default implementation that may differ. Do so until more contract becomes required if ever. (Likely, though.) Change-Id: If6f29c696283355b83b061a9ce0f45a57b230f0d Signed-off-by: Marco Miller Reviewed-on: https://git.eclipse.org/r/c/tracecompass/org.eclipse.tracecompass/+/197779 Tested-by: Trace Compass Bot Tested-by: Bernd Hufmann Reviewed-by: Bernd Hufmann --- .../META-INF/MANIFEST.MF | 2 + .../callstack/core/FlameDefaultPalette.java | 117 ++++++++++++ .../callstack/core/ICallGraphProvider.java | 100 +++++++++++ .../core/tree/AllGroupDescriptor.java | 48 +++++ .../core/tree/WeightedTreeGroupBy.java | 166 ++++++++++++++++++ .../callstack/core/tree/WeightedTreeSet.java | 86 +++++++++ .../META-INF/MANIFEST.MF | 2 +- .../core/callgraph/ICallGraphProvider.java | 2 - 8 files changed, 520 insertions(+), 3 deletions(-) create mode 100644 analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/FlameDefaultPalette.java create mode 100644 analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/ICallGraphProvider.java create mode 100644 analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/AllGroupDescriptor.java create mode 100644 analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeGroupBy.java create mode 100644 analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeSet.java diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.callstack.core/META-INF/MANIFEST.MF index b8e53796e1..340b413e26 100644 --- a/analysis/org.eclipse.tracecompass.analysis.callstack.core/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/META-INF/MANIFEST.MF @@ -11,8 +11,10 @@ Bundle-RequiredExecutionEnvironment: JavaSE-1.8 Automatic-Module-Name: org.eclipse.tracecompass.analysis.callstack.core Require-Bundle: org.eclipse.core.runtime, org.eclipse.jdt.annotation;bundle-version="[2.0.0,3.0.0)";resolution:=optional, + org.eclipse.tracecompass.analysis.profiling.core, org.eclipse.tracecompass.analysis.timing.core, org.eclipse.tracecompass.common.core, + org.eclipse.tracecompass.segmentstore.core, org.eclipse.tracecompass.tmf.core Export-Package: org.eclipse.tracecompass.internal.analysis.callstack.core;x-friends:="org.eclipse.tracecompass.analysis.callstack.core.tests" Import-Package: com.google.common.annotations, diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/FlameDefaultPalette.java b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/FlameDefaultPalette.java new file mode 100644 index 0000000000..5375cc34a6 --- /dev/null +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/FlameDefaultPalette.java @@ -0,0 +1,117 @@ +/******************************************************************************* + * Copyright (c) 2018 École Polytechnique de Montréal + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License 2.0 which + * accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + *******************************************************************************/ + +package org.eclipse.tracecompass.internal.analysis.callstack.core; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import org.eclipse.jdt.annotation.Nullable; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.IDataPalette; +import org.eclipse.tracecompass.internal.analysis.profiling.core.callgraph.ICalledFunction; +import org.eclipse.tracecompass.tmf.core.dataprovider.X11ColorUtils; +import org.eclipse.tracecompass.tmf.core.model.OutputElementStyle; +import org.eclipse.tracecompass.tmf.core.model.StyleProperties; +import org.eclipse.tracecompass.tmf.core.model.timegraph.TimeGraphState; +import org.eclipse.tracecompass.tmf.core.presentation.IPaletteProvider; +import org.eclipse.tracecompass.tmf.core.presentation.RGBAColor; +import org.eclipse.tracecompass.tmf.core.presentation.RotatingPaletteProvider; + +import com.google.common.collect.ImmutableMap; + +/** + * Class to manage the colors of the flame chart and flame graph views + * + * @author Geneviève Bastien + */ +public final class FlameDefaultPalette implements IDataPalette { + + /** + * The state index for the multiple state + */ + private static final int NUM_COLORS = 360; + private static final String DEFAULT_STYLE = "0"; //$NON-NLS-1$ + + private static final Map STYLES; + // Map of styles with the parent + private static final Map STYLE_MAP = Collections.synchronizedMap(new HashMap<>()); + + static { + IPaletteProvider palette = new RotatingPaletteProvider.Builder().setNbColors(NUM_COLORS).build(); + int i = 0; + ImmutableMap.Builder builder = new ImmutableMap.Builder<>(); + for (RGBAColor color : palette.get()) { + builder.put(String.valueOf(i), new OutputElementStyle(null, ImmutableMap.of( + StyleProperties.STYLE_NAME, String.valueOf(i), + StyleProperties.BACKGROUND_COLOR, X11ColorUtils.toHexColor(color.getRed(), color.getGreen(), color.getBlue()), + StyleProperties.OPACITY, (float) color.getAlpha() / 255))); + i++; + } + STYLES = builder.build(); + } + + private static @Nullable FlameDefaultPalette fInstance = null; + + private FlameDefaultPalette() { + // Do nothing + } + + /** + * Get the instance of this palette + * + * @return The instance of the palette + */ + public static FlameDefaultPalette getInstance() { + FlameDefaultPalette instance = fInstance; + if (instance == null) { + instance = new FlameDefaultPalette(); + fInstance = instance; + } + return instance; + } + + /** + * Get the map of styles for this palette + * + * @return The styles + */ + @Override + public Map getStyles() { + return STYLES; + } + + /** + * Get the style element for a given value + * + * @param callsite + * The value to get an element for + * @return The output style + */ + @Override + public OutputElementStyle getStyleFor(Object callsite) { + if (callsite instanceof AggregatedCallSite) { + ICallStackSymbol value = ((AggregatedCallSite) callsite).getObject(); + int hashCode = value.hashCode(); + return STYLE_MAP.computeIfAbsent(String.valueOf(Math.floorMod(hashCode, NUM_COLORS)), style -> new OutputElementStyle(style)); + } + if (callsite instanceof ICalledFunction) { + Object value = ((ICalledFunction) callsite).getSymbol(); + int hashCode = value.hashCode(); + return STYLE_MAP.computeIfAbsent(String.valueOf(Math.floorMod(hashCode, NUM_COLORS)), style -> new OutputElementStyle(style)); + } + if (callsite instanceof TimeGraphState) { + OutputElementStyle elStyle = ((TimeGraphState) callsite).getStyle(); + return elStyle == null ? STYLE_MAP.computeIfAbsent(DEFAULT_STYLE, style -> new OutputElementStyle(style)) : elStyle; + } + return STYLE_MAP.computeIfAbsent(DEFAULT_STYLE, style -> new OutputElementStyle(style)); + } +} diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/ICallGraphProvider.java b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/ICallGraphProvider.java new file mode 100644 index 0000000000..bc8107f36f --- /dev/null +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/ICallGraphProvider.java @@ -0,0 +1,100 @@ +/******************************************************************************* + * Copyright (c) 2017 École Polytechnique de Montréal + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License 2.0 which + * accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + *******************************************************************************/ + +package org.eclipse.tracecompass.internal.analysis.callstack.core; + +import java.util.Collection; + +import org.eclipse.jdt.annotation.NonNull; +import org.eclipse.jdt.annotation.Nullable; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.IDataPalette; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.IWeightedTreeGroupDescriptor; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.IWeightedTreeProvider; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.IWeightedTreeSet; +import org.eclipse.tracecompass.internal.analysis.callstack.core.tree.WeightedTreeGroupBy; +import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp; + +/** + * Interface that analyses who provide callgraph + * + * @author Geneviève Bastien + */ +public interface ICallGraphProvider extends IWeightedTreeProvider<@NonNull ICallStackSymbol, ICallStackElement, AggregatedCallSite> { + + /** + * Get the group descriptors that describe how the elements are grouped in + * this call graph hierarchy. This method will return the root group + * descriptor. Children groups can be retrieved by the parent group. For + * call graph providers who have only one series, this will be a singleton. + * + * @return The collection of group descriptors for this call graph + */ + Collection getGroupDescriptors(); + + @Override + default @Nullable IWeightedTreeGroupDescriptor getGroupDescriptor() { + // Return the first group descriptor + Collection groupDescriptors = getGroupDescriptors(); + if (groupDescriptors.isEmpty()) { + return null; + } + return groupDescriptors.iterator().next(); + } + + /** + * Get the call graph for a given time range. This callgraph is for all the + * elements. The caller can then group the result by calling + * {@link WeightedTreeGroupBy#groupWeightedTreeBy(IWeightedTreeGroupDescriptor, IWeightedTreeSet, IWeightedTreeProvider)} + * method + * + * @param start + * The start of the range + * @param end + * The end of the range + * @return The call graph object containing the CCTs for each element in the + * range. + */ + CallGraph getCallGraph(ITmfTimestamp start, ITmfTimestamp end); + + /** + * Get the call graph for the full range of the trace. This callgraph is for + * all the elements. The caller can then group the result by calling + * {@link WeightedTreeGroupBy#groupWeightedTreeBy(IWeightedTreeGroupDescriptor, IWeightedTreeSet, IWeightedTreeProvider)} + * + * @return The call graph object containing the CCTs for each element in the + * range. + */ + CallGraph getCallGraph(); + + @Override + default @Nullable IWeightedTreeSet<@NonNull ICallStackSymbol, ICallStackElement, AggregatedCallSite> getSelection(ITmfTimestamp start, ITmfTimestamp end) { + return getCallGraph(start, end); + } + + @Override + default IWeightedTreeSet<@NonNull ICallStackSymbol, ICallStackElement, AggregatedCallSite> getTreeSet() { + return getCallGraph(); + } + + /** + * Factory method to create an aggregated callsite for a symbol + * + * @param object + * The symbol + * @return A new aggregated callsite + */ + AggregatedCallSite createCallSite(Object object); + + @Override + default IDataPalette getPalette() { + return FlameDefaultPalette.getInstance(); + } +} diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/AllGroupDescriptor.java b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/AllGroupDescriptor.java new file mode 100644 index 0000000000..b98069224e --- /dev/null +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/AllGroupDescriptor.java @@ -0,0 +1,48 @@ +/******************************************************************************* + * Copyright (c) 2019 École Polytechnique de Montréal + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License 2.0 which + * accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + *******************************************************************************/ + +package org.eclipse.tracecompass.internal.analysis.callstack.core.tree; + +import org.eclipse.jdt.annotation.Nullable; + +/** + * Group descriptor to represent all elements grouped together + * + * @author Geneviève Bastien + */ +public final class AllGroupDescriptor implements IWeightedTreeGroupDescriptor { + + private static final String ALL_NAME = "all"; //$NON-NLS-1$ + + private static final IWeightedTreeGroupDescriptor INSTANCE = new AllGroupDescriptor(); + + /** + * Get the instance of the all group descriptor + * + * @return The instance of this group. + */ + public static IWeightedTreeGroupDescriptor getInstance() { + return INSTANCE; + } + + private AllGroupDescriptor() { + } + + @Override + public @Nullable IWeightedTreeGroupDescriptor getNextGroup() { + return null; + } + + @Override + public String getName() { + return ALL_NAME; + } +} diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeGroupBy.java b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeGroupBy.java new file mode 100644 index 0000000000..6e54d6c73d --- /dev/null +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeGroupBy.java @@ -0,0 +1,166 @@ +/******************************************************************************* + * Copyright (c) 2017 École Polytechnique de Montréal + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License 2.0 which + * accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + *******************************************************************************/ + +package org.eclipse.tracecompass.internal.analysis.callstack.core.tree; + +import java.util.Collection; +import java.util.Objects; + +import org.eclipse.jdt.annotation.NonNull; + +/** + * A class containing helper methods to group aggregated callgraph data by the + * different available groups + * + * @author Geneviève Bastien + */ +public final class WeightedTreeGroupBy { + + private WeightedTreeGroupBy() { + // Nothing to do + } + + /** + * Group callgraph groups by one of the descriptor. + * + * @param + * The type of objects represented by each node in the tree + * @param + * The type of elements used to group the trees. If this type + * extends {@link ITree}, then the elements and their associated + * weighted trees will be grouped in a hierarchical style + * @param + * The type of the tree provided + * + * @param groupBy + * The group descriptor by which to group the call graph + * elements. + * @param weightedTreeSet + * The weighted tree set to group trees for + * @param provider + * The weighted tree provider + * @return A weighted tree set that is the result of the grouping by the + * descriptor + */ + public static <@NonNull N, E, T extends WeightedTree> WeightedTreeSet groupWeightedTreeBy(IWeightedTreeGroupDescriptor groupBy, IWeightedTreeSet weightedTreeSet, IWeightedTreeProvider provider) { + // Fast return: just aggregated all groups together + if (groupBy.equals(AllGroupDescriptor.getInstance())) { + return groupWeightedTreeByAll(weightedTreeSet); + } + + return searchForGroups(groupBy, weightedTreeSet, provider); + } + + private static <@NonNull N, E, T extends WeightedTree> WeightedTreeSet searchForGroups(IWeightedTreeGroupDescriptor groupBy, IWeightedTreeSet callGraph, IWeightedTreeProvider provider) { + IWeightedTreeGroupDescriptor groupDescriptor = provider.getGroupDescriptor(); + int level = 0; + while (groupDescriptor != null && !groupDescriptor.equals(groupBy)) { + groupDescriptor = groupDescriptor.getNextGroup(); + level++; + } + + WeightedTreeSet newCg = new WeightedTreeSet<>(); + + Collection elements = callGraph.getElements(); + for (E element : elements) { + Object groupElement = (element instanceof ITree) ? ((ITree) element).copyElement() : Objects.requireNonNull(element); + recurseAddElementData(element, groupElement, callGraph, newCg, 0, level); + } + return newCg; + } + + /** + * @param originalElement + * The element to get the trees for + * + * @param groupElement + * The last group element + * + * @param treeSet + * The original weighted tree set + * + * @param newTreeSet + * The new weighted tree set to fill + * + * @param elDepth + * The current element depth + * + * @param groupDepth + * The depth from which elements will be aggregated. When elDepht + * < groupDepth, the element's tree are added as is in the new + * treeset, otherwise, they are merged with the trees for the + * element at the group depth + */ + @SuppressWarnings({ "unchecked", "null" }) + private static <@NonNull N, E, T extends WeightedTree> void recurseAddElementData(E originalElement, Object groupElement, IWeightedTreeSet<@NonNull N, E, T> treeSet, WeightedTreeSet<@NonNull N, Object> newTreeSet, int elDepth, + int groupDepth) { + + // Add the current level of trees to the new tree set + for (T tree : treeSet.getTreesFor(originalElement)) { + newTreeSet.addWeightedTree(groupElement, tree.copyOf()); + } + + // Recursively add the next level of elements + if (originalElement instanceof ITree) { + ITree treeEl = (ITree) originalElement; + Collection children = treeEl.getChildren(); + for (@NonNull ITree child : children) { + ITree nextGroupEl = (ITree) groupElement; + if (elDepth < groupDepth) { + nextGroupEl = child.copyElement(); + ((ITree) groupElement).addChild(nextGroupEl); + } + recurseAddElementData((E) child, nextGroupEl, treeSet, newTreeSet, elDepth + 1, groupDepth); + } + } + } + + private static <@NonNull N, E, T extends WeightedTree> WeightedTreeSet groupWeightedTreeByAll(IWeightedTreeSet weightedTree) { + WeightedTreeSet newTreeSet = new WeightedTreeSet<>(); + Collection elements = weightedTree.getElements(); + String mainGroup = "All"; //$NON-NLS-1$ + for (E element : elements) { + recurseAddElementData(element, mainGroup, weightedTree, newTreeSet); + } + return newTreeSet; + } + + /** + * @param element + * The element to get the trees for + * + * @param groupElement + * The last group element + * + * @param treeSet + * The original weighted tree set + * + * @param newTreeSet + * The new weighted tree set to fill + */ + @SuppressWarnings({ "unchecked", "null" }) + private static <@NonNull N, E, T extends WeightedTree> void recurseAddElementData(E element, String group, IWeightedTreeSet<@NonNull N, E, T> treeSet, WeightedTreeSet<@NonNull N, Object> newTreeSet) { + + // Add the current level of trees to the new tree set + for (T tree : treeSet.getTreesFor(element)) { + newTreeSet.addWeightedTree(group, tree.copyOf()); + } + + // Recursively add the next level of elements + if (element instanceof ITree) { + ITree treeEl = (ITree) element; + Collection children = treeEl.getChildren(); + for (Object child : children) { + recurseAddElementData((E) child, group, treeSet, newTreeSet); + } + } + } +} diff --git a/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeSet.java b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeSet.java new file mode 100644 index 0000000000..b9c4d15cc0 --- /dev/null +++ b/analysis/org.eclipse.tracecompass.analysis.callstack.core/src/org/eclipse/tracecompass/internal/analysis/callstack/core/tree/WeightedTreeSet.java @@ -0,0 +1,86 @@ +/******************************************************************************* + * Copyright (c) 2019 École Polytechnique de Montréal + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License 2.0 which + * accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + *******************************************************************************/ + +package org.eclipse.tracecompass.internal.analysis.callstack.core.tree; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Objects; +import java.util.Set; + +import org.eclipse.jdt.annotation.NonNull; + +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Multimap; + +/** + * An implementation of the weighted tree set, with generic types and nodes + * + * @author Geneviève Bastien + * @param + * The type of objects represented by each node in the tree + * @param + * The type of elements used to group the trees. If this type extends + * {@link ITree}, then the elements and their associated weighted + * trees will be grouped in a hierarchical style + */ +public class WeightedTreeSet<@NonNull N, E> implements IWeightedTreeSet> { + + private final Set fRootElements = new HashSet<>(); + private final Multimap> fTrees = HashMultimap.create(); + + @Override + public Collection getElements() { + return fRootElements; + } + + @Override + public Collection<@NonNull WeightedTree> getTreesFor(Object element) { + return Objects.requireNonNull(fTrees.get(element)); + } + + /** + * Add a weighted tree for an element in this set. If a tree for the same + * object already exists, their data will be merged. + * + * @param dstGroup + * The group to which to add this tree + * @param tree + * The weighted tree to add to this set. This tree may be + * modified and merged with others, so it should not be a tree + * that is part of another tree (for groupings or diff or other + * operations for instance) + */ + @SuppressWarnings({ "unchecked", "null" }) + public void addWeightedTree(E dstGroup, WeightedTree tree) { + // Make sure the root element is present + E root = dstGroup; + if (dstGroup instanceof ITree) { + ITree parent = ((ITree) dstGroup).getParent(); + while (parent != null) { + root = (E) parent; + parent = parent.getParent(); + } + fRootElements.add(root); + } + fRootElements.add(root); + + // Add the tree to the appropriate group + Collection> trees = fTrees.get(dstGroup); + for (WeightedTree currentTree : trees) { + if (currentTree.getObject().equals(tree.getObject())) { + currentTree.merge(tree); + return; + } + } + fTrees.put(dstGroup, tree); + } +} diff --git a/analysis/org.eclipse.tracecompass.analysis.profiling.core/META-INF/MANIFEST.MF b/analysis/org.eclipse.tracecompass.analysis.profiling.core/META-INF/MANIFEST.MF index bc4430a674..d9cf878932 100644 --- a/analysis/org.eclipse.tracecompass.analysis.profiling.core/META-INF/MANIFEST.MF +++ b/analysis/org.eclipse.tracecompass.analysis.profiling.core/META-INF/MANIFEST.MF @@ -22,7 +22,7 @@ Export-Package: org.eclipse.tracecompass.analysis.profiling.core.base, org.eclipse.tracecompass.analysis.profiling.core.callgraph, org.eclipse.tracecompass.analysis.profiling.core.callstack, org.eclipse.tracecompass.internal.analysis.profiling.core;x-friends:="org.eclipse.tracecompass.analysis.profiling.core.tests,org.eclipse.tracecompass.analysis.profiling.ui", - org.eclipse.tracecompass.internal.analysis.profiling.core.callgraph;x-friends:="org.eclipse.tracecompass.analysis.profiling.core.tests,org.eclipse.tracecompass.analysis.profiling.ui", + org.eclipse.tracecompass.internal.analysis.profiling.core.callgraph;x-friends:="org.eclipse.tracecompass.analysis.profiling.core.tests,org.eclipse.tracecompass.analysis.profiling.ui,org.eclipse.tracecompass.analysis.callstack.core", org.eclipse.tracecompass.internal.analysis.profiling.core.callstack;x-friends:="org.eclipse.tracecompass.analysis.profiling.core.tests,org.eclipse.tracecompass.analysis.profiling.ui", org.eclipse.tracecompass.internal.analysis.profiling.core.callstack.provider;x-friends:="org.eclipse.tracecompass.analysis.profiling.core.tests,org.eclipse.tracecompass.analysis.profiling.ui" Import-Package: com.google.common.annotations, diff --git a/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callgraph/ICallGraphProvider.java b/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callgraph/ICallGraphProvider.java index 299f5ca0f7..e75c920fdf 100644 --- a/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callgraph/ICallGraphProvider.java +++ b/analysis/org.eclipse.tracecompass.analysis.profiling.core/src/org/eclipse/tracecompass/analysis/profiling/core/callgraph/ICallGraphProvider.java @@ -15,8 +15,6 @@ * Interface that analyses who provide callgraph * * @author Geneviève Bastien - * TODO: Bring methods from the incubator to this interface */ public interface ICallGraphProvider { - }