tools/memory_watcher/memory_watcher.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <algorithm>
   6 #include <windows.h>
   7 #include <tlhelp32.h>     // for CreateToolhelp32Snapshot()
   8 #include <map>
   9
  10 #include "tools/memory_watcher/memory_watcher.h"
  11 #include "base/file_util.h"
  12 #include "base/logging.h"
  13 #include "base/metrics/stats_counters.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/synchronization/lock.h"
  17 #include "tools/memory_watcher/call_stack.h"
  18 #include "tools/memory_watcher/preamble_patcher.h"
  19
  20 static base::StatsCounter mem_in_use("MemoryInUse.Bytes");
  21 static base::StatsCounter mem_in_use_blocks("MemoryInUse.Blocks");
  22 static base::StatsCounter mem_in_use_allocs("MemoryInUse.Allocs");
  23 static base::StatsCounter mem_in_use_frees("MemoryInUse.Frees");
  24
  25 // ---------------------------------------------------------------------
  26
  27 MemoryWatcher::MemoryWatcher()
  28   : file_(NULL),
  29     hooked_(false),
  30     active_thread_id_(0) {
  31   MemoryHook::Initialize();
  32   CallStack::Initialize();
  33
  34   block_map_ = new CallStackMap();
  35
  36   // Register last - only after we're ready for notifications!
  37   Hook();
  38 }
  39
  40 MemoryWatcher::~MemoryWatcher() {
  41   Unhook();
  42
  43   CloseLogFile();
  44
  45   // Pointers in the block_map are part of the MemoryHook heap.  Be sure
  46   // to delete the map before closing the heap.
  47   delete block_map_;
  48 }
  49
  50 void MemoryWatcher::Hook() {
  51   DCHECK(!hooked_);
  52   MemoryHook::RegisterWatcher(this);
  53   hooked_ = true;
  54 }
  55
  56 void MemoryWatcher::Unhook() {
  57   if (hooked_) {
  58     MemoryHook::UnregisterWatcher(this);
  59     hooked_ = false;
  60   }
  61 }
  62
  63 void MemoryWatcher::OpenLogFile() {
  64   DCHECK(file_ == NULL);
  65   file_name_ = "memwatcher";
  66   if (!log_name_.empty()) {
  67     file_name_ += ".";
  68     file_name_ += log_name_;
  69   }
  70   file_name_ += ".log";
  71   char buf[16];
  72   file_name_ += _itoa(GetCurrentProcessId(), buf, 10);
  73
  74   std::string tmp_name(file_name_);
  75   tmp_name += ".tmp";
  76   file_ = fopen(tmp_name.c_str(), "w+");
  77 }
  78
  79 void MemoryWatcher::CloseLogFile() {
  80   if (file_ != NULL) {
  81     fclose(file_);
  82     file_ = NULL;
  83     std::wstring tmp_name = ASCIIToWide(file_name_);
  84     tmp_name += L".tmp";
  85     base::Move(base::FilePath(tmp_name),
  86                base::FilePath(ASCIIToWide(file_name_)));
  87   }
  88 }
  89
  90 bool MemoryWatcher::LockedRecursionDetected() const {
  91   if (!active_thread_id_) return false;
  92   DWORD thread_id = GetCurrentThreadId();
  93   // TODO(jar): Perchance we should use atomic access to member.
  94   return thread_id == active_thread_id_;
  95 }
  96
  97 void MemoryWatcher::OnTrack(HANDLE heap, int32 id, int32 size) {
  98   // Don't track zeroes.  It's a waste of time.
  99   if (size == 0)
 100     return;
 101
 102   if (LockedRecursionDetected())
 103     return;
 104
 105   // AllocationStack overrides new/delete to not allocate
 106   // from the main heap.
 107   AllocationStack* stack = new AllocationStack(size);
 108   if (!stack->Valid()) return;  // Recursion blocked generation of stack.
 109
 110   {
 111     base::AutoLock lock(block_map_lock_);
 112
 113     // Ideally, we'd like to verify that the block being added
 114     // here is not already in our list of tracked blocks.  However,
 115     // the lookup in our hash table is expensive and slows us too
 116     // much.
 117     CallStackMap::iterator block_it = block_map_->find(id);
 118     if (block_it != block_map_->end()) {
 119 #if 0  // Don't do this until stack->ToString() uses ONLY our heap.
 120       active_thread_id_ = GetCurrentThreadId();
 121       PrivateAllocatorString output;
 122       block_it->second->ToString(&output);
 123      // VLOG(1) << "First Stack size " << stack->size() << "was\n" << output;
 124       stack->ToString(&output);
 125      // VLOG(1) << "Second Stack size " << stack->size() << "was\n" << output;
 126 #endif  // 0
 127
 128       // TODO(jar): We should delete one stack, and keep the other, perhaps
 129       // based on size.
 130       // For now, just delete the first, and keep the second?
 131       delete block_it->second;
 132     }
 133     // TODO(jar): Perchance we should use atomic access to member.
 134     active_thread_id_ = 0;  // Note: Only do this AFTER exiting above scope!
 135
 136     (*block_map_)[id] = stack;
 137   }
 138
 139   mem_in_use.Add(size);
 140   mem_in_use_blocks.Increment();
 141   mem_in_use_allocs.Increment();
 142 }
 143
 144 void MemoryWatcher::OnUntrack(HANDLE heap, int32 id, int32 size) {
 145   DCHECK_GE(size, 0);
 146
 147   // Don't bother with these.
 148   if (size == 0)
 149     return;
 150
 151   if (LockedRecursionDetected())
 152     return;
 153
 154   {
 155     base::AutoLock lock(block_map_lock_);
 156     active_thread_id_ = GetCurrentThreadId();
 157
 158     // First, find the block in our block_map.
 159     CallStackMap::iterator it = block_map_->find(id);
 160     if (it != block_map_->end()) {
 161       AllocationStack* stack = it->second;
 162       DCHECK(stack->size() == size);
 163       block_map_->erase(id);
 164       delete stack;
 165     } else {
 166       // Untracked item.  This happens a fair amount, and it is
 167       // normal.  A lot of time elapses during process startup
 168       // before the allocation routines are hooked.
 169       size = 0;  // Ignore size in tallies.
 170     }
 171     // TODO(jar): Perchance we should use atomic access to member.
 172     active_thread_id_ = 0;
 173   }
 174
 175   mem_in_use.Add(-size);
 176   mem_in_use_blocks.Decrement();
 177   mem_in_use_frees.Increment();
 178 }
 179
 180 void MemoryWatcher::SetLogName(char* log_name) {
 181   if (!log_name)
 182     return;
 183
 184   log_name_ = log_name;
 185 }
 186
 187 // Help sort lists of stacks based on allocation cost.
 188 // Note: Sort based on allocation count is interesting too!
 189 static bool CompareCallStackIdItems(MemoryWatcher::StackTrack* left,
 190                                     MemoryWatcher::StackTrack* right) {
 191   return left->size > right->size;
 192 }
 193
 194
 195 void MemoryWatcher::DumpLeaks() {
 196   // We can only dump the leaks once.  We'll cleanup the hooks here.
 197   if (!hooked_)
 198     return;
 199   Unhook();
 200
 201   base::AutoLock lock(block_map_lock_);
 202   active_thread_id_ = GetCurrentThreadId();
 203
 204   OpenLogFile();
 205
 206   // Aggregate contributions from each allocated block on per-stack basis.
 207   CallStackIdMap stack_map;
 208   for (CallStackMap::iterator block_it = block_map_->begin();
 209       block_it != block_map_->end(); ++block_it) {
 210     AllocationStack* stack = block_it->second;
 211     int32 stack_hash = stack->hash();
 212     int32 alloc_block_size = stack->size();
 213     CallStackIdMap::iterator it = stack_map.find(stack_hash);
 214     if (it == stack_map.end()) {
 215       StackTrack tracker;
 216       tracker.count = 1;
 217       tracker.size = alloc_block_size;
 218       tracker.stack = stack;  // Temporary pointer into block_map_.
 219       stack_map[stack_hash] = tracker;
 220     } else {
 221       it->second.count++;
 222       it->second.size += alloc_block_size;
 223     }
 224   }
 225   // Don't release lock yet, as block_map_ is still pointed into.
 226
 227   // Put references to StrackTracks into array for sorting.
 228   std::vector<StackTrack*, PrivateHookAllocator<int32> >
 229       stack_tracks(stack_map.size());
 230   CallStackIdMap::iterator it = stack_map.begin();
 231   for (size_t i = 0; i < stack_tracks.size(); ++i) {
 232     stack_tracks[i] = &(it->second);
 233     ++it;
 234   }
 235   sort(stack_tracks.begin(), stack_tracks.end(), CompareCallStackIdItems);
 236
 237   int32 total_bytes = 0;
 238   int32 total_blocks = 0;
 239   for (size_t i = 0; i < stack_tracks.size(); ++i) {
 240     StackTrack* stack_track = stack_tracks[i];
 241     fwprintf(file_, L"%d bytes, %d allocs, #%d\n",
 242              stack_track->size, stack_track->count, i);
 243     total_bytes += stack_track->size;
 244     total_blocks += stack_track->count;
 245
 246     CallStack* stack = stack_track->stack;
 247     PrivateAllocatorString output;
 248     stack->ToString(&output);
 249     fprintf(file_, "%s", output.c_str());
 250   }
 251   fprintf(file_, "Total Leaks:  %d\n", total_blocks);
 252   fprintf(file_, "Total Stacks: %d\n", stack_tracks.size());
 253   fprintf(file_, "Total Bytes:  %d\n", total_bytes);
 254   CloseLogFile();
 255 }