Context Navigation

-              re6317b
+              r492279
 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
 …
   };
+  boost::mutex memorylock;
+  mutex_t memorylock = mutex_init;
   // start and end of the doubly-linked list
 …
+  }
+  // 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;
+  }
   // Deletes an entry from the linked list
   void deleteEntry(entry_t *entry){
 …
       return;
+    mutex_lock(memorylock);
     if(entry->prev){
       entry->prev->next = entry->next;
 …
       end = entry->prev;
+    }
+    Memory::state  -= entry->info.nbytes;
+    mutex_unlock(memorylock);
     entry->isIgnored = true;
+    Memory::state  -= entry->info.nbytes;
+  }
 …
 void *operator new(size_t nbytes,const char* file, int line, const char* func) 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
   // allocation with 0 byte size are undefined behavior, so we are
 …
     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
 …
   entry->info.location = (char*)res + entrySpace;
+  // 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;
+  // 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);
-  // this will be set to true, when the block is removed from
-  // the list for any reason
-  entry->isIgnored = false;
   // ok, space is prepared... the user can have it.
 …
 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
 …
     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
 …
   entry->info.location = (char*)res + entrySpace;
+  // 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;
+  // mark the block as not in the list (will be changed by addEntry)
+  entry->isIgnored = true;
+  Memory::addEntry(entry);
   // get the checksum...
 …
     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

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 492279 for src

Legend:

src/Helpers/MemDebug.cpp

Download in other formats: