Add heap allocator usage to task 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>
 
 #include <memory>
 
+#include "base/debug/scoped_thread_heap_usage.h"
 #include "base/process/process_handle.h"
 #include "base/time/time.h"
 #include "base/tracking_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 const int kLineNumber = 1776;
 const char kFile[] = "FixedUnitTestFileName";
 const char kWorkerThreadName[] = "WorkerThread-1";
 const char kMainThreadName[] = "SomeMainThreadName";
 const char kStillAlive[] = "Still_Alive";
 
+const uint32_t kAllocOps = 23;
+const uint32_t kFreeOps = 27;
+const uint32_t kAllocatedBytes = 59934;
+const uint32_t kFreedBytes = 2 * kAllocatedBytes;
+const uint32_t kAllocOverheadBytes = kAllocOps * 8;
+const uint32_t kMaxAllocatedBytes = kAllocatedBytes / 2;
+
 namespace tracked_objects {
 
 class TrackedObjectsTest : public testing::Test {
  protected:
   TrackedObjectsTest() {
     // On entry, leak any database structures in case they are still in use by
     // prior threads.
     ThreadData::ShutdownSingleThreadedCleanup(true);
 
     test_time_ = 0;
@@ skipping 195 matching lines @@
   EXPECT_EQ(time_elapsed,
             process_data_phase.tasks[0].death_data.run_duration_max);
   EXPECT_EQ(time_elapsed,
             process_data_phase.tasks[0].death_data.run_duration_sample);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sum);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_max);
   EXPECT_EQ(0, process_data_phase.tasks[0].death_data.queue_duration_sample);
   EXPECT_EQ(kWorkerThreadName, process_data_phase.tasks[0].death_thread_name);
 }
 
-TEST_F(TrackedObjectsTest, DeathDataTestRecordDeath) {
+TEST_F(TrackedObjectsTest, DeathDataTestRecordDurations) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   std::unique_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
   EXPECT_EQ(data->run_duration_sum(), 0);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), 0);
   EXPECT_EQ(data->queue_duration_sum(), 0);
   EXPECT_EQ(data->queue_duration_max(), 0);
   EXPECT_EQ(data->queue_duration_sample(), 0);
   EXPECT_EQ(data->count(), 0);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
   int32_t run_ms = 42;
   int32_t queue_ms = 8;
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
-  data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms);
   EXPECT_EQ(data->run_duration_max(), run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms);
   EXPECT_EQ(data->queue_duration_max(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 1);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 
-  data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
   EXPECT_EQ(data->run_duration_max(), run_ms);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_max(), queue_ms);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
   EXPECT_EQ(nullptr, data->last_phase_snapshot());
 }
 
+TEST_F(TrackedObjectsTest, DeathDataTestRecordAllocations) {
+  ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
+
+  std::unique_ptr<DeathData> data(new DeathData());
+  ASSERT_NE(data, nullptr);
+
+  EXPECT_EQ(data->alloc_ops(), 0);
+  EXPECT_EQ(data->free_ops(), 0);
+  EXPECT_EQ(data->allocated_bytes(), 0);
+  EXPECT_EQ(data->freed_bytes(), 0);
+  EXPECT_EQ(data->alloc_overhead_bytes(), 0);
+  EXPECT_EQ(data->max_allocated_bytes(), 0);
+
+  EXPECT_EQ(nullptr, data->last_phase_snapshot());
+
+  data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+                          kAllocOverheadBytes, kMaxAllocatedBytes);
+  EXPECT_EQ(data->alloc_ops(), kAllocOps);
+  EXPECT_EQ(data->free_ops(), kFreeOps);
+  EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes);
+  EXPECT_EQ(data->freed_bytes(), kFreedBytes);
+  EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes);
+  EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
+  // Record another batch, with a smaller max.
+  const uint32_t kSmallerMaxAllocatedBytes = kMaxAllocatedBytes / 2;
+  data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+                          kAllocOverheadBytes, kSmallerMaxAllocatedBytes);
+  EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps);
+  EXPECT_EQ(data->free_ops(), 2 * kFreeOps);
+  EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes);
+  EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes);
+  EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes);
+  EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
+  // Now with a larger max.
+  const uint32_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.
+  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);
+  EXPECT_EQ(data->allocated_bytes(), INT_MAX);
+  EXPECT_EQ(data->freed_bytes(), INT_MAX);
+  EXPECT_EQ(data->alloc_overhead_bytes(), INT_MAX);
+  EXPECT_EQ(data->max_allocated_bytes(), INT_MAX);
+}
+
 TEST_F(TrackedObjectsTest, DeathDataTest2Phases) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   std::unique_ptr<DeathData> data(new DeathData());
   ASSERT_NE(data, nullptr);
 
