Changes in src/Helpers/MemDebug.cpp [fc6053:f2f4ae]

File:

• src/Helpers/MemDebug.cpp (modified) (13 diffs)

src/Helpers/MemDebug.cpp ¶

@@ -6 +6 @@
  */
 
-#ifndef NDBEGUG
-#ifndef NO_MEMDEBUG
-
 #include <iostream>
 #include <cstdlib>
@@ -14 +11 @@
 #include <boost/thread.hpp>
 
-#ifdef __GNUC__
-#include <execinfo.h>
-#include <cxxabi.h>
-#endif
-
 using namespace std;
 
-// we need our own low level mutexex, since we cannot assure the time of construction and destruction
-// otherwise
-#if defined(unix) || defined(__unix)
-
-#include <pthread.h>
-#include <cassert>
-#define mutex_t    pthread_mutex_t
-#define mutex_init PTHREAD_MUTEX_INITIALIZER
-#define mutex_lock(mtx) \
-  do{\
-    int res = pthread_mutex_lock(&(mtx));\
-    assert(!res && "Could not lock mutex!");\
-  }while(0)
-
-#define mutex_unlock(mtx) \
-  do{\
-    int res = pthread_mutex_unlock(&(mtx));\
-    assert(!res && "Could not unlock mutex!");\
-  }while(0)
-
-#else
-# error "No thread structure defined for this plattform..."
-#endif
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
 
 namespace Memory {
@@ -63 +34 @@
       char file[length+1];
       int line;
-#ifdef __GNUC__  // function tracking only works with GCC
-      // function names can get looooong
-      enum {length2 = 256};
-      char function[length2+1];
-#endif
       size_t nbytes;
       bool isUsed;
@@ -78 +44 @@
   };
 
-
-  mutex_t memorylock = mutex_init;
+  boost::mutex memorylock;
 
   // start and end of the doubly-linked list
@@ -131 +96 @@
     for(entry_t *pos=begin;pos;pos=pos->next){
       cout << "\nChunk of " << pos->info.nbytes << " bytes" << " still available" << endl;
-#ifdef __GNUC__
-      cout << "Chunk reserved at: " << pos->info.function
-           << " (" << pos->info.file << ":" << pos->info.line  << ")" << endl;
-#else
       cout << "Chunk reserved at: " << pos->info.file << ":" << pos->info.line << endl;
-#endif
-    }
-  }
-
-  // Adds an entry to the linked list
-  void addEntry(entry_t *entry){
-    // check if the entry is already in the list
-    if(!entry->isIgnored)
-      return;
-
-    mutex_lock(Memory::memorylock);
-
-    entry->next=0;            // the created block is last in the list
-    entry->prev=Memory::end;  // the created block is last in the list
-    if(!Memory::begin){
-      // the list was empty... start a new one
-      Memory::begin=entry;
-    }
-    else {
-      // other blocks present... we can add to the last one
-      Memory::end->next=entry;
-    }
-    Memory::end=entry;
-
-    // update some global info
-    Memory::state  += entry->info.nbytes;
-    if(Memory::state>Memory::max){
-        Memory::max = Memory::state;
-    }
-    ++Memory::allocs;
-    // done with the list... it is safe to unlock now
-    mutex_unlock(Memory::memorylock);
-    entry->isIgnored = false;
+    }
   }
 
@@ -176 +105 @@
       return;
 
-    mutex_lock(memorylock);
     if(entry->prev){
       entry->prev->next = entry->next;
@@ -192 +120 @@
       end = entry->prev;
     }
+    entry->isIgnored = true;
     Memory::state  -= entry->info.nbytes;
-    mutex_unlock(memorylock);
-    entry->isIgnored = true;
-
   }
 
@@ -204 +130 @@
     deleteEntry(entry);
   }
-
-#ifdef __GNUC__
-  // this function let's us find the caller's name
-  char* getCaller(){
-    // stack looks like this:
-    // getCaller();
-    // operator new();
-    // function_we_are_looking_for(); <-
-    const size_t max_depth = 3;
-    void* stack_addrs[max_depth];
-    size_t stack_depth;
-    char **stack_strings=0;
-    const char *func_name=0;
-    const char *toplevel = "Global scope";
-    char *retval=0;
-
-    // get the backtrace, depth three
-    stack_depth   = backtrace(stack_addrs,max_depth);
-    stack_strings = backtrace_symbols(stack_addrs, stack_depth);
-    // used later for demangling
-    // reserved here, so we can free it unconditionally
-    char *dm_function = static_cast<char*>(malloc(entry_t::info_t::length2));
-    if(!dm_function){
-      // malloc failed... we are out of luck
-      throw std::bad_alloc();
-    }
-
-    // see if we found our function name
-    if(stack_depth==max_depth){
-      // find the mangled function name
-      char *begin = stack_strings[max_depth-1];
-      // function name starts with a (
-      while(*begin && *begin!='(') ++begin;
-      char *end=begin;
-      while(*end && *end!='+') ++end;
-
-      // see if we found our function name
-      if(*begin && *end){
-        *begin++ = 0;
-        *end = 0;
-        // use the C++ demangler
-
-        size_t sz = entry_t::info_t::length2;
-        int status;
-        char *func_ret = abi::__cxa_demangle(begin, dm_function, &sz, &status);
-        if(func_ret){
-          // abi might have realloced...
-          dm_function = func_ret;
-          func_name = dm_function;
-        }
-        else{
-          // demangling failed... get the function name without demangling
-          func_name = begin;
-        }
-      }
-      else{
-        // function name not found... get the whole line
-        func_name = stack_strings[max_depth-1];
-      }
-
-    }
-    else{
-      func_name = toplevel;
-    }
-
-    // now we copy the desired function name
-    if((retval = static_cast<char*>(malloc(strlen(func_name)+1)))){
-      // we know that the string will fit, so strcpy is safe here
-      strcpy(retval,func_name);
-    }
-    else{
-      free(stack_strings); // malloc()ed by backtrace_symbols
-      free(dm_function);
-      // uh-uh ... seems we are out of luck for allocations now
-      throw std::bad_alloc();
-    }
-    free(dm_function);
-    free(stack_strings); // malloc()ed by backtrace_symbols
-    return retval;
-  }
-#endif
-}
-
-#ifdef __GNUC__
-
-void *operator new(size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
+}
+
+void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+
+  // we need to lock, so that no one changes the linked list while we are here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
 
   // to avoid allocations of 0 bytes if someone screws up
