[GNUnet-SVN] r10587 - in GNUnet/src/util: containers string

[gnunet]

Author: durner
Date: 2010-03-13 11:49:36 +0100 (Sat, 13 Mar 2010)
New Revision: 10587

Modified:
   GNUnet/src/util/containers/multihashmap.c
   GNUnet/src/util/string/xmalloc.c
Log:
incomplete mem tracker

Modified: GNUnet/src/util/containers/multihashmap.c
===================================================================
--- GNUnet/src/util/containers/multihashmap.c   2010-03-13 10:01:44 UTC (rev 
10586)
+++ GNUnet/src/util/containers/multihashmap.c   2010-03-13 10:49:36 UTC (rev 
10587)
@@ -27,6 +27,16 @@
 #include "gnunet_util.h"
 #include "gnunet_util_containers.h"
 
+#define WRITE_MEM_STATS 1
+
+#if WRITE_MEM_STATS
+  #define HM_MALLOC malloc
+  #define HM_FREE free
+#else
+  #define HM_MALLOC GNUNET_malloc
+  #define HM_FREE GNUNET_free
+#endif
+
 struct MapEntry
 {
   GNUNET_HashCode key;
@@ -49,9 +59,9 @@
 {
   struct GNUNET_MultiHashMap *ret;
 
-  ret = GNUNET_malloc (sizeof (struct GNUNET_MultiHashMap));
+  ret = HM_MALLOC (sizeof (struct GNUNET_MultiHashMap));
   ret->size = 0;
-  ret->map = GNUNET_malloc (len * sizeof (struct MapEntry *));
+  ret->map = HM_MALLOC (len * sizeof (struct MapEntry *));
   memset (ret->map, 0, len * sizeof (struct MapEntry *));
   ret->map_length = len;
   return ret;
@@ -68,11 +78,11 @@
       while (NULL != (e = map->map[i]))
         {
           map->map[i] = e->next;
-          GNUNET_free (e);
+          HM_FREE (e);
         }
     }
-  GNUNET_free (map->map);
-  GNUNET_free (map);
+  HM_FREE (map->map);
+  HM_FREE (map);
 }
 
 static unsigned int
@@ -148,7 +158,7 @@
             map->map[i] = e->next;
           else
             p->next = e->next;
-          GNUNET_free (e);
+          HM_FREE (e);
           map->size--;
           return GNUNET_YES;
         }
@@ -179,7 +189,7 @@
             map->map[i] = e->next;
           else
             p->next = e->next;
-          GNUNET_free (e);
+          HM_FREE (e);
           map->size--;
           if (p == NULL)
             e = map->map[i];
@@ -225,7 +235,7 @@
   old = map->map;
   l = map->map_length;
   map->map_length *= 2;
-  map->map = GNUNET_malloc (sizeof (struct MapEntry *) * map->map_length);
+  map->map = HM_MALLOC (sizeof (struct MapEntry *) * map->map_length);
   memset (map->map, 0, sizeof (struct MapEntry *) * map->map_length);
   for (i = 0; i < l; i++)
     {
@@ -236,7 +246,7 @@
           map->map[idx_of (map, &e->key)] = e;
         }
     }
-  GNUNET_free (old);
+  HM_FREE (old);
 }
 
 int
@@ -270,7 +280,7 @@
       grow (map);
       i = idx_of (map, key);
     }
-  e = GNUNET_malloc (sizeof (struct MapEntry));
+  e = HM_MALLOC (sizeof (struct MapEntry));
   e->key = *key;
   e->value = value;
   e->next = map->map[i];

Modified: GNUnet/src/util/string/xmalloc.c
===================================================================
--- GNUnet/src/util/string/xmalloc.c    2010-03-13 10:01:44 UTC (rev 10586)
+++ GNUnet/src/util/string/xmalloc.c    2010-03-13 10:49:36 UTC (rev 10587)
@@ -32,12 +32,70 @@
 #define INT_MAX 0x7FFFFFFF
 #endif
 
-#define RECORD_USAGE 0
+#define RECORD_USAGE 1
+#define WRITE_MEM_STATS 1
 
 #if RECORD_USAGE
-volatile int GNUNET_memory_usage = 0;
+volatile unsigned long long GNUNET_memory_usage = 0;
 #endif
 