-  int32_t run_ms = 42;
-  int32_t queue_ms = 8;
+  const int32_t run_ms = 42;
+  const int32_t queue_ms = 8;
 
   const int kUnrandomInt = 0;  // Fake random int that ensure we sample data.
-  data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
-  data->RecordDeath(queue_ms, run_ms, kUnrandomInt);
+  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
+  data->RecordDurations(queue_ms, run_ms, kUnrandomInt);
+
+  data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+                          kAllocOverheadBytes, kMaxAllocatedBytes);
 
   data->OnProfilingPhaseCompleted(123);
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms);
   EXPECT_EQ(data->run_duration_max(), 0);
   EXPECT_EQ(data->run_duration_sample(), run_ms);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms);
   EXPECT_EQ(data->queue_duration_max(), 0);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms);
   EXPECT_EQ(data->count(), 2);
+
+  EXPECT_EQ(data->alloc_ops(), kAllocOps);
+  EXPECT_EQ(data->free_ops(), kFreeOps);
+  EXPECT_EQ(data->allocated_bytes(), kAllocatedBytes);
+  EXPECT_EQ(data->freed_bytes(), kFreedBytes);
+  EXPECT_EQ(data->alloc_overhead_bytes(), kAllocOverheadBytes);
+  EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
   ASSERT_NE(nullptr, data->last_phase_snapshot());
   EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
   EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
   EXPECT_EQ(2 * run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sum);
   EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max);
   EXPECT_EQ(run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sample);
   EXPECT_EQ(2 * queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sum);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_max);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sample);
+
+  EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
+  EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
+  EXPECT_EQ(kAllocatedBytes,
+            data->last_phase_snapshot()->death_data.allocated_bytes);
+  EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
+  EXPECT_EQ(kAllocOverheadBytes,
+            data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
+  EXPECT_EQ(kMaxAllocatedBytes,
+            data->last_phase_snapshot()->death_data.max_allocated_bytes);
+
   EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
 
-  int32_t run_ms1 = 21;
-  int32_t queue_ms1 = 4;
+  const int32_t run_ms1 = 21;
+  const int32_t queue_ms1 = 4;
 
-  data->RecordDeath(queue_ms1, run_ms1, kUnrandomInt);
+  data->RecordDurations(queue_ms1, run_ms1, kUnrandomInt);
+  data->RecordAllocations(kAllocOps, kFreeOps, kAllocatedBytes, kFreedBytes,
+                          kAllocOverheadBytes, kMaxAllocatedBytes);
+
   EXPECT_EQ(data->run_duration_sum(), run_ms + run_ms + run_ms1);
   EXPECT_EQ(data->run_duration_max(), run_ms1);
   EXPECT_EQ(data->run_duration_sample(), run_ms1);
   EXPECT_EQ(data->queue_duration_sum(), queue_ms + queue_ms + queue_ms1);
   EXPECT_EQ(data->queue_duration_max(), queue_ms1);
   EXPECT_EQ(data->queue_duration_sample(), queue_ms1);
   EXPECT_EQ(data->count(), 3);
+
+  EXPECT_EQ(data->alloc_ops(), 2 * kAllocOps);
+  EXPECT_EQ(data->free_ops(), 2 * kFreeOps);
+  EXPECT_EQ(data->allocated_bytes(), 2 * kAllocatedBytes);
+  EXPECT_EQ(data->freed_bytes(), 2 * kFreedBytes);
+  EXPECT_EQ(data->alloc_overhead_bytes(), 2 * kAllocOverheadBytes);
+  EXPECT_EQ(data->max_allocated_bytes(), kMaxAllocatedBytes);
+
   ASSERT_NE(nullptr, data->last_phase_snapshot());
   EXPECT_EQ(123, data->last_phase_snapshot()->profiling_phase);
   EXPECT_EQ(2, data->last_phase_snapshot()->death_data.count);
   EXPECT_EQ(2 * run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sum);
   EXPECT_EQ(run_ms, data->last_phase_snapshot()->death_data.run_duration_max);
   EXPECT_EQ(run_ms,
             data->last_phase_snapshot()->death_data.run_duration_sample);
   EXPECT_EQ(2 * queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sum);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_max);
   EXPECT_EQ(queue_ms,
             data->last_phase_snapshot()->death_data.queue_duration_sample);
