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_ 96