1 files changed, 185 insertions, 7 deletions
diff --git a/libstdc++-v3/testsuite/performance/allocator.cc b/libstdc++-v3/testsuite/performance/allocator.cc
index a70eda5bd25..42997e952ca 100644
--- a/libstdc++-v3/testsuite/performance/allocator.cc
+++ b/libstdc++-v3/testsuite/performance/allocator.cc
@@ -25,15 +25,193 @@
 // invalidate any other reasons why the executable file might be covered by
 // the GNU General Public License.
 
-#include <list>
+/*
+ * 
+ *
+ * The goal with this application is to compare the performance
+ * between different STL allocators relative to the default
+ * __pool_alloc.
+ *
+ * The container used for the tests is vector, which as stated by
+ * SGI "Vector is the simplest of the STL container classes, and in 
+ * many cases the most efficient.".
+ *
+ * NOTE! The vector<> container does some "caching" of it's own and
+ * therefore we redeclare the variable in each iteration (forcing the
+ * const/destr to be called and thus free memory).
+ *
+ * NOTE! The usage of gettimeofday is unwanted since it's not POSIX,
+ * however I have not found a more generic system call to use - 
+ * ideas are greatly appriciated!
+ *
+ * NOTE! This version only does operations on vector<int>. More/other
+ * data types should maybe also be tested - ideas are always welcome!
+ *
+ * I assume that glibc/underlying malloc() implementation has been
+ * compiled with -O2 thus should this application also be compiled
+ * with -O2 in order to get relevant results.
+ */
+
+// 2003-02-05 Stefan Olsson <stefan@snon.net>
+
+#include <vector>
+#include <sys/time.h>
+#include <ext/mt_allocator.h>
+#include <ext/malloc_allocator.h>
+#include <testsuite_performance.h>
+
+using namespace std;
+using __gnu_cxx::__malloc_alloc;
+using __gnu_cxx::__mt_alloc;
+
+/*
+ * In order to avoid that the time it takes for the application to 
+ * startup/shutdown affect the end result, we define a target 
+ * duration (in seconds) for which all tests should run.
+ * Each test is responsible for "calibrating" their # of iterations 
+ * to come as close as possible to this target based on the time
+ * it takes to complete the test using the default __pool_alloc.
+ */
+int target_run_time = 10;
+
+/*
+ * The number of iterations to be performed in order to figure out
+ * the "speed" of this computer and adjust the number of iterations
+ * needed to come close to target_run_time.
+ */
+int calibrate_iterations = 100000;
+
+/*
+ * The number of values to insert in the vector, 32 will cause 
+ * 5 (re)allocations to be performed (sizes 4, 8, 16, 32 and 64)
+ * This means that all allocations are within _MAX_BYTES = 128
+ * as defined in stl_alloc.h for __pool_alloc.
+ * Whether or not this value is relevant in "the real world" 
+ * or not I don't know and should probably be investigated in 
+ * more detail.
+ */
+int insert_values = 32;
+
+static struct timeval _tstart, _tend;
+static struct timezone tz;
+
+void
+tstart(void)
+{
+  gettimeofday(&_tstart, &tz);
+}
+
+void
+tend(void)
+{
+  gettimeofday(&_tend, &tz);
+}
+
+double
+tval()
+{
+  double t1, t2;
+
+  t1 =(double)_tstart.tv_sec +(double)_tstart.tv_usec/(1000*1000);
+  t2 =(double)_tend.tv_sec +(double)_tend.tv_usec/(1000*1000);
+  return t2 - t1;
+}
+
+int
+calibrate_test_ints(void)
+{
+  tstart();
+  for (int i = 0; i < calibrate_iterations; i++)
+  {
+    vector<int> v1;
+
+    for(int j = 0; j < insert_values; j++)
+      v1.push_back(1);
+  }
+  tend();
+
+  return(int)((double)target_run_time / tval()) * calibrate_iterations;
+}
+
+double
+test_ints_pool_alloc(int iterations)
+{
+  tstart();
+  for(int i = 0; i < iterations; i++)
+  {
+    vector<int> v1;
+
+    for(int j = 0; j < insert_values; j++)
+      v1.push_back(1);
+  }
+  tend();
+
+  return tval();
+}
+
+double
+test_ints_malloc_alloc(int iterations)
+{
+  tstart();
+  for(int i = 0; i < iterations; i++)
+  {
+    vector<int, __malloc_alloc<0> > v1;
+
+    for(int j = 0; j < insert_values; j++)
+    {
+      v1.push_back(1);
+    }
+  }
+  tend();
+
+  return tval();
+}
+
+double
+test_ints_mt_alloc(int iterations)
+{
+  tstart();
+  for(int i = 0; i < iterations; i++)
+  {
+    vector<int, __mt_alloc<0> > v1;
+
+    for(int j = 0; j < insert_values; j++)
+    {
+      v1.push_back(1);
+    }
+  }
+  tend();
+
+  return tval();
+}
 
-// Primarily a test of the default allocator.
 // http://gcc.gnu.org/ml/libstdc++/2001-05/msg00105.html
-int main ()
+// http://gcc.gnu.org/ml/libstdc++/2003-05/msg00231.html
+int main(void)
 {
-  std::list<int> List;
-  for (int i = 0; i < 10000000; ++i )
-    List.push_back( int() );
+  using namespace __gnu_cxx_test;
+
+  time_counter time;
+  resource_counter resource;
+
+  int iterations = calibrate_test_ints();
+
+  start_counters(time, resource);
+  test_ints_pool_alloc(iterations);
+  stop_counters(time, resource);
+  report_performance(__FILE__, "default", time, resource);
+  clear_counters(time, resource);
+
+  start_counters(time, resource);
+  test_ints_malloc_alloc(iterations);
+  stop_counters(time, resource);
+  report_performance(__FILE__, "malloc", time, resource);
+  clear_counters(time, resource);
+
+  start_counters(time, resource);
+  test_ints_mt_alloc(iterations);
+  stop_counters(time, resource);
+  report_performance(__FILE__, "mt", time, resource);
+
   return 0;
 }
-