Ticket #187: profiler-memtracker.patch

trunk/source/ps/Profile.cpp

@@ -38 +38 @@
 #endif
 
 #include <numeric>
+#include <map>
 
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // CProfileNodeTable
@@ -83 +84 @@
             columns.push_back(ProfileColumn("calls/turn", 80));
             columns.push_back(ProfileColumn("msec/turn", 80));
             columns.push_back(ProfileColumn("mallocs/turn", 80));
+            columns.push_back(ProfileColumn("alloc'd mem", 80));
         }
     };
     
@@ -160 +162 @@
         double unlogged_time_turn = node->GetTurnTime();
         double unlogged_mallocs_frame = node->GetFrameMallocs();
         double unlogged_mallocs_turn = node->GetTurnMallocs();
+        double unlogged_alloc_mem = node->GetAllocMem();
         CProfileNode::const_profile_iterator it;
 
         for (it = node->GetChildren()->begin(); it != node->GetChildren()->end(); ++it)
@@ -168 +171 @@
             unlogged_time_turn -= (*it)->GetTurnTime();
             unlogged_mallocs_frame -= (*it)->GetFrameMallocs();
             unlogged_mallocs_turn -= (*it)->GetTurnMallocs();
+            unlogged_alloc_mem -= (*it)->GetAllocMem();
         }
         for (it = node->GetScriptChildren()->begin(); it != node->GetScriptChildren()->end(); ++it)
         {
@@ -175 +179 @@
             unlogged_time_turn -= (*it)->GetTurnTime();
             unlogged_mallocs_frame -= (*it)->GetFrameMallocs();
             unlogged_mallocs_turn -= (*it)->GetTurnMallocs();
+            unlogged_alloc_mem -= (*it)->GetAllocMem();
         }
         
         // The root node can't easily count per-turn values (since Turn isn't called until
@@ -193 +198 @@
             sprintf_s(buf, ARRAY_SIZE(buf), "%.3f", unlogged_time_turn * 1000.f);
         else if (col == 6)
             sprintf_s(buf, ARRAY_SIZE(buf), "%.1f", unlogged_mallocs_turn);
+        else if (col == 7) {
+            double d = unlogged_alloc_mem;
+            if (d >= 10.0 * 1024 * 1024)
+                sprintf_s(buf, ARRAY_SIZE(buf), "%.1f MiB", d / 1024.0 / 1024.0);
+            else if (d >= 10.0 * 1024)
+                sprintf_s(buf, ARRAY_SIZE(buf), "%.1f KiB", d / 1024.0);
+            else
+                sprintf_s(buf, ARRAY_SIZE(buf), "%.1f B", d);
+        }
         
         return CStr(buf);
     }
@@ -221 +235 @@
     case 6:
         sprintf_s(buf, ARRAY_SIZE(buf), "%.1f", child->GetTurnMallocs());
         break;
+    case 7:
+    {
+        double d = child->GetAllocMem();
+        if (d >= 10.0 * 1024 * 1024)
+            sprintf_s(buf, ARRAY_SIZE(buf), "%.1f MiB", d / 1024.0 / 1024.0);
+        else if (d >= 10.0 * 1024)
+            sprintf_s(buf, ARRAY_SIZE(buf), "%.1f KiB", d / 1024.0);
+        else
+            sprintf_s(buf, ARRAY_SIZE(buf), "%.1f B", d);
+        break;
+    }
     }
     return CStr(buf);
 }
@@ -264 +289 @@
     name = _name;
     recursion = 0;
 
+    pthread_mutex_init(&alloc_mem_mutex, NULL);
+    alloc_mem = 0;
+
     Reset();
 
     parent = _parent;
@@ -280 +308 @@
         delete( *it );
     
     delete display_table;
+    
+    pthread_mutex_destroy(&alloc_mem_mutex);
 }
 
 template<typename T>
@@ -504 +534 @@
 
 //#define ALLOC_DEBUG
 
