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

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>
@@ skipping 262 matching lines @@
   // 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 alloc_ops,
                     int32_t free_ops,
-                    int32_t allocated_bytes,
-                    int32_t freed_bytes,
-                    int32_t alloc_overhead_bytes,
+                    int64_t allocated_bytes,
+                    int64_t freed_bytes,
+                    int64_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;
+  int64_t allocated_bytes;
+  int64_t freed_bytes;
+  int64_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,
                          const DeathData& death_data,
@@ skipping 68 matching lines @@
   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_);
+  int64_t allocated_bytes() const {
+    return ConsistentCumulativeByteCountRead(&allocated_bytes_);
   }
-  int32_t freed_bytes() const {
-    return base::subtle::NoBarrier_Load(&freed_bytes_);
+  int64_t freed_bytes() const {
+    return ConsistentCumulativeByteCountRead(&freed_bytes_);
   }
-  int32_t alloc_overhead_bytes() const {
-    return base::subtle::NoBarrier_Load(&alloc_overhead_bytes_);
+  int64_t alloc_overhead_bytes() const {
+    return ConsistentCumulativeByteCountRead(&alloc_overhead_bytes_);
   }
-  int32_t max_allocated_bytes() const {
+  int64_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:
+#if defined(ARCH_CPU_64_BITS)
+  using CumulativeByteCount = base::subtle::Atomic64;
+#else
+  struct CumulativeByteCount {
+    base::subtle::Atomic32 hi_word;
+    base::subtle::Atomic32 lo_word;
+  };
+#endif
+
+  // Reads a cumulative byte counter consistently.
+  int64_t ConsistentCumulativeByteCountRead(
+      const CumulativeByteCount* count) const;
+
+  // Reads the value of a cumulative byte count, only returns consistent
+  // results on the owning thread.
+  static int64_t CumulativeByteCountRead(const CumulativeByteCount* count);
+
   // A saturating addition operation for member variables. This elides the
   // use of atomic-primitive reads for members that are only written on the
   // owning thread.
   static void SaturatingMemberAdd(const uint32_t addend,
                                   base::subtle::Atomic32* sum);
 
+  void SaturatingByteCountMemberAdd(const uint32_t addend,
+                                    CumulativeByteCount* sum);
+
   // Members are ordered from most regularly read and updated, to least
   // frequently used.  This might help a bit with cache lines.
   // Number of runs seen (divisor for calculating averages).
   // Can be incremented only on the death thread.
   base::subtle::Atomic32 count_;
 
   // Count used in determining probability of selecting exec/queue times from a
   // recorded death as samples.
   // Gets incremented only on the death thread, but can be set to 0 by
   // OnProfilingPhaseCompleted() on the snapshot thread.
   base::subtle::Atomic32 sample_probability_count_;
 
   // Basic tallies, used to compute averages.  Can be incremented only on the
   // death thread.
   base::subtle::Atomic32 run_duration_sum_;
   base::subtle::Atomic32 queue_duration_sum_;
   // Max values, used by local visualization routines.  These are often read,
   // 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_;
 
   // The cumulative number of allocation and free operations.
   base::subtle::Atomic32 alloc_ops_;
   base::subtle::Atomic32 free_ops_;
 
+#if !defined(ARCH_CPU_64_BITS)
+  // On 32 bit systems this is used to achieve consistent reads for cumulative
+  // byte counts. This is odd while updates are in progress, and even while
+  // quiescent. If this has the same value before and after reading the
+  // cumulative counts, the read is consistent.
+  base::subtle::Atomic32 byte_update_counter_;
+#endif
+
   // The number of bytes allocated by the task.
-  base::subtle::Atomic32 allocated_bytes_;
+  CumulativeByteCount allocated_bytes_;
 
   // The number of bytes freed by the task.
-  base::subtle::Atomic32 freed_bytes_;
+  CumulativeByteCount 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_;
+  CumulativeByteCount alloc_overhead_bytes_;
 
   // The high-watermark for the number of outstanding heap allocated bytes.
   base::subtle::Atomic32 max_allocated_bytes_;
 
   // 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_;
 
   // Snapshot of this death data made at the last profiling phase completion, if
@@ skipping 420 matching lines @@
   ProcessDataSnapshot(const ProcessDataSnapshot& other);
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_