Tracked objects: Bump cumulative byte count storage to 64 bits to avoid saturation

base/tracked_objects_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Test of classes in the tracked_objects.h classes.
 
 #include "base/tracked_objects.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 328 matching lines @@
   const int32_t kLargerMaxAllocatedBytes = kMaxAllocatedBytes * 2;
   data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
                           kAllocOverheadBytes, kLargerMaxAllocatedBytes);
   EXPECT_EQ(data->alloc_ops(), 3 * kAllocOps);
   EXPECT_EQ(data->free_ops(), 3 * kFreeOps);
   EXPECT_EQ(data->allocated_bytes(), 3 * kAllocatedBytes);
   EXPECT_EQ(data->freed_bytes(), 3 * kFreedBytes);
   EXPECT_EQ(data->alloc_overhead_bytes(), 3 * kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), kLargerMaxAllocatedBytes);
 
-  // Saturate everything.
+  // Saturate the counts.
   data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX);

[gab, 2017/05/02 21:17:12]

INT_MAX no longer saturates though right?

[Sigurður Ásgeirsson, 2017/05/03 14:10:10]

Comment amended to moar specific specificity.

   EXPECT_EQ(data->alloc_ops(), INT_MAX);
   EXPECT_EQ(data->free_ops(), INT_MAX);
-  EXPECT_EQ(data->allocated_bytes(), INT_MAX);
-  EXPECT_EQ(data->freed_bytes(), INT_MAX);
-  EXPECT_EQ(data->alloc_overhead_bytes(), INT_MAX);
+  // The cumulative byte counts are 64 bit wide, and won't saturate easily.
+  EXPECT_EQ(data->allocated_bytes(),
+            static_cast<int64_t>(INT_MAX) +
+                static_cast<int64_t>(3 * kAllocatedBytes));
+  EXPECT_EQ(data->freed_bytes(),
+            static_cast<int64_t>(INT_MAX) + 3 * kFreedBytes);
+  EXPECT_EQ(data->alloc_overhead_bytes(),
+            static_cast<int64_t>(INT_MAX) + 3 * kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), INT_MAX);
 }

[gab, 2017/05/02 21:17:12]

Do we have any tests that verify the new range beyond 32-bit integers?

[Sigurður Ásgeirsson, 2017/05/03 14:10:10]

The test above now goes to 2^32 + some.

 
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   std::unique_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
 
   const int32_t run_ms = 42;
   const int32_t queue_ms = 8;
 
@@ skipping 998 matching lines @@
       EXPECT_TRUE(thread.Start());
     }
   }
 
   // Expect one ThreadData instance for each element in |kThreadNames| and one
   // ThreadData instance for the main thread.
   EXPECT_EQ(static_cast<int>(arraysize(kThreadNames) + 1), GetNumThreadData());
 }
 
 }  // namespace tracked_objects