+#if WRITE_MEM_STATS
+  struct GNUNET_MultiHashMap *map;
+
+  typedef struct
+  {
+    char *filename;
+    int line;
+    size_t size;
+  } GNUNET_MemBlock;
+#endif
+
+#if WRITE_MEM_STATS
+static void __attribute__ ((constructor)) xmalloc_init()
+  {
+    map = GNUNET_multi_hash_map_create (50);
+    GNUNET_GE_ASSERT (NULL, map);
+  }
+
+static int map_iter (const GNUNET_HashCode *key, void *value, void *cls)
+  {
+    GNUNET_MemBlock *block;
+
+    block = (GNUNET_MemBlock *) value;
+
+    FPRINTF ((FILE *) cls, "%p;%u;%s:%u\n", key, block->size, block->filename, 
block->line);
+    return GNUNET_YES;
+  }
+
+static void __attribute__ ((destructor)) xmalloc_deinit()
+  {
+    FILE *f;
+    char fn[4097], *path;
+
+#ifdef MINGW
+    path = getenv ("USERPROFILE");
+#else
+    path = getenv ("HOME");
+#endif
+
+    snprintf (fn, 4096, "%s/gnunet_mem_stats.txt", path);
+    f = FOPEN (fn, "w");
+    if (!f)
+      {
+        PRINTF ("Cannot write memory statistics to %s: %s\n", fn, 
STRERROR(errno));
+        return;
+      }
+
+    FPRINTF (f, "Total: %llu\n\n", GNUNET_memory_usage);
+    fprintf (f, "ptr;size;source\n");
+    GNUNET_multi_hash_map_iterate (map, map_iter, f);
+    fputs ("\n*** end ***\n", f);
+
+    GNUNET_free (fn);
+    fclose (f);
+  }
+#endif
+
 /**
  * Allocate memory. Checks the return value, aborts if no more
  * memory is available.
@@ -65,6 +123,10 @@
 GNUNET_xmalloc_unchecked_ (size_t size, const char *filename, int linenumber)
 {
   void *result;
+#if WRITE_MEM_STATS
+  GNUNET_HashCode key;
+  GNUNET_MemBlock *block;
+#endif
 
   GNUNET_GE_ASSERT_FL (NULL, size < INT_MAX, filename, linenumber);
 
@@ -84,7 +146,25 @@
   *((size_t *) result) = size;
   result += sizeof (size_t);
   GNUNET_memory_usage += size;
+#if WRITE_MEM_STATS
+  if (!map)
+    xmalloc_init();
+
+  memset (&key, 0, sizeof (GNUNET_HashCode));
+  memcpy (&key, result, sizeof (void *));
+  block = GNUNET_multi_hash_map_get (map, &key);
+  if (block)
+    block->size += size;
+  else
+    {
+      block = malloc (sizeof (GNUNET_MemBlock));
+      block->filename = strdup (filename);
+      block->line = linenumber;
+      block->size = size;
+      GNUNET_GE_ASSERT (NULL, GNUNET_multi_hash_map_put (map, &key, block, 
GNUNET_MultiHashMapOption_UNIQUE_ONLY) == GNUNET_YES);
+    }
 #endif
+#endif
 
   memset (result, 0, size);     /* client code should not rely on this, 
though... */
   return result;
@@ -107,8 +187,31 @@
                   const size_t n, const char *filename, int linenumber)
 {
 #if RECORD_USAGE
+  size_t old;
+#if WRITE_MEM_STATS
+  GNUNET_HashCode key;
+  GNUNET_MemBlock *block;
+#endif
+
   ptr -= sizeof (size_t);
-  GNUNET_memory_usage = GNUNET_memory_usage - (*((size_t *) ptr)) + n;
+  old = (*((size_t *) ptr));
+  GNUNET_memory_usage = GNUNET_memory_usage - old + n;
+
+  memset (&key, 0, sizeof (GNUNET_HashCode));
+  memcpy (&key, ptr, sizeof (void *));
+  block = GNUNET_multi_hash_map_get (map, &key);
+  if (block)
+    {
+      block->size = block->size - old + n;
+
+      if (!block->size)
+        {
+          GNUNET_multi_hash_map_remove_all (map, &key);
+          free (block->filename);
+          free (block);
+        }
+    }
+
   *((size_t *) ptr) = n;
   (*((size_t *) & n)) += sizeof (size_t);
 #endif
@@ -139,13 +242,30 @@
 void
 GNUNET_xfree_ (void *ptr, const char *filename, int linenumber)
 {
+#if WRITE_MEM_STATS
+  GNUNET_HashCode key;
+  GNUNET_MemBlock *block;
+#endif
+
   GNUNET_GE_ASSERT_FL (NULL, ptr != NULL, filename, linenumber);
 
 #if RECORD_USAGE
   ptr -= sizeof (size_t);
   GNUNET_memory_usage -= *((size_t *) ptr);
 #endif
+#if WRITE_MEM_STATS
+  memset (&key, 0, sizeof (GNUNET_HashCode));
+  memcpy (&key, ptr, sizeof (void *));
+  block = GNUNET_multi_hash_map_get (map, &key);
 
+  if (block)
+    {
+      GNUNET_multi_hash_map_remove_all (map, &key);
+      free (block->filename);
+      free (block);
+    }
+#endif
+
   free (ptr);
 }