Changeset 257c77 for src/Helpers

Timestamp:

Jun 17, 2010, 2:55:56 PM (15 years ago)

Author:

Tillmann Crueger <crueger@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, Candidate_v1.7.0, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

b47bfc

Parents:

992fd7 (diff), 5f5a7b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'stable' into QT4Refactoring

Conflicts:

molecuilder/src/Actions/TesselationAction/ConvexEnvelopeAction.hpp
molecuilder/src/Helpers/MemDebug.hpp
molecuilder/src/Makefile.am
molecuilder/src/UIElements/Dialog.cpp
molecuilder/src/UIElements/MainWindow.cpp
molecuilder/src/UIElements/TextUI/TextUIFactory.cpp
molecuilder/src/builder.cpp

Location:

src/Helpers

Files:

• Assert.cpp (modified) (5 diffs)
• MemDebug.cpp (modified) (13 diffs)
• MemDebug.hpp (modified) (3 diffs)

src/Helpers/Assert.cpp

@@ -5 +5 @@
  *      Author: crueger
  */
+
+#include "Helpers/MemDebug.hpp"
 
 #include "Helpers/Assert.hpp"
@@ -46 +48 @@
 using namespace Assert;
 
+#ifndef NDEBUG
+
 Action _my_assert::defaultAction = Ask;
 std::vector<Assert::hook_t> _my_assert::hooks;
@@ -52 +56 @@
 const char* _wrapper::message_ptr = "source pointer did not point to object of desired type";
 const char* _wrapper::message_ref = "source reference did not contain object of desired type";
-
 
 
@@ -63 +66 @@
 {
   if(!res){
-    cout << "Assertion " << condition << " failed in file " << filename << " at line " << line << endl;
+    cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
     cout << "Assertion Message: " << message << std::endl;
     while(true){
@@ -123 +126 @@
   return ActionNames[defaultAction];
 }
+
+#endif
+

src/Helpers/MemDebug.cpp

@@ -6 +6 @@
  */
 
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
+
 #include <iostream>
 #include <cstdlib>
@@ -11 +14 @@
 #include <boost/thread.hpp>
 
+#ifdef __GNUC__
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif
+
 using namespace std;
 
-#ifndef NDBEGUG
-#ifndef NO_MEMDEBUG
+// 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
 
 namespace Memory {
@@ -34 +63 @@
       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;
@@ -44 +78 @@
   };
 
-  boost::mutex memorylock;
+
+  mutex_t memorylock = mutex_init;
 
   // start and end of the doubly-linked list
@@ -96 +131 @@
     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;
   }
 
@@ -105 +176 @@
       return;
 
+    mutex_lock(memorylock);
     if(entry->prev){
       entry->prev->next = entry->next;
@@ -120 +192 @@
       end = entry->prev;
     }
+    Memory::state  -= entry->info.nbytes;
+    mutex_unlock(memorylock);
     entry->isIgnored = true;
-    Memory::state  -= entry->info.nbytes;
+
   }
 
@@ -130 +204 @@
     deleteEntry(entry);
   }
-}
-
-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);
+
+#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) {
 
   // to avoid allocations of 0 bytes if someone screws up
@@ -153 +307 @@
   }
 
-  // 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
+  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();
+  }
 
   // build the entry in front of the space
@@ -171 +364 @@
   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...
@@ -196 +380 @@
 }
 
+#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) {
@@ -207 +420 @@
 }
 
+#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
 }
 
@@ -217 +450 @@
     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

src/Helpers/MemDebug.hpp

@@ -28 +28 @@
 #endif
 
-#include <cstdlib>
 #include <new>
+
+// some light header files, that do weird new stuff and therefore need
+// to be loaded before the define
+#include <string>
+#include <boost/optional.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/program_options.hpp>
+
 
 namespace Memory {
@@ -53 +61 @@
   }
 }
-
+#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, const char* func) throw(std::bad_alloc);
+#else
 void *operator new   (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
+#endif
 void operator delete   (void *ptr,const char*, int) throw();
 void operator delete[] (void *ptr,const char*, int) throw();
+
+
 
 /**
@@ -63 +77 @@
  * version that allows tracking.
  */
+#ifdef __GNUC__
+#define new new(__FILE__,__LINE__,__PRETTY_FUNCTION__)
+#else
 #define new new(__FILE__,__LINE__)
+#endif
 
 #endif
 #endif
 
+
+#ifdef NDEBUG
+#undef MEMDEBUG
+#endif
 
 #ifndef MEMDEBUG