+
+  EXPECT_EQ(kAllocOps, data->last_phase_snapshot()->death_data.alloc_ops);
+  EXPECT_EQ(kFreeOps, data->last_phase_snapshot()->death_data.free_ops);
+  EXPECT_EQ(kAllocatedBytes,
+            data->last_phase_snapshot()->death_data.allocated_bytes);
+  EXPECT_EQ(kFreedBytes, data->last_phase_snapshot()->death_data.freed_bytes);
+  EXPECT_EQ(kAllocOverheadBytes,
+            data->last_phase_snapshot()->death_data.alloc_overhead_bytes);
+  EXPECT_EQ(kMaxAllocatedBytes,
+            data->last_phase_snapshot()->death_data.max_allocated_bytes);
+
   EXPECT_EQ(nullptr, data->last_phase_snapshot()->prev);
 }
 
 TEST_F(TrackedObjectsTest, Delta) {
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::PROFILING_ACTIVE);
 
   DeathDataSnapshot snapshot;
   snapshot.count = 10;
   snapshot.run_duration_sum = 100;
   snapshot.run_duration_max = 50;
   snapshot.run_duration_sample = 25;
   snapshot.queue_duration_sum = 200;
   snapshot.queue_duration_max = 101;
   snapshot.queue_duration_sample = 26;
 
+  snapshot.alloc_ops = 95;
+  snapshot.free_ops = 90;
+  snapshot.allocated_bytes = 10240;
+  snapshot.freed_bytes = 4096;
+  snapshot.alloc_overhead_bytes = 950;
+  snapshot.max_allocated_bytes = 10240;
+
   DeathDataSnapshot older_snapshot;
   older_snapshot.count = 2;
   older_snapshot.run_duration_sum = 95;
   older_snapshot.run_duration_max = 48;
   older_snapshot.run_duration_sample = 22;
   older_snapshot.queue_duration_sum = 190;
   older_snapshot.queue_duration_max = 99;
   older_snapshot.queue_duration_sample = 21;
 
+  older_snapshot.alloc_ops = 45;
+  older_snapshot.free_ops = 40;
+  older_snapshot.allocated_bytes = 4096;
+  older_snapshot.freed_bytes = 2048;
+  older_snapshot.alloc_overhead_bytes = 450;
+  older_snapshot.max_allocated_bytes = 10200;
+
   const DeathDataSnapshot& delta = snapshot.Delta(older_snapshot);
   EXPECT_EQ(8, delta.count);
   EXPECT_EQ(5, delta.run_duration_sum);
   EXPECT_EQ(50, delta.run_duration_max);
   EXPECT_EQ(25, delta.run_duration_sample);
   EXPECT_EQ(10, delta.queue_duration_sum);
   EXPECT_EQ(101, delta.queue_duration_max);
   EXPECT_EQ(26, delta.queue_duration_sample);
+
+  EXPECT_EQ(50, delta.alloc_ops);
+  EXPECT_EQ(50, delta.free_ops);
+  EXPECT_EQ(6144, delta.allocated_bytes);
+  EXPECT_EQ(2048, delta.freed_bytes);
+  EXPECT_EQ(500, delta.alloc_overhead_bytes);
+  EXPECT_EQ(10240, delta.max_allocated_bytes);
 }
 
 TEST_F(TrackedObjectsTest, DeactivatedBirthOnlyToSnapshotWorkerThread) {
   // Start in the deactivated state.
   ThreadData::InitializeAndSetTrackingStatus(ThreadData::DEACTIVATED);
 
   const char kFunction[] = "DeactivatedBirthOnlyToSnapshotWorkerThread";
   Location location(kFunction, kFile, kLineNumber, NULL);
   TallyABirth(location, std::string());
 
@@ skipping 342 matching lines @@
   pending_task.time_posted = kTimePosted;  // Overwrite implied Now().
 
   const unsigned int kStartOfRun = 5;
   const unsigned int kEndOfRun = 7;
   SetTestTime(kStartOfRun);
   TaskStopwatch stopwatch;
   stopwatch.Start();
   SetTestTime(kEndOfRun);
   stopwatch.Stop();
 
+  // DO NOT SUBMIT
   ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, stopwatch);
 
   ThreadData::OnProfilingPhaseCompleted(0);
 
   ProcessDataSnapshot process_data;
   ThreadData::Snapshot(1, &process_data);
 
   ASSERT_EQ(2u, process_data.phased_snapshots.size());
 
   auto it0 = process_data.phased_snapshots.find(0);
@@ skipping 433 matching lines @@
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_max);
   EXPECT_EQ(2, process_data_phase.tasks[t1].death_data.run_duration_sample);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sum);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_max);
   EXPECT_EQ(1, process_data_phase.tasks[t1].death_data.queue_duration_sample);
   EXPECT_EQ(kMainThreadName, process_data_phase.tasks[t1].death_thread_name);
   EXPECT_EQ(base::GetCurrentProcId(), process_data.process_id);
 }
 
 }  // namespace tracked_objects