timing: Update callgraph to use Statistics

The aggregated function statistics have one statistics object for
durations, one for self times.

Change-Id: I6f36f653bb082915d7cc7a03a09e9bcc4947aa48
Signed-off-by: Geneviève Bastien <gbastien+lttng@versatic.net>
Reviewed-on: https://git.eclipse.org/r/88903
Reviewed-by: Hudson CI
Reviewed-by: Matthew Khouzam <matthew.khouzam@ericsson.com>
Tested-by: Matthew Khouzam <matthew.khouzam@ericsson.com>

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/src/org/eclipse/tracecompass/analysis/timing/core/tests/flamegraph/AggregatedCalledFunctionStatisticsTest.java b/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/src/org/eclipse/tracecompass/analysis/timing/core/tests/flamegraph/AggregatedCalledFunctionStatisticsTest.java
index 2afb80be21c346ea1a6c367efdadc08171013cea..8aac31cfc0bbf9a3ddb37fd34d9356a638528483 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/src/org/eclipse/tracecompass/analysis/timing/core/tests/flamegraph/AggregatedCalledFunctionStatisticsTest.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.core.tests/src/org/eclipse/tracecompass/analysis/timing/core/tests/flamegraph/AggregatedCalledFunctionStatisticsTest.java
@@ -117,39 +117,39 @@ public class AggregatedCalledFunctionStatisticsTest {
         // Test the main statistics
         @NonNull
         AggregatedCalledFunctionStatistics mainStatistics1 = firstFunction.getFunctionStatistics();
-        assertEquals("Test main's maximum duration", 100, mainStatistics1.getMax());
-        assertEquals("Test main's minimum duration", 100, mainStatistics1.getMin());
-        assertEquals("Test main's maximum self time", 20, mainStatistics1.getMaxSelfTime());
-        assertEquals("Test main's minimum self time", 20, mainStatistics1.getMinSelfTime());
-        assertEquals("Test main's number of calls", 1, mainStatistics1.getNbSegments());
-        assertEquals("Test main's average duration", 100, mainStatistics1.getAverage(), ERROR);
-        assertEquals("Test main's standard deviation", 20, mainStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDev(), ERROR);
-        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test main's maximum duration", 100, mainStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test main's minimum duration", 100, mainStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test main's maximum self time", 20, mainStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test main's minimum self time", 20, mainStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test main's number of calls", 1, mainStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test main's average duration", 100, mainStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test main's standard deviation", 20, mainStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the first function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics1 = SecondFunction.getFunctionStatistics();
-        assertEquals("Test first function's maximum duration", 50, functionStatistics1.getMax());
-        assertEquals("Test first function's minimum duration", 30, functionStatistics1.getMin());
-        assertEquals("Test first function's maximum self time", 30, functionStatistics1.getMaxSelfTime());
-        assertEquals("Test first function's mininmum self time", 20, functionStatistics1.getMinSelfTime());
-        assertEquals("Test first function's number of calls", 2, functionStatistics1.getNbSegments());
-        assertEquals("Test first function's average duration", 40, functionStatistics1.getAverage(), ERROR);
-        assertEquals("Test first function's average self time", 25, functionStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
-        assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test first function's maximum duration", 50, functionStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test first function's minimum duration", 30, functionStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test first function's maximum self time", 30, functionStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test first function's mininmum self time", 20, functionStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test first function's number of calls", 2, functionStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test first function's average duration", 40, functionStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test first function's average self time", 25, functionStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the third function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics2 = ThirdFunction.getFunctionStatistics();
-        assertEquals("Test second function's maximum duration", 30, functionStatistics2.getMax());
-        assertEquals("Test second function's minimum duration", 30, functionStatistics2.getMin());
-        assertEquals("Test second function's maximum self time", 30, functionStatistics2.getMaxSelfTime());
-        assertEquals("Test second function's minimum self time", 30, functionStatistics2.getMinSelfTime());
-        assertEquals("Test second function's number of calls", 1, functionStatistics2.getNbSegments());
-        assertEquals("Test second function's average duration", 30, functionStatistics2.getAverage(), ERROR);
-        assertEquals("Test second function's average self time", 30, functionStatistics2.getAverageSelfTime(), ERROR);
-        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
-        assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
+        assertEquals("Test second function's maximum duration", 30, functionStatistics2.getDurationStatistics().getMax());
+        assertEquals("Test second function's minimum duration", 30, functionStatistics2.getDurationStatistics().getMin());
+        assertEquals("Test second function's maximum self time", 30, functionStatistics2.getSelfTimeStatistics().getMax());
+        assertEquals("Test second function's minimum self time", 30, functionStatistics2.getSelfTimeStatistics().getMin());
+        assertEquals("Test second function's number of calls", 1, functionStatistics2.getDurationStatistics().getNbElements());
+        assertEquals("Test second function's average duration", 30, functionStatistics2.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test second function's average self time", 30, functionStatistics2.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getSelfTimeStatistics().getStdDev(), ERROR);
         cga.dispose();
     }
 
@@ -204,51 +204,51 @@ public class AggregatedCalledFunctionStatisticsTest {
         // Test the first function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics1 = firstFunction.getFunctionStatistics();
-        assertEquals("Test first function's maximum duration", 100, functionStatistics1.getMax());
-        assertEquals("Test first function's minimum duration", 100, functionStatistics1.getMin());
-        assertEquals("Test first function's maximum self time", 20, functionStatistics1.getMaxSelfTime());
-        assertEquals("Test first function's minimum self time", 20, functionStatistics1.getMinSelfTime());
-        assertEquals("Test first function's number of segments", 1, functionStatistics1.getNbSegments());
-        assertEquals("Test first function's average duration", 100, functionStatistics1.getAverage(), ERROR);
-        assertEquals("Test first function's average self time", 20, functionStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
-        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test first function's maximum duration", 100, functionStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test first function's minimum duration", 100, functionStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test first function's maximum self time", 20, functionStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test first function's minimum self time", 20, functionStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test first function's number of segments", 1, functionStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test first function's average duration", 100, functionStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test first function's average self time", 20, functionStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the first function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics2 = secondFunction.getFunctionStatistics();
-        assertEquals("Test second function's maximum duration", 50, functionStatistics2.getMax());
-        assertEquals("Test second function's minimum duration", 30, functionStatistics2.getMin());
-        assertEquals("Test second function's maximum self time", 20, functionStatistics2.getMaxSelfTime());
-        assertEquals("Test second function's minimum self time", 10, functionStatistics2.getMinSelfTime());
-        assertEquals("Test second function's number of calls", 2, functionStatistics2.getNbSegments());
-        assertEquals("Test second function's average duration", 40, functionStatistics2.getAverage(), ERROR);
-        assertEquals("Test second function's average self time", 15, functionStatistics2.getAverageSelfTime(), ERROR);
-        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
-        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
+        assertEquals("Test second function's maximum duration", 50, functionStatistics2.getDurationStatistics().getMax());
+        assertEquals("Test second function's minimum duration", 30, functionStatistics2.getDurationStatistics().getMin());
+        assertEquals("Test second function's maximum self time", 20, functionStatistics2.getSelfTimeStatistics().getMax());
+        assertEquals("Test second function's minimum self time", 10, functionStatistics2.getSelfTimeStatistics().getMin());
+        assertEquals("Test second function's number of calls", 2, functionStatistics2.getDurationStatistics().getNbElements());
+        assertEquals("Test second function's average duration", 40, functionStatistics2.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test second function's average self time", 15, functionStatistics2.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the first leaf statistics
         @NonNull
         AggregatedCalledFunctionStatistics leafStatistics1 = leaf1.getFunctionStatistics();
-        assertEquals("Test first leaf's maximum duration", 30, leafStatistics1.getMax());
-        assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getMin());
-        assertEquals("Test first leaf's maximum self time", 30, leafStatistics1.getMaxSelfTime());
-        assertEquals("Test first leaf's minimum self time", 30, leafStatistics1.getMinSelfTime());
-        assertEquals("Test first leaf's number of calls", 1, leafStatistics1.getNbSegments());
-        assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getAverage(), ERROR);
-        assertEquals("Test first leaf's average self time", 30, leafStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test first leaf's standard deviation", Double.NaN, leafStatistics1.getStdDev(), ERROR);
-        assertEquals("Test first leaf's self time standard deviation", Double.NaN, leafStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test first leaf's maximum duration", 30, leafStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test first leaf's maximum self time", 30, leafStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test first leaf's minimum self time", 30, leafStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test first leaf's number of calls", 1, leafStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test first leaf's minimum duration", 30, leafStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test first leaf's average self time", 30, leafStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test first leaf's standard deviation", Double.NaN, leafStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test first leaf's self time standard deviation", Double.NaN, leafStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the second leaf statistics
         @NonNull
         AggregatedCalledFunctionStatistics leafStatistics2 = leaf2.getFunctionStatistics();
-        assertEquals("Test second leaf's maximum duration", 20, leafStatistics2.getMax());
-        assertEquals("Test second leaf's minimum duration", 20, leafStatistics2.getMin());
-        assertEquals("Test second leaf's maximum self time", 20, leafStatistics2.getMaxSelfTime());
-        assertEquals("Test second leaf's minimum self time", 20, leafStatistics2.getMinSelfTime());
-        assertEquals("Test second leaf's number of calls", 1, leafStatistics2.getNbSegments());
-        assertEquals("Test second leaf's average duration", 20, leafStatistics2.getAverage(), ERROR);
-        assertEquals("Test second leaf's average self time", 20, leafStatistics2.getAverageSelfTime(), ERROR);
-        assertEquals("Test second leaf's standard deviation", Double.NaN, leafStatistics2.getStdDev(), ERROR);
-        assertEquals("Test second leaf's self time standard deviation", Double.NaN, leafStatistics2.getStdDevSelfTime(), ERROR);
+        assertEquals("Test second leaf's maximum duration", 20, leafStatistics2.getDurationStatistics().getMax());
+        assertEquals("Test second leaf's minimum duration", 20, leafStatistics2.getDurationStatistics().getMin());
+        assertEquals("Test second leaf's maximum self time", 20, leafStatistics2.getSelfTimeStatistics().getMax());
+        assertEquals("Test second leaf's minimum self time", 20, leafStatistics2.getSelfTimeStatistics().getMin());
+        assertEquals("Test second leaf's number of calls", 1, leafStatistics2.getDurationStatistics().getNbElements());
+        assertEquals("Test second leaf's average duration", 20, leafStatistics2.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test second leaf's average self time", 20, leafStatistics2.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test second leaf's standard deviation", Double.NaN, leafStatistics2.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test second leaf's self time standard deviation", Double.NaN, leafStatistics2.getSelfTimeStatistics().getStdDev(), ERROR);
         cga.dispose();
     }
 
@@ -298,39 +298,39 @@ public class AggregatedCalledFunctionStatisticsTest {
         // Test the first function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics1 = firstFunction.getFunctionStatistics();
-        assertEquals("Test first function's maximum duration", 50, functionStatistics1.getMax());
-        assertEquals("Test first function's minimum duration", 20, functionStatistics1.getMin());
-        assertEquals("Test first function's maximum self time", 40, functionStatistics1.getMaxSelfTime());
-        assertEquals("Test first function's minimum self time", 10, functionStatistics1.getMinSelfTime());
-        assertEquals("Test first function's number of segments", 2, functionStatistics1.getNbSegments());
-        assertEquals("Test first function's average duration", 35, functionStatistics1.getAverage(), ERROR);
-        assertEquals("Test first function's average self time", 25, functionStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getStdDev(), ERROR);
-        assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test first function's maximum duration", 50, functionStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test first function's minimum duration", 20, functionStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test first function's maximum self time", 40, functionStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test first function's minimum self time", 10, functionStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test first function's number of segments", 2, functionStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test first function's average duration", 35, functionStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test first function's average self time", 25, functionStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test first function's standard deviation", Double.NaN, functionStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test first function's self time standard deviation", Double.NaN, functionStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the second function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics2 = function2.getFunctionStatistics();
-        assertEquals("Test second function's maximum duration", 10, functionStatistics2.getMax());
-        assertEquals("Test second function's minimum duration", 10, functionStatistics2.getMin());
-        assertEquals("Test second function's maximum self time", 10, functionStatistics2.getMaxSelfTime());
-        assertEquals("Test second function's minimum self time", 10, functionStatistics2.getMinSelfTime());
-        assertEquals("Test second function's number of calls", 1, functionStatistics2.getNbSegments());
-        assertEquals("Test second function's average duration", 10, functionStatistics2.getAverage(), ERROR);
-        assertEquals("Test second function's average self time", 10, functionStatistics2.getAverageSelfTime(), ERROR);
-        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getStdDev(), ERROR);
-        assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getStdDevSelfTime(), ERROR);
+        assertEquals("Test second function's maximum duration", 10, functionStatistics2.getDurationStatistics().getMax());
+        assertEquals("Test second function's minimum duration", 10, functionStatistics2.getDurationStatistics().getMin());
+        assertEquals("Test second function's maximum self time", 10, functionStatistics2.getSelfTimeStatistics().getMax());
+        assertEquals("Test second function's minimum self time", 10, functionStatistics2.getSelfTimeStatistics().getMin());
+        assertEquals("Test second function's number of calls", 1, functionStatistics2.getDurationStatistics().getNbElements());
+        assertEquals("Test second function's average duration", 10, functionStatistics2.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test second function's average self time", 10, functionStatistics2.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test second function's standard deviation", Double.NaN, functionStatistics2.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test second function's self time standard deviation", Double.NaN, functionStatistics2.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the third function statistics
         @NonNull
         AggregatedCalledFunctionStatistics functionStatistics3 = function3.getFunctionStatistics();
-        assertEquals("Test third function's maximum duration", 10, functionStatistics3.getMax());
-        assertEquals("Test third function's minimum duration", 10, functionStatistics3.getMin());
-        assertEquals("Test third function's maximum selftime", 10, functionStatistics3.getMaxSelfTime());
-        assertEquals("Test third function's minimum self time", 10, functionStatistics3.getMinSelfTime());
-        assertEquals("Test third function's number of calls", 1, functionStatistics3.getNbSegments());
-        assertEquals("Test third function's average duration", 10, functionStatistics3.getAverage(), ERROR);
-        assertEquals("Test third function's average self time", 10, functionStatistics3.getAverageSelfTime(), ERROR);
-        assertEquals("Test third function's standard deviation", Double.NaN, functionStatistics3.getStdDev(), ERROR);
-        assertEquals("Test third function's self time standard deviation", Double.NaN, functionStatistics3.getStdDevSelfTime(), ERROR);
+        assertEquals("Test third function's maximum duration", 10, functionStatistics3.getDurationStatistics().getMax());
+        assertEquals("Test third function's minimum duration", 10, functionStatistics3.getDurationStatistics().getMin());
+        assertEquals("Test third function's maximum selftime", 10, functionStatistics3.getSelfTimeStatistics().getMax());
+        assertEquals("Test third function's minimum self time", 10, functionStatistics3.getSelfTimeStatistics().getMin());
+        assertEquals("Test third function's number of calls", 1, functionStatistics3.getDurationStatistics().getNbElements());
+        assertEquals("Test third function's average duration", 10, functionStatistics3.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test third function's average self time", 10, functionStatistics3.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test third function's standard deviation", Double.NaN, functionStatistics3.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test third function's self time standard deviation", Double.NaN, functionStatistics3.getSelfTimeStatistics().getStdDev(), ERROR);
         cga.dispose();
     }
 
@@ -419,59 +419,59 @@ public class AggregatedCalledFunctionStatisticsTest {
         AggregatedCalledFunction function4 = (AggregatedCalledFunction) firstChildCallee[0];
         // Test the main function statistics
         AggregatedCalledFunctionStatistics mainStatistics1 = main.getFunctionStatistics();
-        assertEquals("Test main's maximum duration", 150, mainStatistics1.getMax());
-        assertEquals("Test main's minimum duration", 150, mainStatistics1.getMin());
-        assertEquals("Test main's maximum self time", 40, mainStatistics1.getMaxSelfTime());
-        assertEquals("Test main's minimum self time", 40, mainStatistics1.getMinSelfTime());
-        assertEquals("Test main's number of calls", 1, mainStatistics1.getNbSegments());
-        assertEquals("Test main's average duration", 150, mainStatistics1.getAverage(), ERROR);
-        assertEquals("Test main's average self time", 40, mainStatistics1.getAverageSelfTime(), ERROR);
-        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getStdDev(), ERROR);
-        assertEquals("Test main's self time standard deviation", Double.NaN, mainStatistics1.getStdDevSelfTime(), ERROR);
+        assertEquals("Test main's maximum duration", 150, mainStatistics1.getDurationStatistics().getMax());
+        assertEquals("Test main's minimum duration", 150, mainStatistics1.getDurationStatistics().getMin());
+        assertEquals("Test main's maximum self time", 40, mainStatistics1.getSelfTimeStatistics().getMax());
+        assertEquals("Test main's minimum self time", 40, mainStatistics1.getSelfTimeStatistics().getMin());
+        assertEquals("Test main's number of calls", 1, mainStatistics1.getDurationStatistics().getNbElements());
+        assertEquals("Test main's average duration", 150, mainStatistics1.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test main's average self time", 40, mainStatistics1.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test main's standard deviation", Double.NaN, mainStatistics1.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test main's self time standard deviation", Double.NaN, mainStatistics1.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the first function statistics
         AggregatedCalledFunctionStatistics firstFunctionStatistics = function1.getFunctionStatistics();
-        assertEquals("Test first function's maximum duration", 50, firstFunctionStatistics.getMax());
-        assertEquals("Test first function's minimum duration", 20, firstFunctionStatistics.getMin());
-        assertEquals("Test first function's maximum self time", 30, firstFunctionStatistics.getMaxSelfTime());
-        assertEquals("Test first function's minimum self time", 10, firstFunctionStatistics.getMinSelfTime());
-        assertEquals("Test first function's number of segments", 3, firstFunctionStatistics.getNbSegments());
-        assertEquals("Test first function's average duration", 36.666666667, firstFunctionStatistics.getAverage(), ERROR);
-        assertEquals("Test first function's average self time", 20, firstFunctionStatistics.getAverageSelfTime(), ERROR);
-        assertEquals("Test first function's standard deviation", 15.275252316, firstFunctionStatistics.getStdDev(), ERROR);
-        assertEquals("Test first function's self time standard deviation", 10, firstFunctionStatistics.getStdDevSelfTime(), ERROR);
+        assertEquals("Test first function's maximum duration", 50, firstFunctionStatistics.getDurationStatistics().getMax());
+        assertEquals("Test first function's minimum duration", 20, firstFunctionStatistics.getDurationStatistics().getMin());
+        assertEquals("Test first function's maximum self time", 30, firstFunctionStatistics.getSelfTimeStatistics().getMax());
+        assertEquals("Test first function's minimum self time", 10, firstFunctionStatistics.getSelfTimeStatistics().getMin());
+        assertEquals("Test first function's number of segments", 3, firstFunctionStatistics.getDurationStatistics().getNbElements());
+        assertEquals("Test first function's average duration", 36.666666667, firstFunctionStatistics.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test first function's average self time", 20, firstFunctionStatistics.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test first function's standard deviation", 15.275252316, firstFunctionStatistics.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test first function's self time standard deviation", 10, firstFunctionStatistics.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the second function statistics
         AggregatedCalledFunctionStatistics secondFunctionStatistics2 = function2.getFunctionStatistics();
-        assertEquals("Test second function's maximum duration", 30, secondFunctionStatistics2.getMax());
-        assertEquals("Test second function's minimum duration", 10, secondFunctionStatistics2.getMin());
-        assertEquals("Test second function's maximum self time", 10, secondFunctionStatistics2.getMaxSelfTime());
-        assertEquals("Test second function's minimum self time", 0, secondFunctionStatistics2.getMinSelfTime());
-        assertEquals("Test second function's number of segments", 2, secondFunctionStatistics2.getNbSegments());
-        assertEquals("Test second function's average duration", 20, secondFunctionStatistics2.getAverage(), ERROR);
-        assertEquals("Test second function's average self time", 5, secondFunctionStatistics2.getAverageSelfTime(), ERROR);
-        assertEquals("Test second function's standard deviation", Double.NaN, secondFunctionStatistics2.getStdDev(), ERROR);
-        assertEquals("Test second function's self time standard deviation", Double.NaN, secondFunctionStatistics2.getStdDevSelfTime(), ERROR);
+        assertEquals("Test second function's maximum duration", 30, secondFunctionStatistics2.getDurationStatistics().getMax());
+        assertEquals("Test second function's minimum duration", 10, secondFunctionStatistics2.getDurationStatistics().getMin());
+        assertEquals("Test second function's maximum self time", 10, secondFunctionStatistics2.getSelfTimeStatistics().getMax());
+        assertEquals("Test second function's minimum self time", 0, secondFunctionStatistics2.getSelfTimeStatistics().getMin());
+        assertEquals("Test second function's number of segments", 2, secondFunctionStatistics2.getDurationStatistics().getNbElements());
+        assertEquals("Test second function's average duration", 20, secondFunctionStatistics2.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test second function's average self time", 5, secondFunctionStatistics2.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test second function's standard deviation", Double.NaN, secondFunctionStatistics2.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test second function's self time standard deviation", Double.NaN, secondFunctionStatistics2.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the third function statistics
         AggregatedCalledFunctionStatistics thirdFunctionStatistics3 = function3.getFunctionStatistics();
-        assertEquals("Test third function's maximum duration", 10, thirdFunctionStatistics3.getMax());
-        assertEquals("Test third function's minimum duration", 10, thirdFunctionStatistics3.getMin());
-        assertEquals("Test third function's maximum self time", 10, thirdFunctionStatistics3.getMaxSelfTime());
-        assertEquals("Test third function's minimum self time", 10, thirdFunctionStatistics3.getMinSelfTime());
-        assertEquals("Test third function's number of segments", 1, thirdFunctionStatistics3.getNbSegments());
-        assertEquals("Test third function's average duration", 10, thirdFunctionStatistics3.getAverage(), ERROR);
-        assertEquals("Test third function's average self time", 10, thirdFunctionStatistics3.getAverageSelfTime(), ERROR);
-        assertEquals("Test third function's self time deviation", Double.NaN, thirdFunctionStatistics3.getStdDev(), ERROR);
-        assertEquals("Test third function's self time standard deviation", Double.NaN, thirdFunctionStatistics3.getStdDev(), ERROR);
+        assertEquals("Test third function's maximum duration", 10, thirdFunctionStatistics3.getDurationStatistics().getMax());
+        assertEquals("Test third function's minimum duration", 10, thirdFunctionStatistics3.getDurationStatistics().getMin());
+        assertEquals("Test third function's maximum self time", 10, thirdFunctionStatistics3.getSelfTimeStatistics().getMax());
+        assertEquals("Test third function's minimum self time", 10, thirdFunctionStatistics3.getSelfTimeStatistics().getMin());
+        assertEquals("Test third function's number of segments", 1, thirdFunctionStatistics3.getDurationStatistics().getNbElements());
+        assertEquals("Test third function's average duration", 10, thirdFunctionStatistics3.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test third function's average self time", 10, thirdFunctionStatistics3.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test third function's self time deviation", Double.NaN, thirdFunctionStatistics3.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test third function's self time standard deviation", Double.NaN, thirdFunctionStatistics3.getSelfTimeStatistics().getStdDev(), ERROR);
         // Test the fourth function statistics
         AggregatedCalledFunctionStatistics fourthFunctionStatistics4 = function4.getFunctionStatistics();
-        assertEquals("Test fourth function's maximum duration", 20, fourthFunctionStatistics4.getMax());
-        assertEquals("Test fourth function's minimum duration", 10, fourthFunctionStatistics4.getMin());
-        assertEquals("Test fourth function's maximum self time", 20, fourthFunctionStatistics4.getMaxSelfTime());
-        assertEquals("Test fourth function's maximum self time", 10, fourthFunctionStatistics4.getMinSelfTime());
-        assertEquals("Test fourth function's number of segments", 2, fourthFunctionStatistics4.getNbSegments());
-        assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getAverage(), ERROR);
-        assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getAverageSelfTime(), ERROR);
-        assertEquals("Test fourth function's standard deviation", Double.NaN, fourthFunctionStatistics4.getStdDev(), ERROR);
-        assertEquals("Test fourth function's self time deviation", Double.NaN, fourthFunctionStatistics4.getStdDevSelfTime(), ERROR);
+        assertEquals("Test fourth function's maximum duration", 20, fourthFunctionStatistics4.getDurationStatistics().getMax());
+        assertEquals("Test fourth function's minimum duration", 10, fourthFunctionStatistics4.getDurationStatistics().getMin());
+        assertEquals("Test fourth function's maximum self time", 20, fourthFunctionStatistics4.getSelfTimeStatistics().getMax());
+        assertEquals("Test fourth function's maximum self time", 10, fourthFunctionStatistics4.getSelfTimeStatistics().getMin());
+        assertEquals("Test fourth function's number of segments", 2, fourthFunctionStatistics4.getDurationStatistics().getNbElements());
+        assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getDurationStatistics().getMean(), ERROR);
+        assertEquals("Test fourth function's average duration", 15, fourthFunctionStatistics4.getSelfTimeStatistics().getMean(), ERROR);
+        assertEquals("Test fourth function's standard deviation", Double.NaN, fourthFunctionStatistics4.getDurationStatistics().getStdDev(), ERROR);
+        assertEquals("Test fourth function's self time deviation", Double.NaN, fourthFunctionStatistics4.getSelfTimeStatistics().getStdDev(), ERROR);
         cga.dispose();
     }
 

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunction.java b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunction.java
index 0eeb499e423d5f36b0775808f382d32936579885..46ddf63e8bf3f467b53e39e0d8a63c9f9a1780aa 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunction.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunction.java
@@ -64,7 +64,7 @@ public class AggregatedCalledFunction {
         fProcessId = calledFunction.getProcessId();
         fMaxDepth = parent.getMaxDepth();
         fParent = parent;
-        fStatistics = new AggregatedCalledFunctionStatistics(calledFunction, calledFunction);
+        fStatistics = new AggregatedCalledFunctionStatistics();
     }
 
     /**
@@ -83,7 +83,7 @@ public class AggregatedCalledFunction {
         fProcessId = calledFunction.getProcessId();
         fMaxDepth = maxDepth;
         fParent = null;
-        fStatistics = new AggregatedCalledFunctionStatistics(calledFunction, calledFunction);
+        fStatistics = new AggregatedCalledFunctionStatistics();
     }
 
     /**
@@ -119,18 +119,21 @@ public class AggregatedCalledFunction {
      * it'll combine their callees.
      *
      * @param child
-     *            The callees of a function
+     *            The callee to add to this function
+     * @param aggregatedChild
+     *            The aggregated data of the callee
      */
-    public synchronized void addChild(AggregatedCalledFunction child) {
-        AggregatedCalledFunction node = fChildren.get(child.getSymbol());
+    public synchronized void addChild(AbstractCalledFunction child, AggregatedCalledFunction aggregatedChild) {
+        // Update the child's statistics with itself
+        fSelfTime -= aggregatedChild.getDuration();
+        aggregatedChild.getFunctionStatistics().update(child);
+        AggregatedCalledFunction node = fChildren.get(aggregatedChild.getSymbol());
         if (node == null) {
-            fChildren.put(child.getSymbol(), child);
+            fChildren.put(aggregatedChild.getSymbol(), aggregatedChild);
         } else {
-            merge(node, child);
+            merge(node, aggregatedChild);
             fChildren.replace(node.getSymbol(), node);
         }
-        fSelfTime -= child.fDuration;
-        fStatistics.initializeMaxMinSelfTime(fSelfTime);
     }
 
     /**
@@ -179,7 +182,7 @@ public class AggregatedCalledFunction {
         long sourceSelfTime = source.getSelfTime();
         destination.addToDuration(sourceDuration);
         destination.addToSelfTime(sourceSelfTime);
-        destination.getFunctionStatistics().update(source.getFunctionStatistics(), sourceDuration, sourceSelfTime);
+        destination.getFunctionStatistics().merge(source.getFunctionStatistics());
         // merge the children callees.
         mergeChildren(destination, source);
     }
@@ -217,7 +220,7 @@ public class AggregatedCalledFunction {
      * @return The number of calls of a function
      */
     public long getNbCalls() {
-        return fStatistics.getNbSegments();
+        return fStatistics.getDurationStatistics().getNbElements();
     }
 
     /**

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunctionStatistics.java b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunctionStatistics.java
index b74a3985e3a55cbc3e624f1de342d46de0d9f454..a4d735e96f2e8ee3feb65b57eb1a6f0c8eaf1cd5 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunctionStatistics.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/AggregatedCalledFunctionStatistics.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2016 Ericsson
+ * Copyright (c) 2016, 2017 Ericsson, É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 v1.0 which
@@ -9,57 +9,44 @@
 
 package org.eclipse.tracecompass.internal.analysis.timing.core.callgraph;
 
-import org.eclipse.tracecompass.analysis.timing.core.segmentstore.statistics.SegmentStoreStatistics;
-import org.eclipse.tracecompass.segmentstore.core.ISegment;
+import org.eclipse.tracecompass.analysis.timing.core.statistics.IStatistics;
+import org.eclipse.tracecompass.analysis.timing.core.statistics.Statistics;
 
 /**
  * Class to calculate statistics for an aggregated function.
  *
  * @author Sonia Farrah
+ * @author Geneviève Bastien
  */
-public class AggregatedCalledFunctionStatistics extends SegmentStoreStatistics {
+public class AggregatedCalledFunctionStatistics {
+
+    // Duration statistics will be kept for all calls of the method, so we make
+    // them on the called function themselves
+    private final IStatistics<ICalledFunction> fDurations;
+    // Self time statistics are on aggregated called function because self times
+    // are known only at the end, once the aggregation is over
+    private final IStatistics<ICalledFunction> fSelfTimes;
 
     /**
-     * The maximum self time
-     */
-    private long fMaxSelfTime;
-    /**
-     * The minimum duration
-     */
-    private long fMinSelfTime;
-    /**
-     * The average self time
-     */
-    private double fSelfTimeAverage;
-    /**
-     * The variance of the self time
-     */
-    private double fVariance;
-    /**
-     * The segment with the longest duration
-     */
-    private ISegment fMaxSegment;
-    /**
-     * The segment with the shortest duration
+     * Constructor
      */
-    private ISegment fMinSegment;
+    public AggregatedCalledFunctionStatistics() {
+        fDurations = new Statistics<>(f -> f.getLength());
+        fSelfTimes = new Statistics<>(f -> f.getSelfTime());
+    }
 
     /**
-     * Constructor
+     * Update the durations and self time statistics for a function. This
+     * function should be called only once all the children of the function have
+     * been assigned and the self time will not change anymore, otherwise, the
+     * results will not be accurate for self times.
      *
-     * @param duration
-     *            The function's duration
-     * @param selfTime
-     *            The function's self time
+     * @param function
+     *            The function to add statistics for
      */
-    public AggregatedCalledFunctionStatistics(ISegment duration, ISegment selfTime) {
-        fMaxSelfTime = selfTime.getLength();
-        fMinSelfTime = selfTime.getLength();
-        fSelfTimeAverage = selfTime.getLength();
-        fVariance = 0.0;
-        fMinSegment = duration;
-        fMaxSegment = duration;
-        update(duration);
+    public void update(ICalledFunction function) {
+        fDurations.update(function);
+        fSelfTimes.update(function);
     }
 
     /**
@@ -68,80 +55,33 @@ public class AggregatedCalledFunctionStatistics extends SegmentStoreStatistics {
      *
      * @param statisticsNode
      *            The statistics node to be merged
-     * @param duration
-     *            The function to be merged duration
-     * @param selfTime
-     *            The function to be merged self time
      */
-    public void update(SegmentStoreStatistics statisticsNode, long duration, long selfTime) {
-        merge(statisticsNode);
-        if (fMaxSelfTime < selfTime) {
-            fMaxSelfTime = selfTime;
-        }
-        if (fMinSelfTime > selfTime) {
-            fMinSelfTime = selfTime;
-        }
-        double delta = selfTime - fSelfTimeAverage;
-        fSelfTimeAverage += delta / getNbSegments();
-        fVariance += delta * (selfTime - fSelfTimeAverage);
+    public void merge(AggregatedCalledFunctionStatistics statisticsNode) {
+        fDurations.merge(statisticsNode.fDurations);
+        fSelfTimes.merge(statisticsNode.fSelfTimes);
     }
 
     /**
-     * Get the maximum self time
+     * Get the statistics for the duration of the called functions
      *
-     * @return The maximum self time
+     * @return The durations statistics
      */
-    public long getMaxSelfTime() {
-        return fMaxSelfTime;
+    public IStatistics<ICalledFunction> getDurationStatistics() {
+        return fDurations;
     }
 
     /**
-     * Get the minimum self time
+     * Get the statistics for the self times of the called functions
      *
-     * @return The minimum self time
+     * @return The self time statistics
      */
-    public long getMinSelfTime() {
-        return fMinSelfTime;
-    }
-
-    /**
-     * Get the average self time
-     *
-     * @return The average self time
-     */
-    public double getAverageSelfTime() {
-        return fSelfTimeAverage;
-    }
-
-    /**
-     * Get the standard deviation of the self time
-     *
-     * @return The standard deviation of the self time
-     */
-    public double getStdDevSelfTime() {
-        long nbSegments = getNbSegments();
-        return nbSegments > 2 ? Math.sqrt(fVariance / (nbSegments - 1)) : Double.NaN;
-    }
-
-    /**
-     * Initialize the maximum and minimum self time
-     *
-     * @param selfTime
-     *            Self time
-     */
-    public void initializeMaxMinSelfTime(long selfTime) {
-        fMaxSelfTime = selfTime;
-        fMinSelfTime = selfTime;
-        fSelfTimeAverage = selfTime;
+    public IStatistics<ICalledFunction> getSelfTimeStatistics() {
+        return fSelfTimes;
     }
 
     @Override
-    public ISegment getMaxSegment() {
-        return fMaxSegment;
+    public String toString() {
+        return "Aggregated function statistics: Durations: " + fDurations + ", Self times " + fSelfTimes; //$NON-NLS-1$//$NON-NLS-2$
     }
 
-    @Override
-    public ISegment getMinSegment() {
-        return fMinSegment;
-    }
 }

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/CallGraphAnalysis.java b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/CallGraphAnalysis.java
index 1d91a2b332645008ef9e1c2cfcc41c32abb6d4cc..4f7791222b331c5b399cbbfd6df44816b81d205a 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/CallGraphAnalysis.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.core/src/org/eclipse/tracecompass/internal/analysis/timing/core/callgraph/CallGraphAnalysis.java
@@ -251,13 +251,13 @@ public abstract class CallGraphAnalysis extends TmfAbstractAnalysisModule implem
                     long intervalStart = interval.getStartTime();
                     long intervalEnd = interval.getEndTime();
                     // Create the segment for the first call event.
-                    AbstractCalledFunction segment = CalledFunctionFactory.create(intervalStart, intervalEnd + 1, depth, stateValue, processId, null);
-                    fRootFunctions.add(segment);
-                    AggregatedCalledFunction firstNode = new AggregatedCalledFunction(segment, fCurrentQuarks.size());
-                    if (!findChildren(segment, depth, stateSystem, fCurrentQuarks.size() + fCurrentQuarks.get(depth), firstNode, processId, monitor)) {
+                    AbstractCalledFunction rootFunction = CalledFunctionFactory.create(intervalStart, intervalEnd + 1, depth, stateValue, processId, null);
+                    fRootFunctions.add(rootFunction);
+                    AggregatedCalledFunction firstNode = new AggregatedCalledFunction(rootFunction, fCurrentQuarks.size());
+                    if (!findChildren(rootFunction, depth, stateSystem, fCurrentQuarks.size() + fCurrentQuarks.get(depth), firstNode, processId, monitor)) {
                         return false;
                     }
-                    init.addChild(firstNode);
+                    init.addChild(rootFunction, firstNode);
                 }
 
                 curTime = interval.getEndTime() + 1;
@@ -317,12 +317,13 @@ public abstract class CallGraphAnalysis extends TmfAbstractAnalysisModule implem
                 if (intervalStart < node.getStart() || intervalEnd > limit) {
                     return true;
                 }
-                AbstractCalledFunction segment = CalledFunctionFactory.create(intervalStart, intervalEnd + 1, node.getDepth() + 1, stateValue, processId, node);
-                AggregatedCalledFunction childNode = new AggregatedCalledFunction(segment, aggregatedCalledFunction);
+                AbstractCalledFunction function = CalledFunctionFactory.create(intervalStart, intervalEnd + 1, node.getDepth() + 1, stateValue, processId, node);
+                AggregatedCalledFunction childNode = new AggregatedCalledFunction(function, aggregatedCalledFunction);
                 // Search for the children with the next quark.
-                findChildren(segment, depth + 1, ss, maxQuark, childNode, processId, monitor);
-                aggregatedCalledFunction.addChild(childNode);
-                node.addChild(segment);
+                findChildren(function, depth + 1, ss, maxQuark, childNode, processId, monitor);
+                node.addChild(function);
+                aggregatedCalledFunction.addChild(function, childNode);
+
             }
             curTime = interval.getEndTime() + 1;
         }

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphPresentationProvider.java b/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphPresentationProvider.java
index 8b70648c18a2b465c3aae12bd084923fb61b2d60..6f0fe8e7a19cc31f97aefb8d39e606d07676a4f2 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphPresentationProvider.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphPresentationProvider.java
@@ -18,6 +18,7 @@ import org.eclipse.swt.graphics.RGB;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.tracecompass.analysis.timing.ui.views.segmentstore.SubSecondTimeWithUnitFormat;
 import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.AggregatedCalledFunctionStatistics;
+import org.eclipse.tracecompass.internal.analysis.timing.core.callgraph.ICalledFunction;
 import org.eclipse.tracecompass.tmf.core.trace.ITmfTrace;
 import org.eclipse.tracecompass.tmf.core.trace.TmfTraceManager;
 import org.eclipse.tracecompass.tmf.ui.symbols.ISymbolProvider;
@@ -90,19 +91,19 @@ public class FlameGraphPresentationProvider extends TimeGraphPresentationProvide
     public Map<String, String> getEventHoverToolTipInfo(ITimeEvent event, long hoverTime) {
         AggregatedCalledFunctionStatistics statistics = ((FlamegraphEvent) event).getStatistics();
         ImmutableMap.Builder<String, String> builder = new ImmutableMap.Builder<>();
-        builder.put(Messages.FlameGraph_NbCalls, NumberFormat.getIntegerInstance().format(statistics.getNbSegments())); // $NON-NLS-1$
+        builder.put(Messages.FlameGraph_NbCalls, NumberFormat.getIntegerInstance().format(statistics.getDurationStatistics().getNbElements())); // $NON-NLS-1$
         builder.put(String.valueOf(Messages.FlameGraph_Durations), ""); //$NON-NLS-1$
         builder.put("\t" + Messages.FlameGraph_Duration, FORMATTER.format(event.getDuration())); //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_AverageDuration, FORMATTER.format(statistics.getAverage())); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_MaxDuration, FORMATTER.format((statistics.getMax()))); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_MinDuration, FORMATTER.format(statistics.getMin())); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_Deviation, FORMATTER.format(statistics.getStdDev())); //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_AverageDuration, FORMATTER.format(statistics.getDurationStatistics().getMean())); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_MaxDuration, FORMATTER.format((statistics.getDurationStatistics().getMax()))); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_MinDuration, FORMATTER.format(statistics.getDurationStatistics().getMin())); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_Deviation, FORMATTER.format(statistics.getDurationStatistics().getStdDev())); //$NON-NLS-1$
         builder.put(Messages.FlameGraph_SelfTimes, ""); //$NON-NLS-1$
         builder.put("\t" + Messages.FlameGraph_SelfTime, FORMATTER.format(((FlamegraphEvent) event).getSelfTime())); //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_AverageSelfTime, FORMATTER.format(statistics.getAverageSelfTime())); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_MaxSelfTime, FORMATTER.format(statistics.getMaxSelfTime())); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_MinSelfTime, FORMATTER.format(statistics.getMinSelfTime())); // $NON-NLS-1$ //$NON-NLS-1$
-        builder.put("\t" + Messages.FlameGraph_SelfTimeDeviation, FORMATTER.format(statistics.getStdDevSelfTime())); //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_AverageSelfTime, FORMATTER.format(statistics.getSelfTimeStatistics().getMean())); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_MaxSelfTime, FORMATTER.format(statistics.getSelfTimeStatistics().getMax())); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_MinSelfTime, FORMATTER.format(statistics.getSelfTimeStatistics().getMin())); // $NON-NLS-1$ //$NON-NLS-1$
+        builder.put("\t" + Messages.FlameGraph_SelfTimeDeviation, FORMATTER.format(statistics.getSelfTimeStatistics().getStdDev())); //$NON-NLS-1$
         return builder.build();
 
     }
@@ -135,7 +136,11 @@ public class FlameGraphPresentationProvider extends TimeGraphPresentationProvide
                 return "0x" + Long.toHexString(longAddress); //$NON-NLS-1$
             }
             // take time of max segment for time a query the symbol name
-            long time = event.getStatistics().getMaxSegment().getStart();
+            ICalledFunction maxObject = event.getStatistics().getDurationStatistics().getMaxObject();
+            if (maxObject == null) {
+                return "0x" + Long.toHexString(longAddress); //$NON-NLS-1$
+            }
+            long time = maxObject.getStart();
             int pid = event.getProcessId();
             if (pid > 0) {
                 String text = symbolProvider.getSymbolText(pid, time, longAddress);

diff --git a/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphView.java b/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphView.java
index 463b901a7c07660898ecad120d9a406915f5bf38..0d63809ff0d20c3bcaf66f5389b17da2a8f33712 100644 (file)
--- a/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphView.java
+++ b/analysis/org.eclipse.tracecompass.analysis.timing.ui/src/org/eclipse/tracecompass/internal/analysis/timing/ui/flamegraph/FlameGraphView.java
@@ -317,7 +317,10 @@ public class FlameGraphView extends TmfView {
                     menuManager.add(new Action(Messages.FlameGraphView_GotoMaxDuration) {
                         @Override
                         public void run() {
-                            ISegment maxSeg = flamegraphEvent.getStatistics().getMaxSegment();
+                            ISegment maxSeg = flamegraphEvent.getStatistics().getDurationStatistics().getMaxObject();
+                            if (maxSeg == null) {
+                                return;
+                            }
                             TmfSelectionRangeUpdatedSignal sig = new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromNanos(maxSeg.getStart()), TmfTimestamp.fromNanos(maxSeg.getEnd()));
                             broadcast(sig);
                         }
@@ -326,7 +329,10 @@ public class FlameGraphView extends TmfView {
                     menuManager.add(new Action(Messages.FlameGraphView_GotoMinDuration) {
                         @Override
                         public void run() {
-                            ISegment minSeg = flamegraphEvent.getStatistics().getMinSegment();
+                            ISegment minSeg = flamegraphEvent.getStatistics().getDurationStatistics().getMinObject();
+                            if (minSeg == null) {
+                                return;
+                            }
                             TmfSelectionRangeUpdatedSignal sig = new TmfSelectionRangeUpdatedSignal(this, TmfTimestamp.fromNanos(minSeg.getStart()), TmfTimestamp.fromNanos(minSeg.getEnd()));
                             broadcast(sig);
                         }