Breakdown nonprofiled memory regions (f.k.a. 'unknown'), and add new policy files.

third_party/tcmalloc/chromium/src/deep-heap-profile.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.
 
 // ---
 // Author: Sainbayar Sukhbaatar
 //         Dai Mikurube
 //
 // This file contains a class DeepHeapProfile and its public function
 // DeepHeapProfile::FillOrderedProfile() which works as an alternative of
@@ skipping 22 matching lines @@
 #include "addressmap-inl.h"
 #include "heap-profile-table.h"
 
 class DeepHeapProfile {
  public:
   typedef HeapProfileTable::Bucket Bucket;
   typedef HeapProfileTable::AllocationMap AllocationMap;
   typedef HeapProfileTable::AllocValue AllocValue;
   typedef HeapProfileTable::Stats Stats;
 
+  enum MapsRegionType {
+    // Bytes of memory which were not recognized with /proc/<pid>/maps.
+    // This size should be 0.
+    ABSENT,
+
+    // Bytes of memory which is mapped anonymously.
+    // Regions which contain nothing in the last column of /proc/<pid>/maps.
+    ANONYMOUS,
+
+    // Bytes of memory which is mapped to a executable/non-executable file.
+    // Regions which contain file paths in the last column of /proc/<pid>/maps.
+    FILE_EXEC,
+    FILE_NONEXEC,
+
+    // Bytes of memory which is labeled [stack] in /proc/<pid>/maps.
+    STACK,
+
+    // Bytes of memory which is labeled, but not mapped to any file.
+    // Regions which contain non-path strings in the last column of
+    // /proc/<pid>/maps.
+    OTHER,
+
+    NUMBER_OF_MAPS_REGION_TYPES
+  };
+
   // Construct a DeepHeapProfile instance.  It works as a wrapper of
   // HeapProfileTable.
   //
   // |heap_profile| is a pointer to HeapProfileTable.  DeepHeapProfile reads
   // data in |heap_profile| and forwards operations to |heap_profile| if
   // DeepHeapProfile is not available (non-Linux).
   // |prefix| is a prefix of dumped file names.
   DeepHeapProfile(HeapProfileTable* heap_profile, const char* prefix);
   ~DeepHeapProfile();
 
@@ skipping 19 matching lines @@
   struct PageState {
     bool is_committed;  // Currently, we use only this
     bool is_present;
     bool is_swapped;
     bool is_shared;
     bool is_mmap;
   };
 
   class RegionStats {
    public:
-    RegionStats() {}
+    RegionStats(): virtual_bytes_(0), committed_bytes_(0) {}
     ~RegionStats() {}
 
     // Initialize virtual_bytes and committed_bytes.
     void Initialize();
 
     // Update the RegionStats to include the tallies of virtual_bytes and
     // committed_bytes in the region from |first_adress| to |last_address|
     // inclusive.
     void Record(int pagemap_fd, uint64 first_address, uint64 last_address);
 
     size_t virtual_bytes() const { return virtual_bytes_; }
     size_t committed_bytes() const { return committed_bytes_; }
     void set_virtual_bytes(size_t virtual_bytes) {
       virtual_bytes_ = virtual_bytes;
     }
     void set_committed_bytes(size_t committed_bytes) {
       committed_bytes_ = committed_bytes;
     }
     void AddToVirtualBytes(size_t additional_virtual_bytes) {
       virtual_bytes_ += additional_virtual_bytes;
     }
     void AddToCommittedBytes(size_t additional_committed_bytes) {
       committed_bytes_ += additional_committed_bytes;
     }
+    void AddAnotherRegionStat(const RegionStats& other) {
+      virtual_bytes_ += other.virtual_bytes_;
+      committed_bytes_ += other.committed_bytes_;
+    }
 
    private:
     size_t virtual_bytes_;
     size_t committed_bytes_;
     DISALLOW_COPY_AND_ASSIGN(RegionStats);
   };
 
   struct GlobalStats {
     // All RegionStats members in this class contain the bytes of virtual
     // memory and committed memory.
     // TODO(dmikurube): These regions should be classified more precisely later
     // for more detailed analysis.
-
-    // Total bytes of the process memory.
-    RegionStats total;
-
-    // Total bytes of memory which is mapped to a file.
-    // Regions which contain file paths in the last column of /proc/<pid>/maps.
-    RegionStats file_mapped;
-
-    // Total bytes of memory which is mapped anonymously.
-    // Regions which contain nothing in the last column of /proc/<pid>/maps.
-    RegionStats anonymous;
-
-    // Total bytes of memory which is labeled, but not mapped to any file.
-    // Regions which contain non-path strings in the last column of
-    // /proc/<pid>/maps.
-    RegionStats other;
+    RegionStats all[NUMBER_OF_MAPS_REGION_TYPES];
+    RegionStats nonprofiled[NUMBER_OF_MAPS_REGION_TYPES];
 
     // Total bytes of mmap'ed regions.
-    RegionStats record_mmap;
+    RegionStats profiled_mmap;
 
     // Total bytes of malloc'ed regions.
-    RegionStats record_malloc;
+    RegionStats profiled_malloc;
+  };
+
+  struct MMapListEntry {
+    uint64 first_address;
+    uint64 last_address;
+    MapsRegionType type;
   };
 
   // Checks if the length of |printed| characters by snprintf is valid.
   static bool IsPrintedStringValid(int printed,
                                    int buffer_size,
                                    int used_in_buffer);
 
   // Clear the is_logged flag in a DeepBucket object as a callback function
   // for DeepBucketMap::Iterate().
   static void ClearIsLogged(const void* pointer,
@@ skipping 20 matching lines @@
 
   // Write re-formatted /proc/self/maps into a file which has |filename_prefix|
   // with using |buffer| of size |buffer_size|.
   static void WriteMapsToFile(const char* filename_prefix,
                               int buffer_size,
                               char buffer[]);
 
   // Compute the global statistics from /proc/self/maps and |pagemap_fd|, and
   // store the statistics in |stats|.
   static void SnapshotGlobalStatsWithoutMalloc(int pagemap_fd,
-                                               GlobalStats* stats);
+                                               GlobalStats* stats,
+                                               MMapListEntry* mmap_list,
+                                               int mmap_list_length);
 
   // Get the DeepBucket object corresponding to the given |bucket|.
   // DeepBucket is an extension to Bucket which is declared above.
   DeepBucket* GetDeepBucket(Bucket* bucket);
 
   // Reset committed_size member variables in DeepBucket objects to 0.
   void ResetCommittedSize(Bucket** bucket_table);
 
   // Fill bucket data in |bucket_table| into buffer |buffer| of size
   // |buffer_size|, and return the size occupied by the bucket data in
   // |buffer|.  |bucket_length| is the offset for |buffer| to start filling.
   int SnapshotBucketTableWithoutMalloc(Bucket** bucket_table,
                                        int used_in_buffer,
                                        int buffer_size,
                                        char buffer[]);
 
+  static bool ByFirstAddress(const MMapListEntry& a,
+                             const MMapListEntry& b);
+
+  // Count mmap allocations in deep_profile->num_mmap_allocations_.
+  static void CountMMap(const void* pointer,
+                        AllocValue* alloc_value,
+                        DeepHeapProfile* deep_profile);
+
   // Record both virtual and committed byte counts of malloc and mmap regions
   // as callback functions for AllocationMap::Iterate().
   static void RecordAlloc(const void* pointer,
                           AllocValue* alloc_value,
                           DeepHeapProfile* deep_profile);
   static void RecordMMap(const void* pointer,
                          AllocValue* alloc_value,
                          DeepHeapProfile* deep_profile);
   void SnapshotAllAllocsWithoutMalloc();
 
@@ skipping 33 matching lines @@
 
   // Process ID of the last dump.  This could change by fork.
   pid_t most_recent_pid_;
   GlobalStats stats_;      // Stats about total memory.
   int dump_count_;         // The number of dumps.
   char* filename_prefix_;  // Output file prefix.
   char* profiler_buffer_;  // Buffer we use many times.
 
   int bucket_id_;
   DeepBucketMap* deep_bucket_map_;
+  MMapListEntry* mmap_list_;
+  int mmap_list_length_;
+  int num_mmap_allocations_;
 #endif  // DEEP_HEAP_PROFILE
 
   HeapProfileTable* heap_profile_;
 
   DISALLOW_COPY_AND_ASSIGN(DeepHeapProfile);
 };
 
 #endif  // BASE_DEEP_HEAP_PROFILE_H_