@@ -307 +153 @@
   }
 
-  // build the entry in front of the space
-  Memory::entry_t *entry = (Memory::entry_t*) res;
-  memset(res,0,entrySpace);
-  entry->info.nbytes = nbytes;
-  entry->info.isUsed = true;
-  strncpy(entry->info.file,file,Memory::entry_t::info_t::length);
-  entry->info.file[Memory::entry_t::info_t::length] = '\0';
-  entry->info.line=line;
-  strncpy(entry->info.function,func,Memory::entry_t::info_t::length2);
-  entry->info.function[Memory::entry_t::info_t::length2] = '\0';
-  // the space starts behind the info
-  entry->info.location = (char*)res + entrySpace;
-
-  // mark the block as not in the list (will be changed by addEntry)
-  entry->isIgnored = true;
-  Memory::addEntry(entry);
-
-  // get the checksum...
-  entry->checksum = Memory::calcChecksum(&entry->info);
-
-  // ok, space is prepared... the user can have it.
-  // the rest (constructor, deleting when something is thrown etc)
-  // is handled automatically
-  return entry->info.location;
-}
-
-#else
-
-void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
-
-  // to avoid allocations of 0 bytes if someone screws up
-  // allocation with 0 byte size are undefined behavior, so we are
-  // free to handle it this way
-  if(!nbytes) {
-    nbytes = 1;
-  }
-
-  // get the size of the entry, including alignment
-  static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
-
-  void *res;
-  if(!(res=malloc(entrySpace + nbytes))){
-    // new must throw, when space is low
-    throw std::bad_alloc();
-  }
+  // we got the space, so update the global info
+  Memory::state += nbytes;
+  if(Memory::state>Memory::max){
+    Memory::max = Memory::state;
+  }
+  Memory::allocs++;
 
   // build the entry in front of the space
@@ -364 +171 @@
   entry->info.location = (char*)res + entrySpace;
 
-  // mark the block as not in the list (will be changed by addEntry)
-  entry->isIgnored = true;
-  Memory::addEntry(entry);
+  // add the entry at the end of the list
+  entry->next=0;            // the created block is last in the list
+  entry->prev=Memory::end;  // the created block is last in the list
+  if(!Memory::begin){
+    // the list was empty... start a new one
+    Memory::begin=entry;
+  }
+  else {
+    // other blocks present... we can add to the last one
+    Memory::end->next=entry;
+  }
+  Memory::end=entry;
 
   // get the checksum...
@@ -380 +196 @@
 }
 
-#endif
-
 void *operator new(size_t nbytes) throw(std::bad_alloc) {
   // Just forward to the other operator, when we do not know from
   // where the allocation came
-#ifdef __GNUC__
-  // this might throw bad_alloc
-  char *caller = Memory::getCaller();
-  void* retval = 0;
-
-  // if this throws, we have to clean up the caller anyway
-  try{
-    retval = operator new(nbytes,"Unknown",0,caller);
-  }
-  catch(...)
-  {
-    free(caller); // malloc()ed by Memory::getCaller();
-    throw;
-  }
-  free(caller); // malloc()ed by Memory::getCaller();
-  return retval;
-#else
   return operator new(nbytes,"Unknown",0);
-#endif
-}
-
-#ifdef __GNUC__
-
-void *operator new[] (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
-  // The difference between new and new[] is just for compiler bookkeeping.
-  return operator new(nbytes,file,line,func);
-}
-
-#else
+}
 
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
@@ -420 +207 @@
 }
 
-#endif
-
 void *operator new[] (size_t nbytes) throw(std::bad_alloc) {
   // Forward again
-#ifdef __GNUC__
-  // this might throw bad_alloc
-    char *caller = Memory::getCaller();
-    void *retval=0;
-
-    // if this throws, we have to clean up the caller anyway
-    try{
-      retval = operator new[] (nbytes,"Unknown",0,caller);
-    }
-    catch(...)
-    {
-      free(caller); // malloc()ed by Memory::getCaller();
-      throw;
-    }
-    free(caller); // malloc()ed by Memory::getCaller();
-    return retval;
-#else
   return operator new[] (nbytes,"Unknown",0);
-#endif
 }
 
@@ -450 +217 @@
     return;
   }
+
+  // we need to lock, so the linked list does not changed while we are in here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
 
   // get the size for the entry, including alignment