Marshal 64 bit byte counts as double to the profiler.

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 but aggregate byte counts. The byte counts will be
-  // pushed past the 32 bit value range.
-  data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX);
+  // Saturate everything but aggregate byte counts.
+  // In the 32 bit implementation, this tests the case where the low-order

[gab, 2017/05/12 15:07:52]

in the "64 bit implementation"?

[Sigurður Ásgeirsson, 2017/05/12 15:11:21]

No, I specifically mean the 32 bit implementation, the one with all the wonky
atomics crap. I suspected the negative values were emerging from the way I
concatenate two 32 bit (signed) AtomicIntegers to a 64 bit signed integer. This
is essentially a regression test for screwing that up in the future.
I can't think of any way to screw up the 64 bit case :).

[gab, 2017/05/12 15:13:41]

Ah, indeed, right :)

+  // word goes negative.
   data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX);
   EXPECT_EQ(data->alloc_ops(), INT_MAX);
   EXPECT_EQ(data->free_ops(), 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);
+
+  // The byte counts will be pushed past the 32 bit value range.
+  data->RecordAllocations(INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX, INT_MAX);
+  EXPECT_EQ(data->alloc_ops(), INT_MAX);
+  EXPECT_EQ(data->free_ops(), INT_MAX);
   // The cumulative byte counts are 64 bit wide, and won't saturate easily.
   EXPECT_EQ(data->allocated_bytes(),
             2 * static_cast<int64_t>(INT_MAX) +
                 static_cast<int64_t>(3 * kAllocatedBytes));
   EXPECT_EQ(data->freed_bytes(),
             2 * static_cast<int64_t>(INT_MAX) + 3 * kFreedBytes);
   EXPECT_EQ(data->alloc_overhead_bytes(),
             2 * static_cast<int64_t>(INT_MAX) + 3 * kAllocOverheadBytes);
   EXPECT_EQ(data->max_allocated_bytes(), INT_MAX);
 }
@@ skipping 1008 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