Add heap allocator usage to task profiler.

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <stack>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/allocator/features.h"
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/containers/hash_tables.h"
+#include "base/debug/debugging_flags.h"
+#include "base/debug/thread_heap_usage_tracker.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/process/process_handle.h"
 #include "base/profiler/tracked_time.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local_storage.h"
 
@@ skipping 211 matching lines @@
   // When we have a birth we update the count for this birthplace.
   void RecordBirth();
 
  private:
   // The number of births on this thread for our location_.
   int birth_count_;
 
   DISALLOW_COPY_AND_ASSIGN(Births);
 };
 
+// forward

[Primiano Tucci (use gerrit), 2016/11/16 16:39:10]

no need for the // forward annotation, it's generally quite common to have
these.

[Sigurður Ásgeirsson, 2016/11/16 21:30:28]

Done.

+class DeathData;
 //------------------------------------------------------------------------------
 // A "snapshotted" representation of the DeathData class.
 
 struct BASE_EXPORT DeathDataSnapshot {
   DeathDataSnapshot();
 
   // Constructs the snapshot from individual values.
   // The alternative would be taking a DeathData parameter, but this would
   // create a loop since DeathData indirectly refers DeathDataSnapshot.  Passing
   // a wrapper structure as a param or using an empty constructor for
   // snapshotting DeathData would be less efficient.
   DeathDataSnapshot(int count,
                     int32_t run_duration_sum,
                     int32_t run_duration_max,
                     int32_t run_duration_sample,
                     int32_t queue_duration_sum,
                     int32_t queue_duration_max,
-                    int32_t queue_duration_sample);
+                    int32_t queue_duration_sample,
+                    int32_t alloc_ops,
+                    int32_t free_ops,
+                    int32_t allocated_bytes,
+                    int32_t freed_bytes,
+                    int32_t alloc_overhead_bytes,
+                    int32_t max_allocated_bytes);
+  DeathDataSnapshot(const DeathData& death_data);
+  DeathDataSnapshot(const DeathDataSnapshot& other);
   ~DeathDataSnapshot();
 
   // Calculates and returns the delta between this snapshot and an earlier
   // snapshot of the same task |older|.
   DeathDataSnapshot Delta(const DeathDataSnapshot& older) const;
 
   int count;
   int32_t run_duration_sum;
   int32_t run_duration_max;
   int32_t run_duration_sample;
   int32_t queue_duration_sum;
   int32_t queue_duration_max;
   int32_t queue_duration_sample;
