Correct inclusive time and start tracking maximum exclusive time

runtime/vm/timeline_test.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <cstring>
 
 #include "platform/assert.h"
 
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
@@ skipping 411 matching lines @@
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(10, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(10, pauses.MaxExclusiveTime("a"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "b", 0, 10);
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(0, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(0, pauses.MaxExclusiveTime("a"));
     EXPECT_EQ(10, pauses.InclusiveTime("b"));
     EXPECT_EQ(10, pauses.ExclusiveTime("b"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("b"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("b"));
+    EXPECT_EQ(10, pauses.MaxExclusiveTime("b"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "b", 1, 8);
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(3, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(3, pauses.MaxExclusiveTime("a"));
     EXPECT_EQ(7, pauses.InclusiveTime("b"));
     EXPECT_EQ(7, pauses.ExclusiveTime("b"));
-    EXPECT_EQ(7, pauses.MaxDurationTime("b"));
+    EXPECT_EQ(7, pauses.MaxInclusiveTime("b"));
+    EXPECT_EQ(7, pauses.MaxExclusiveTime("b"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "b", 0, 1);
   TimelineTestHelper::FakeDuration(recorder, "b", 1, 2);
   TimelineTestHelper::FakeDuration(recorder, "b", 2, 3);
   TimelineTestHelper::FakeDuration(recorder, "b", 3, 4);
   TimelineTestHelper::FakeDuration(recorder, "b", 4, 5);
   TimelineTestHelper::FakeDuration(recorder, "b", 5, 6);
   TimelineTestHelper::FakeDuration(recorder, "b", 6, 7);
   TimelineTestHelper::FakeDuration(recorder, "b", 7, 8);
   TimelineTestHelper::FakeDuration(recorder, "b", 8, 9);
   TimelineTestHelper::FakeDuration(recorder, "b", 9, 10);
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(0, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(0, pauses.MaxExclusiveTime("a"));
     EXPECT_EQ(10, pauses.InclusiveTime("b"));
     EXPECT_EQ(10, pauses.ExclusiveTime("b"));
-    EXPECT_EQ(1, pauses.MaxDurationTime("b"));
+    EXPECT_EQ(1, pauses.MaxInclusiveTime("b"));
+    EXPECT_EQ(1, pauses.MaxExclusiveTime("b"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "b", 0, 5);
   TimelineTestHelper::FakeDuration(recorder, "c", 1, 4);
   TimelineTestHelper::FakeDuration(recorder, "d", 5, 10);
 
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(0, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(0, pauses.MaxExclusiveTime("a"));
     EXPECT_EQ(5, pauses.InclusiveTime("b"));
     EXPECT_EQ(2, pauses.ExclusiveTime("b"));
-    EXPECT_EQ(5, pauses.MaxDurationTime("b"));
+    EXPECT_EQ(5, pauses.MaxInclusiveTime("b"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("b"));
     EXPECT_EQ(3, pauses.InclusiveTime("c"));
     EXPECT_EQ(3, pauses.ExclusiveTime("c"));
-    EXPECT_EQ(3, pauses.MaxDurationTime("c"));
+    EXPECT_EQ(3, pauses.MaxInclusiveTime("c"));
+    EXPECT_EQ(3, pauses.MaxExclusiveTime("c"));
     EXPECT_EQ(5, pauses.InclusiveTime("d"));
     EXPECT_EQ(5, pauses.ExclusiveTime("d"));
-    EXPECT_EQ(5, pauses.MaxDurationTime("d"));
+    EXPECT_EQ(5, pauses.MaxInclusiveTime("d"));
+    EXPECT_EQ(5, pauses.MaxExclusiveTime("d"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "b", 1, 9);
   TimelineTestHelper::FakeDuration(recorder, "c", 2, 8);
   TimelineTestHelper::FakeDuration(recorder, "d", 3, 7);
   TimelineTestHelper::FakeDuration(recorder, "e", 4, 6);
 
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
     EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(2, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("a"));
     EXPECT_EQ(8, pauses.InclusiveTime("b"));
     EXPECT_EQ(2, pauses.ExclusiveTime("b"));
-    EXPECT_EQ(8, pauses.MaxDurationTime("b"));
+    EXPECT_EQ(8, pauses.MaxInclusiveTime("b"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("b"));
     EXPECT_EQ(6, pauses.InclusiveTime("c"));
     EXPECT_EQ(2, pauses.ExclusiveTime("c"));
-    EXPECT_EQ(6, pauses.MaxDurationTime("c"));
+    EXPECT_EQ(6, pauses.MaxInclusiveTime("c"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("c"));
     EXPECT_EQ(4, pauses.InclusiveTime("d"));
     EXPECT_EQ(2, pauses.ExclusiveTime("d"));
-    EXPECT_EQ(4, pauses.MaxDurationTime("d"));
+    EXPECT_EQ(4, pauses.MaxInclusiveTime("d"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("d"));
     EXPECT_EQ(2, pauses.InclusiveTime("e"));
     EXPECT_EQ(2, pauses.ExclusiveTime("e"));
-    EXPECT_EQ(2, pauses.MaxDurationTime("e"));
+    EXPECT_EQ(2, pauses.MaxInclusiveTime("e"));
+    EXPECT_EQ(2, pauses.MaxExclusiveTime("e"));
   }
   TimelineTestHelper::Clear(recorder);
 
   // Test case.
   TimelineTestHelper::FakeDuration(recorder, "a", 0, 10);
   TimelineTestHelper::FakeDuration(recorder, "a", 1, 9);
 
   {
     TimelinePauses pauses(zone, isolate, recorder);
     pauses.Setup();
     pauses.CalculatePauseTimesForThread(tid);
     EXPECT(!pauses.has_error());
-    EXPECT_EQ(18, pauses.InclusiveTime("a"));
+    EXPECT_EQ(10, pauses.InclusiveTime("a"));
     EXPECT_EQ(10, pauses.ExclusiveTime("a"));
-    EXPECT_EQ(10, pauses.MaxDurationTime("a"));
+    EXPECT_EQ(10, pauses.MaxInclusiveTime("a"));
+    EXPECT_EQ(8, pauses.MaxExclusiveTime("a"));
   }
   TimelineTestHelper::Clear(recorder);
 }
 
 }  // namespace dart