Added test for pool allocator.

[[Imported from SVN: r1988]]

common/test/.gitignore

@@ -12,6 +12,7 @@ sllisttest
 tuplestest
 settest
 fmatrixtest
+poolallocatertest
 *.gcda
 *.gcno
 gmon.out
\ No newline at end of file

common/test/Makefile.am

 # $Id$
 
 TESTPROGS = parsetest test-stack arraylisttest smartpointertest \
-	sllisttest iteratorfacadetest tuplestest fmatrixtest
+	sllisttest iteratorfacadetest tuplestest fmatrixtest \
+	poolallocatortest
 
 # which tests to run
 TESTS = $(TESTPROGS)
@@ -31,3 +32,5 @@ iteratorfacadetest_SOURCES = iteratorfacadetest.cc iteratorfacadetest.hh \
    iteratortest.hh
 
 fmatrixtest_SOURCES = fmatrixtest.cc
+
+poolallocatortest_SOURCES = poolallocatortest.cc

common/test/poolallocatortest.cc

+// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+// vi: set et ts=4 sw=2 sts=2:
+#include <dune/common/poolallocator.hh>
+#include <dune/common/alignment.hh>
+#include <dune/common/fmatrix.hh>
+
+using namespace Dune;
+
+struct UnAligned
+{
+  char t;
+  char s;
+  char k;
+};
+
+
+
+template<std::size_t size, typename T>
+int testPool()
+{
+  int ret=0;
+
+  Pool<T,size> pool;
+
+  int elements = Pool<T,size>::elements;
+  //int poolSize        = Pool<T,size>::size;
+  //int chunkSize   = Pool<T,size>::chunkSize;
+  //int alignedSize = Pool<T,size>::alignedSize;
+
+  char** fields= new char*[10];
+  unsigned long* oelements = new unsigned long[10*elements];
+
+  typedef typename Pool<T,size>::Chunk Chunk;
+
+  //Fill 10 chunks
+  for(int chunk=0; chunk < 10; ++chunk) {
+    //std::cout<< std::endl<<"Chunk "<<chunk<<" ";
+    //fields[chunk] = new char[333];
+    unsigned long element = reinterpret_cast<unsigned long>(pool.allocate());
+    void* celement = reinterpret_cast<void*>(element);
+    //std::cout << element<<" "<< celement<<",  "<<std::endl;
+
+    Chunk* currentChunk = pool.chunks_;
+
+    assert(element==reinterpret_cast<unsigned long>(currentChunk->memory_));
+    unsigned long end = reinterpret_cast<unsigned long>(currentChunk->chunk_)+Pool<T,size>::chunkSize;
+
+    if(element< reinterpret_cast<unsigned long>(currentChunk->chunk_))
+    {
+      std::cerr <<" buffer overflow during first alloc: "<<reinterpret_cast<unsigned long>(currentChunk->chunk_)
+                <<">"<<element<<"+"<<sizeof(T)<<std::endl;
+      return ++ret;
+    }
+
+    if(end < element + sizeof(T)) {
+      std::cerr <<" buffer overflow during first alloc: "<<end<<"<"<<element<<"+"<<sizeof(T)<<std::endl;
+      return ++ret;
+    }
+
+    oelements[chunk*elements]=element;
+
+    for(int i=1; i < elements; i++)
+    {
+      element = reinterpret_cast<unsigned long>(pool.allocate());
+      celement = reinterpret_cast<void*>(element);
+
+      //  std::cout << element<<" "<<celement<<",  "<<std::endl;
+
+      if(element< reinterpret_cast<unsigned long>(currentChunk->chunk_)) {
+        std::cerr <<" buffer overflow during first alloc: "<<reinterpret_cast<unsigned long>(currentChunk->chunk_)
+                  <<">"<<element<<"+"<<sizeof(T)<<std::endl;
+        return ++ret;
+      }
+
+      if(end < element + sizeof(T)) {
+        std::cerr <<" buffer overflow during "<<i<<" alloc: "<<end<<"<"<<element+sizeof(T)<<std::endl;
+        return ++ret;
+
+      }
+
+      if(oelements[chunk*elements+i-1]+sizeof(T)>element) {
+        std::cerr<<"allocated elements overlap!"<<std::endl;
+        return ++ret;
+      }
+
+      oelements[chunk*elements+i]=element;
+    }
+  }
+
+  //for(int chunk=0; chunk < 10; ++chunk)
+  //delete[] fields[chunk];
+
+  delete[] fields;
+  delete[] oelements;
+
+  return ret;
+}
+
+template<typename T>
+int testPool()
+{
+  const std::size_t size = sizeof(T)>=2 ? sizeof(T)-2 : 0;
+
+  int ret=0;
+
+  std::cout<<"Checking "<<typeid(T).name()<<" sizeof="<<sizeof(T)<<" with size "<< size<<
+  " alignment="<<AlignmentOf<T>::value<<std::endl;
+
+  std::cout<<"size="<<0<<std::endl;
+  ret += testPool<0,T>();
+  std::cout<<"size="<<size<<std::endl;
+  ret += testPool<size,T>();
+  std::cout<<"size="<<5*size<<std::endl;
+  ret += testPool<5*size,T>();
+  std::cout<<"size="<<11*size<<std::endl;
+  ret += testPool<11*size,T>();
+  std::cout<<"size="<<size<<std::endl;
+  ret += testPool<33*size,T>();
+  std::cout<<"size="<<33*size<<std::endl;
+
+
+
+  return ret;
+}
+int main(int argc, char **argv)
+{
+  int ret=0;
+  /*
+     ret += testPool<int>();
+
+     ret+= testPool<double>();
+
+     ret+= testPool<char>();
+
+     ret += testPool<Dune::FieldMatrix<double,10,10> >();
+   */
+
+  std::cout<<AlignmentOf<UnAligned>::value<<" "<<sizeof(UnAligned)<<std::endl;
+
+  ret += testPool<UnAligned>();
+
+  return ret;
+}