Changeset 1775d3 for molecuilder

Timestamp:

Apr 30, 2010, 8:01:18 AM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

8c01ce

Parents:

070651 (diff), c53e0b (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 commit 'jupiter/StructureRefactoring' into StructureRefactoring

Location:

molecuilder/src

Files:

• Helpers/MemDebug.cpp (modified) (10 diffs)
• Helpers/MemDebug.hpp (modified) (2 diffs)
• Plane.cpp (modified) (1 diff)
• Plane.hpp (modified) (2 diffs)
• unittests/vectorunittest.cpp (modified) (2 diffs)
• unittests/vectorunittest.hpp (modified) (3 diffs)
• vector.cpp (modified) (1 diff)

molecuilder/src/Helpers/MemDebug.cpp

@@ -8 +8 @@
 #include <iostream>
 #include <cstdlib>
+#include <cstring>
 
 using namespace std;
 
 namespace Memory {
+
+  // This struct is added before each memory chunk
+  // and contains tracking information. Anything used
+  // to track memory cannot use any dynamic memory, so
+  // we have to resort to classic C-idioms here.
+  // This struct also contains pointers to the next
+  // an previous chunks to allow fast traversion of
+  // all allocated memory blocks
   struct entry_t {
+    // we seperate the tracking info from the rest
+    // A checksum will be calculated for this part of
+    // the struct, so the information in here should
+    // not change during the lifetime of the memory
     struct info_t {
-      char file[256];
+      enum {length = 64};
+      char file[length+1];
       int line;
       size_t nbytes;
@@ -26 +40 @@
   };
 
+  // start and end of the doubly-linked list
   entry_t *begin=0;
   entry_t *end=0;
 
+  // current amount of allocated memory
   size_t state = 0;
+  // maximum amount of allocated memory
   size_t max = 0;
-
+  // number of allocations that have been done so far
+  unsigned int allocs = 0;
+
+
+  // this sets the alignment of the returned memory block
+  // malloc guarantees an alignment at the 8 byte border,
+  // so we just do the same
   const int alignment = 8;
 
+  // calculates a simple checksum for the info block
+  // the checksum is used to find memory corruptions
   inline char calcChecksum(entry_t::info_t *info){
     char *buffer = (char*)info;
@@ -43 +68 @@
   }
 
+  // gets the next alignet point which is greater than nbytes
+  // this function is only called a fixed number of times, so
+  // there is no need to optimize
   inline size_t doAlign(size_t nbytes){
     int nonaligned = nbytes % alignment;
@@ -53 +81 @@
   }
 
+  // Output some state information
   void getState(){
     cout << "Maximum allocated Memory: " << max << " bytes" << endl;
     cout << "Currently allocated Memory: " << state <<" bytes" << endl;
-
+    cout << allocs << " allocated chunks total" << endl;
+
+    // simple traversal of the chunk list
     for(entry_t *pos=begin;pos;pos=pos->next){
       cout << "\nChunk of " << pos->info.nbytes << " bytes" << " still available" << endl;
@@ -63 +94 @@
   }
 
+  // Deletes an entry from the linked list
   void deleteEntry(entry_t *entry){
     if(entry->isIgnored)
       return;
+
     if(entry->prev){
       entry->prev->next = entry->next;
     }
     else{
+      // this node was the beginning of the list
       begin = entry->next;
     }
@@ -77 +111 @@
     }
     else{
+      // this node was the end of the list
       end = entry->prev;
     }
@@ -84 +119 @@
 
   void _ignore(void *ptr){
+    // just deletes the node from the list, but leaves the info intact
     static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
     entry_t *entry = (Memory::entry_t*)((char*)ptr-entrySpace);
@@ -92 +128 @@
 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
   Memory::entry_t *entry = (Memory::entry_t*) res;
   entry->info.nbytes = nbytes;
   entry->info.isUsed = true;
-  strncpy(entry->info.file,file,256);
-  entry->info.file[255] = '\0';
+  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;
+  // the space starts behind the info
   entry->info.location = (char*)res + entrySpace;
 
-  entry->next=0;
-  entry->prev=Memory::end;
+  // 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...
   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.
+  // the rest (constructor, deleting when something is thrown etc)
+  // is handled automatically
   return entry->info.location;
 }
 
 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
   return operator new(nbytes,"Unknown",0);
 }
 
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+  // The difference between new and new[] is just for compiler bookkeeping.
   return operator new(nbytes,file,line);
 }
 
 void *operator new[] (size_t nbytes) throw(std::bad_alloc) {
+  // Forward again
   return operator new[] (nbytes,"Unknown",0);
 }
 
 void operator delete(void *ptr) throw() {
+  // get the size for the entry, including alignment
   static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
 
+  // get the position for the entry from the pointer the user gave us
   Memory::entry_t *entry = (Memory::entry_t*)((char*)ptr-entrySpace);
 
+  // let's see if the checksum is still matching
   if(Memory::calcChecksum(&entry->info)!=entry->checksum){
     cout << "Possible memory corruption detected!" << endl;
@@ -156 +217 @@
   }
 
+  // this will destroy the checksum, so double deletes are caught
   entry->info.isUsed = false;
   Memory::deleteEntry(entry);
 
+  // delete the space reserved by malloc
   free((char*)ptr-entrySpace);
 }
 
+// operator that is called when the constructor throws
+// do not call manually
 void operator delete(void *ptr,const char*, int) throw() {
   operator delete(ptr);
@@ -167 +232 @@
 
 void operator delete[](void *ptr){
+  // again difference between delete and delete[] is just in compiler bookkeeping
   operator delete(ptr);
 }
 
+// and another operator that can be called when a constructor throws
 void operator delete[](void *ptr,const char*, int) throw(){
   operator delete(ptr);

molecuilder/src/Helpers/MemDebug.hpp

@@ -9 +9 @@
 #define MEMDEBUG_HPP_
 
+/**
+ * @file
+ * This module allows easy automatic memory tracking. Link this module to replace the
+ * operators new, new[], delete and delete[] with custom versions that add tracking
+ * information to allocated blocks.
+ *
+ * All tracking is done in O(1) for new and delete operators. Summaries for the
+ * used memory take O(N), where N is the number of currently allocated memory chunks.
+ *
+ * To use full tracking including file name and line number include this file in
+ * your sourcefiles.
+ */
+
 namespace Memory {
+
+  /**
+   * Displays a short summary of the memory state.
+   */
   void getState();
 
   void _ignore(void*);
 
+  /**
+   * Use this to disable memory for a certain pointer on the heap.
+   * This is useful for pointers which should live over the run of the
+   * program, and which are deleted automatically at the end. Usually these
+   * pointers should be wrapped inside some kind of smart pointer to
+   * ensure destruction at the end.
+   */
   template <typename T>
   T *ignore(T* ptr){
@@ -26 +50 @@
 void operator delete[] (void *ptr,const char*, int) throw();
 
-
+/**
+ * This macro replaces all occurences of the keyword new with a replaced
+ * version that allows tracking.
+ */
 #define new new(__FILE__,__LINE__)
 

molecuilder/src/Plane.cpp

@@ -98 +98 @@
 }
 
+vector<Vector> Plane::getPointsOnPlane(){
+  std::vector<Vector> res;
+  // first point on the plane
+  res[0] = getOffsetVector();
+  // first is orthogonal to the plane...
+  // an orthogonal vector to this one lies on the plane
+  Vector direction;
+  direction.GetOneNormalVector(res[0]);
+  res[1] = res[0]+direction;
+  // get an orthogonal vector to direction and offset (lies on the plane)
+  direction.VectorProduct(res[0]);
+  direction.Normalize();
+  res[2] = res[0] +direction;
+  return res;
+}
+
+
 /** Calculates the intersection point between a line defined by \a *LineVector and \a *LineVector2 and a plane defined by \a *Normal and \a *PlaneOffset.
  * According to [Bronstein] the vectorial plane equation is:

molecuilder/src/Plane.hpp

@@ -10 +10 @@
 
 #include <memory>
+#include <vector>
 
 class Vector;
@@ -38 +39 @@
   Vector getOffsetVector();
 
+  /**
+   * returns three seperate points on this plane
+   */
+  std::vector<Vector> getPointsOnPlane();
+
   // some calculations
   Vector GetIntersection(const Vector &Origin, const Vector &LineVector);

molecuilder/src/unittests/vectorunittest.cpp

@@ -43 +43 @@
   notunit = Vector(0.,1.,1.);
   two = Vector(2.,1.,0.);
+  three = Vector(1,2,3);
 };
 
@@ -185 +186 @@
   CPPUNIT_ASSERT_EQUAL( Vector(0.,1.,0.),  two.Projection(otherunit) );
 };
+
+/**
+ * Unittest for operation with normals
+ */
+void VectorTest::NormalsTest(){
+  Vector testVector;
+  // the zero Vector should produce an error
+  CPPUNIT_ASSERT(!testVector.GetOneNormalVector(zero));
+
+  // first one-component system
+  CPPUNIT_ASSERT(testVector.GetOneNormalVector(unit));
+  CPPUNIT_ASSERT(testVector.ScalarProduct(unit) < MYEPSILON);
+
+  // second one-component system
+  CPPUNIT_ASSERT(testVector.GetOneNormalVector(otherunit));
+  CPPUNIT_ASSERT(testVector.ScalarProduct(otherunit) < MYEPSILON);
+
+  // first two-component system
+  CPPUNIT_ASSERT(testVector.GetOneNormalVector(notunit));
+  CPPUNIT_ASSERT(testVector.ScalarProduct(notunit) < MYEPSILON);
+
+  // second two-component system
+  CPPUNIT_ASSERT(testVector.GetOneNormalVector(two));
+  CPPUNIT_ASSERT(testVector.ScalarProduct(two) < MYEPSILON);
+
+  // three component system
+  CPPUNIT_ASSERT(testVector.GetOneNormalVector(three));
+  CPPUNIT_ASSERT(testVector.ScalarProduct(three) < MYEPSILON);
+}
 
 /** UnitTest for line intersections.

molecuilder/src/unittests/vectorunittest.hpp

@@ -26 +26 @@
     CPPUNIT_TEST ( EuclidianAnglesTest );
     CPPUNIT_TEST ( ProjectionTest );
+    CPPUNIT_TEST ( NormalsTest );
     CPPUNIT_TEST ( LineIntersectionTest );
     CPPUNIT_TEST ( VectorRotationTest );
@@ -43 +44 @@
     void EuclidianAnglesTest();
     void ProjectionTest();
+    void NormalsTest();
     void LineIntersectionTest();
     void VectorRotationTest();
@@ -56 +58 @@
     Vector notunit;
     Vector two;
+    Vector three;
 };
 

molecuilder/src/vector.cpp

@@ -647 +647 @@
   for (j=NDIM;j--;)
     Components[j] = -1;
+
+  // in two component-systems we need to find the one position that is zero
+  int zeroPos = -1;
   // find two components != 0
-  for (j=0;j<NDIM;j++)
+  for (j=0;j<NDIM;j++){
     if (fabs(GivenVector[j]) > MYEPSILON)
       Components[Last++] = j;
+    else
+      // this our zero Position
+      zeroPos = j;
+  }
 
   switch(Last) {
     case 3:  // threecomponent system
+      // the position of the zero is arbitrary in three component systems
+      zeroPos = Components[2];
     case 2:  // two component system
       norm = sqrt(1./(GivenVector[Components[1]]*GivenVector[Components[1]]) + 1./(GivenVector[Components[0]]*GivenVector[Components[0]]));
-      x[Components[2]] = 0.;
+      at(zeroPos) = 0.;
       // in skp both remaining parts shall become zero but with opposite sign and third is zero
-      x[Components[1]] = -1./GivenVector[Components[1]] / norm;
-      x[Components[0]] = 1./GivenVector[Components[0]] / norm;
+      at(Components[1]) = -1./GivenVector[Components[1]] / norm;
+      at(Components[0]) = 1./GivenVector[Components[0]] / norm;
       return true;
       break;
     case 1: // one component system
       // set sole non-zero component to 0, and one of the other zero component pendants to 1
-      x[(Components[0]+2)%NDIM] = 0.;
-      x[(Components[0]+1)%NDIM] = 1.;
-      x[Components[0]] = 0.;
+      at((Components[0]+2)%NDIM) = 0.;
+      at((Components[0]+1)%NDIM) = 1.;
+      at(Components[0]) = 0.;
       return true;
       break;