+
+  int32_t alloc_ops;
+  int32_t free_ops;
+  int32_t allocated_bytes;
+  int32_t freed_bytes;
+  int32_t alloc_overhead_bytes;
+  int32_t max_allocated_bytes;
 };
 
 //------------------------------------------------------------------------------
 // A "snapshotted" representation of the DeathData for a particular profiling
 // phase.  Used as an element of the list of phase snapshots owned by DeathData.
 
 struct DeathDataPhaseSnapshot {
   DeathDataPhaseSnapshot(int profiling_phase,
-                         int count,
-                         int32_t run_duration_sum,
-                         int32_t run_duration_max,
-                         int32_t run_duration_sample,
-                         int32_t queue_duration_sum,
-                         int32_t queue_duration_max,
-                         int32_t queue_duration_sample,
+                         const DeathData& death_data,
                          const DeathDataPhaseSnapshot* prev);
 
   // Profiling phase at which completion this snapshot was taken.
   int profiling_phase;
 
   // Death data snapshot.
   DeathDataSnapshot death_data;
 
   // Pointer to a snapshot from the previous phase.
   const DeathDataPhaseSnapshot* prev;
@@ skipping 12 matching lines @@
 // snapshotted.
 
 class BASE_EXPORT DeathData {
  public:
   DeathData();
   DeathData(const DeathData& other);
   ~DeathData();
 
   // Update stats for a task destruction (death) that had a Run() time of
   // |duration|, and has had a queueing delay of |queue_duration|.
-  void RecordDeath(const int32_t queue_duration,
-                   const int32_t run_duration,
-                   const uint32_t random_number);
+  void RecordDurations(const int32_t queue_duration,
+                       const int32_t run_duration,
+                       const uint32_t random_number);

[Primiano Tucci (use gerrit), 2016/11/16 16:39:09]

nit: add newline here

[Sigurður Ásgeirsson, 2016/11/16 21:30:28]

Done.

+  // Update stats for a task destruction that performed |alloc_ops|
+  // allocations, |free_ops| frees, allocated |allocated_bytes| bytes, freed
+  // |freed_bytes|, where an estimated |alloc_overhead_bytes| went to heap
+  // overhead, and where at most |max_allocated_bytes| were outstanding at any
+  // one time.
+  // Note that |alloc_overhead_bytes|/|alloc_ops| yields the average estimated
+  // heap overhead of allocations in the task, and |allocated_bytes|/|alloc_ops|
+  // yields the average size of allocation.
+  // Note also that |allocated_bytes|-|freed_bytes| yields the net heap memory
+  // usage of the task, which can be negative.
+  void RecordAllocations(const uint32_t alloc_ops,
+                         const uint32_t free_ops,
+                         const uint32_t allocated_bytes,
+                         const uint32_t freed_bytes,
+                         const uint32_t alloc_overhead_bytes,
+                         const uint32_t max_allocated_bytes);
 
   // Metrics and past snapshots accessors, used only for serialization and in
   // tests.
   int count() const { return base::subtle::NoBarrier_Load(&count_); }
   int32_t run_duration_sum() const {
     return base::subtle::NoBarrier_Load(&run_duration_sum_);
   }
   int32_t run_duration_max() const {
     return base::subtle::NoBarrier_Load(&run_duration_max_);
   }
   int32_t run_duration_sample() const {
     return base::subtle::NoBarrier_Load(&run_duration_sample_);
   }
   int32_t queue_duration_sum() const {
     return base::subtle::NoBarrier_Load(&queue_duration_sum_);
   }
   int32_t queue_duration_max() const {
     return base::subtle::NoBarrier_Load(&queue_duration_max_);
   }
   int32_t queue_duration_sample() const {
     return base::subtle::NoBarrier_Load(&queue_duration_sample_);
   }
+  int32_t alloc_ops() const {
+    return base::subtle::NoBarrier_Load(&alloc_ops_);
+  }
+  int32_t free_ops() const { return base::subtle::NoBarrier_Load(&free_ops_); }
+  int32_t allocated_bytes() const {
+    return base::subtle::NoBarrier_Load(&allocated_bytes_);
+  }
+  int32_t freed_bytes() const {
+    return base::subtle::NoBarrier_Load(&freed_bytes_);
+  }
+  int32_t alloc_overhead_bytes() const {
+    return base::subtle::NoBarrier_Load(&alloc_overhead_bytes_);
+  }
+  int32_t max_allocated_bytes() const {
+    return base::subtle::NoBarrier_Load(&max_allocated_bytes_);
+  }
   const DeathDataPhaseSnapshot* last_phase_snapshot() const {
     return last_phase_snapshot_;
   }
 
   // Called when the current profiling phase, identified by |profiling_phase|,
   // ends.
   // Must be called only on the snapshot thread.
   void OnProfilingPhaseCompleted(int profiling_phase);
 
  private:
@@ skipping 17 matching lines @@
   // but rarely updated.  The max values get assigned only on the death thread,
   // but these fields can be set to 0 by OnProfilingPhaseCompleted() on the
   // snapshot thread.
   base::subtle::Atomic32 run_duration_max_;
   base::subtle::Atomic32 queue_duration_max_;
   // Samples, used by crowd sourcing gatherers.  These are almost never read,
   // and rarely updated.  They can be modified only on the death thread.
   base::subtle::Atomic32 run_duration_sample_;
   base::subtle::Atomic32 queue_duration_sample_;
 
+  // The cumulative number of allocation and free operations.
+  base::subtle::Atomic32 alloc_ops_;
+  base::subtle::Atomic32 free_ops_;
+
+  // The number of bytes allocated by the task.
+  base::subtle::Atomic32 allocated_bytes_;
+
+  // The number of bytes freed by the task.
+  base::subtle::Atomic32 freed_bytes_;
+
+  // The cumulative number of overhead bytes. Where available this yields an
+  // estimate of the heap overhead for allocations.
+  base::subtle::Atomic32 alloc_overhead_bytes_;
+
+  // The high-watermark for the number of outstanding heap allocated bytes.
+  base::subtle::Atomic32 max_allocated_bytes_;
+
   // Snapshot of this death data made at the last profiling phase completion, if
   // any.  DeathData owns the whole list starting with this pointer.
   // Can be accessed only on the snapshot thread.
   const DeathDataPhaseSnapshot* last_phase_snapshot_;
 
   DISALLOW_ASSIGN(DeathData);
 };
 
 //------------------------------------------------------------------------------
 // A temporary collection of data that can be sorted and summarized.  It is
@@ skipping 347 matching lines @@
 
   // Returns the start time.
   TrackedTime StartTime() const;
 
   // Task's duration is calculated as the wallclock duration between starting
   // and stopping this stopwatch, minus the wallclock durations of any other
   // instances that are immediately nested in this one, started and stopped on
   // this thread during that period.
   int32_t RunDurationMs() const;
 
+#if BUILDFLAG(ENABLE_MEMORY_TASK_PROFILER)
+  const base::debug::ThreadHeapUsageTracker& heap_usage() const;

[Primiano Tucci (use gerrit), 2016/11/16 16:39:09]

why not inlining also this accessor?

[Sigurður Ásgeirsson, 2016/11/16 21:30:28]

Thanks, done.

+  bool heap_tracking_enabled() const { return heap_tracking_enabled_; }
+#endif
+
   // Returns tracking info for the current thread.
   ThreadData* GetThreadData() const;
 
  private:
   // Time when the stopwatch was started.
   TrackedTime start_time_;
 
+#if BUILDFLAG(ENABLE_MEMORY_TASK_PROFILER)
+  base::debug::ThreadHeapUsageTracker heap_usage_;
+  bool heap_tracking_enabled_;
+#endif
+
   // Wallclock duration of the task.
   int32_t wallclock_duration_ms_;
 
   // Tracking info for the current thread.
   ThreadData* current_thread_data_;
 
   // Sum of wallclock durations of all stopwatches that were directly nested in
   // this one.
   int32_t excluded_duration_ms_;
 
@@ skipping 36 matching lines @@
   ProcessDataSnapshot(const ProcessDataSnapshot& other);
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_