tools/memory_watcher/memory_watcher.h

   1 // Copyright (c) 2006-2008 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 // MemoryWatcher.
   6 // The MemoryWatcher is a library that can be linked into any
   7 // win32 application.  It will override the default memory allocators
   8 // and track call stacks for any allocations that are made.  It can
   9 // then be used to see what memory is in use.
  10
  11 #ifndef TOOLS_MEMORY_WATCHER_MEMORY_WATCHER_
  12 #define TOOLS_MEMORY_WATCHER_MEMORY_WATCHER_
  13
  14 #include <map>
  15 #include <functional>
  16
  17 #include "base/synchronization/lock.h"
  18 #include "tools/memory_watcher/memory_hook.h"
  19
  20 class CallStack;
  21 class AllocationStack;
  22
  23 // The MemoryWatcher installs allocation hooks and monitors
  24 // allocations and frees.
  25 class MemoryWatcher : MemoryObserver {
  26  public:
  27   struct StackTrack {
  28     CallStack* stack;
  29     int count;
  30     int size;
  31   };
  32
  33   typedef std::map<int32, AllocationStack*, std::less<int32>,
  34                    PrivateHookAllocator<int32> > CallStackMap;
  35   typedef std::map<int32, StackTrack, std::less<int32>,
  36                    PrivateHookAllocator<int32> > CallStackIdMap;
  37   typedef std::basic_string<char, std::char_traits<char>,
  38                             PrivateHookAllocator<char> > PrivateAllocatorString;
  39
  40   MemoryWatcher();
  41   virtual ~MemoryWatcher();
  42
  43   // Dump all tracked pointers still in use.
  44   void DumpLeaks();
  45
  46   // MemoryObserver interface.
  47   virtual void OnTrack(HANDLE heap, int32 id, int32 size);
  48   virtual void OnUntrack(HANDLE heap, int32 id, int32 size);
  49
  50   // Sets a name that appears in the generated file name.
  51   void SetLogName(char* log_name);
  52
  53  private:
  54   // Opens the logfile which we create.
  55   void OpenLogFile();
  56
  57   // Close the logfile.
  58   void CloseLogFile();
  59
  60   // Hook the memory hooks.
  61   void Hook();
  62
  63   // Unhooks our memory hooks.
  64   void Unhook();
  65
  66   // Check to see if this thread is already processing a block, and should not
  67   // recurse.
  68   bool LockedRecursionDetected() const;
  69
  70   // This is for logging.
  71   FILE* file_;
  72
  73   bool hooked_;  // True when this class has the memory_hooks hooked.
  74
  75   // Either 0, or else the threadID for a thread that is actively working on
  76   // a stack track.  Used to avoid recursive tracking.
  77   DWORD active_thread_id_;
  78
  79   base::Lock block_map_lock_;
  80   // The block_map provides quick lookups based on the allocation
  81   // pointer.  This is important for having fast round trips through
  82   // malloc/free.
  83   CallStackMap *block_map_;
  84
  85   // The file name for that log.
  86   std::string file_name_;
  87
  88   // An optional name that appears in the log file name (used to differentiate
  89   // logs).
  90   std::string log_name_;
  91 };
  92
  93
  94
  95 #endif  // TOOLS_MEMORY_WATCHER_MEMORY_WATCHER_