+std::map<void*, std::pair<CProfileNode*, size_t> > memtracker_map;
+static pthread_mutex_t memtracker_map_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static volatile pthread_t memtracker_access;
+static volatile bool memtracker_access_valid = false;
+static pthread_mutex_t memtracker_access_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static volatile bool memtracker_enabled = false;
+
+static void memtracker_enable(bool b)
+{
+    memtracker_enabled = b;
+    if (!memtracker_enabled) {
+        debug_printf(L"Disabling breaks memory-tracking\n");
+        pthread_mutex_lock(&memtracker_map_mutex);
+        memtracker_map.clear();
+        pthread_mutex_unlock(&memtracker_map_mutex);
+    }
+}
+
+void memtracker_update(void *o, void *n, size_t s)
+{
+    if (!memtracker_enabled)
+        return;
+
+    while (true) {
+        pthread_mutex_lock(&memtracker_access_mutex);
+        if (!memtracker_access_valid) { // noone here, register
+            memtracker_access = pthread_self();
+            memtracker_access_valid = true;
+            pthread_mutex_unlock(&memtracker_access_mutex);
+            break;
+        } else if (pthread_equal(memtracker_access, pthread_self())) { // same thread, recursiv -> ignore
+            pthread_mutex_unlock(&memtracker_access_mutex);
+            return;
+        } else // other thread, spinlock
+            pthread_mutex_unlock(&memtracker_access_mutex);
+    }
+
+    pthread_mutex_lock(&memtracker_map_mutex);
+    if (o) {
+        if (memtracker_map.count(o)) {
+            memtracker_map[o].first->RemoveAllocMem(memtracker_map[o].second);
+            memtracker_map.erase(o);
+        }
+    }
+    if (n) {
+        if (CProfileManager::IsInitialised() && ThreadUtil::IsMainThread()) {
+            CProfileNode* node = CProfileManager::GetSingleton().GetCurrentWritable();
+            if (node) {
+                memtracker_map[n] = std::pair<CProfileNode*, size_t>(node, s);
+                node->AddAllocMem(s);
+            }
+        }
+    }
+    pthread_mutex_unlock(&memtracker_map_mutex);
+    
+    pthread_mutex_lock(&memtracker_access_mutex);
+    memtracker_access_valid = false;
+    pthread_mutex_unlock(&memtracker_access_mutex);
+}
+
 void* malloc(size_t sz)
 {
     cpu_AtomicAdd(&alloc_count, 1);
@@ -518 +610 @@
 #ifdef ALLOC_DEBUG
     printf("### malloc(%d) = %p\n", sz, ret);
 #endif
+
+    memtracker_update(0, ret, sz);
+
     return ret;
 }
 
@@ -535 +630 @@
 #ifdef ALLOC_DEBUG
     printf("### realloc(%p, %d) = %p\n", ptr, sz, ret);
 #endif
+
+    memtracker_update(ptr, ret, sz);
+
     return ret;
 }
 
@@ -561 +659 @@
 #ifdef ALLOC_DEBUG
     printf("### calloc(%d, %d) = %p\n", nm, sz, ret);
 #endif
+
+    memtracker_update(0, ret, sz*nm);
+
     return ret;
 }
 
@@ -577 +678 @@
 #ifdef ALLOC_DEBUG
     printf("### free(%p)\n", ptr);
 #endif
+
+    memtracker_update(ptr, 0, 0);
 }
 
 static void alloc_hook_initialize()
@@ -626 +729 @@
     return true;
 }
 
+double CProfileNode::GetAllocMem()
+{
+    pthread_mutex_lock(&alloc_mem_mutex);
+    long tmp = alloc_mem;
+    pthread_mutex_unlock(&alloc_mem_mutex);
+
+    std::vector<CProfileNode*>::const_iterator it;
+    for (it = children.begin(); it != children.end(); ++it )
+        tmp += (*it)->GetAllocMem();
+    for (it = script_children.begin(); it != script_children.end(); ++it )
+        tmp += (*it)->GetAllocMem();
+
+    return tmp;
+}
+
 CProfileManager::CProfileManager() :
     root(NULL), current(NULL), needs_structural_reset(false)
 {
@@ -634 +752 @@
 
 CProfileManager::~CProfileManager()
 {
+#if defined(USE_GLIBC_MALLOC_OVERRIDE)
+    memtracker_enable(false);
+#endif
     delete root;
 }
 
@@ -698 +819 @@
 
 void CProfileManager::PerformStructuralReset()
 {
+#if defined(USE_GLIBC_MALLOC_OVERRIDE)
+    memtracker_enable(false);
+#endif
     delete root;
     root = new CProfileNode("root", NULL);
     root->Call();
     current = root;
     g_ProfileViewer.AddRootTable(root->display_table, true);
+#if defined(USE_GLIBC_MALLOC_OVERRIDE)
+    memtracker_enable(true);
+#endif
 }

trunk/source/ps/Profile.h

@@ -65 +65 @@
     double start;
     long start_mallocs;
     int recursion;
+    long alloc_mem;
+    
+    pthread_mutex_t alloc_mem_mutex;
 
     CProfileNode* parent;
     std::vector<CProfileNode*> children;
@@ -86 +89 @@
     double GetTurnTime() const;
     double GetFrameMallocs() const;
     double GetTurnMallocs() const;
+    double GetAllocMem();
+    
+    void RemoveAllocMem(size_t s) { pthread_mutex_lock(&alloc_mem_mutex); alloc_mem -= s; pthread_mutex_unlock(&alloc_mem_mutex); }
+    void AddAllocMem(size_t s) { pthread_mutex_lock(&alloc_mem_mutex); alloc_mem += s; pthread_mutex_unlock(&alloc_mem_mutex); }
 
     const CProfileNode* GetChild( const char* name ) const;
     const CProfileNode* GetScriptChild( const char* name ) const;
@@ -141 +148 @@
     void StructuralReset();
 
     inline const CProfileNode* GetCurrent() { return( current ); }
+    inline CProfileNode* GetCurrentWritable() { return( current ); }
     inline const CProfileNode* GetRoot() { return( root ); }
 };