-// Copyright (C) 2003 Free Software Foundation, Inc.
+// Copyright (C) 2003, 2004 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// the GNU General Public License.
/*
- *
- *
* 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.
+ * between different std::allocator implementations. The results are
+ * influenced by the underlying allocator in the "C" library, malloc.
*/
// 2003-02-05 Stefan Olsson <stefan@snon.net>
#include <vector>
-#include <sys/time.h>
+#include <list>
+#include <typeinfo>
+#include <sstream>
#include <ext/mt_allocator.h>
#include <ext/malloc_allocator.h>
#include <testsuite_performance.h>
using __gnu_cxx::malloc_allocator;
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;
+typedef int test_type;
-/*
- * 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 iterations to be performed.
+int iterations;
-/*
- * 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;
+// The number of values to insert in the container, 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 = 128;
-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++)
+template<typename Container>
+ int
+ do_loop()
{
- vector<int> v1;
-
- for(int j = 0; j < insert_values; j++)
- v1.push_back(1);
+ int test_iterations = 0;
+ try
+ {
+ Container obj;
+ while (test_iterations < iterations)
+ {
+ for (int j = 0; j < insert_values; ++j)
+ obj.push_back(test_iterations);
+ ++test_iterations;
+ }
+ }
+ catch(...)
+ {
+ // No point allocating all available memory, repeatedly.
+ }
+ return test_iterations;
}
- 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++)
+template<typename Container>
+ void
+ calibrate_iterations()
{
- vector<int, malloc_allocator<int> > v1;
-
- for(int j = 0; j < insert_values; j++)
- {
- v1.push_back(1);
- }
+ int try_iterations = iterations = 100000;
+ int test_iterations;
+
+ __gnu_test::time_counter timer;
+ timer.start();
+ test_iterations = do_loop<Container>();
+ timer.stop();
+
+ if (try_iterations > test_iterations && test_iterations > iterations)
+ iterations = test_iterations - 100;
+ else
+ {
+ double tics = timer.real_time();
+ double iterpc = test_iterations / tics; //iterations per clock
+ double xtics = 200; // works for linux 2gig x86
+ iterations = static_cast<int>(xtics * iterpc);
+ }
}
- tend();
-
- return tval();
-}
-double
-test_ints_mt_alloc(int iterations)
-{
- tstart();
- for(int i = 0; i < iterations; i++)
+template<typename Container>
+ void
+ test_container(Container obj)
{
- vector<int, __mt_alloc<int> > v1;
-
- for(int j = 0; j < insert_values; j++)
- {
- v1.push_back(1);
- }
+ using namespace __gnu_test;
+
+ time_counter time;
+ resource_counter resource;
+ clear_counters(time, resource);
+ start_counters(time, resource);
+ int test_iterations = do_loop<Container>();
+ stop_counters(time, resource);
+
+ std::ostringstream comment;
+ comment << "iterations: " << test_iterations << '\t';
+ comment << "type: " << typeid(obj).name();
+ report_header(__FILE__, comment.str());
+ report_performance(__FILE__, string(), time, resource);
}
- tend();
-
- return tval();
-}
// http://gcc.gnu.org/ml/libstdc++/2001-05/msg00105.html
// http://gcc.gnu.org/ml/libstdc++/2003-05/msg00231.html
int main(void)
{
- using namespace __gnu_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);
+ calibrate_iterations<vector<test_type> >();
+ test_container(vector<test_type>());
+ test_container(vector<test_type, malloc_allocator<test_type> >());
+ //test_container(vector<test_type, __mt_alloc<test_type> >());
+
+ calibrate_iterations<list<test_type> >();
+ test_container(list<test_type>());
+ test_container(list<test_type, malloc_allocator<test_type> >());
+ //test_container(list<test_type, __mt_alloc<test_type> >());
return 0;
}
--- /dev/null
+// Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+// USA.
+
+// As a special exception, you may use this file as part of a free software
+// library without restriction. Specifically, if other files instantiate
+// templates or use macros or inline functions from this file, or you compile
+// this file and link it with other files to produce an executable, this
+// file does not by itself cause the resulting executable to be covered by
+// the GNU General Public License. This exception does not however
+// invalidate any other reasons why the executable file might be covered by
+// the GNU General Public License.
+
+/*
+ * The goal with this application is to compare the performance
+ * between different std::allocator implementations. The results are
+ * influenced by the underlying allocator in the "C" library, malloc.
+ */
+
+// 2003-02-05 Stefan Olsson <stefan@snon.net>
+
+#include <vector>
+#include <list>
+#include <typeinfo>
+#include <sstream>
+#include <pthread.h>
+#include <ext/mt_allocator.h>
+#include <ext/malloc_allocator.h>
+#include <testsuite_performance.h>
+
+using namespace std;
+using __gnu_cxx::malloc_allocator;
+using __gnu_cxx::__mt_alloc;
+
+typedef int test_type;
+
+// The number of iterations to be performed.
+int iterations;
+
+// The number of values to insert in the container, 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 = 128;
+
+template<typename Container>
+ void*
+ do_loop(void* p = NULL)
+ {
+ Container obj;
+ try
+ {
+ int test_iterations = 0;
+ while (test_iterations < iterations)
+ {
+ for (int j = 0; j < insert_values; ++j)
+ obj.push_back(test_iterations);
+ ++test_iterations;
+ }
+ obj.clear();
+ test_iterations = 0;
+ while (test_iterations < iterations)
+ {
+ for (int j = 0; j < insert_values; ++j)
+ obj.push_back(test_iterations);
+ ++test_iterations;
+ }
+ }
+ catch(...)
+ {
+ // No point allocating all available memory, repeatedly.
+ }
+ }
+
+template<typename Container>
+ void
+ calibrate_iterations()
+ {
+ int try_iterations = iterations = 100000;
+
+ __gnu_test::time_counter timer;
+ timer.start();
+ do_loop<Container>();
+ timer.stop();
+
+ double tics = timer.real_time();
+ double iterpc = iterations / tics; //iterations per clock
+ double xtics = 100; // works for linux 2gig x86
+ iterations = static_cast<int>(xtics * iterpc);
+ }
+
+template<typename Container>
+ void
+ test_container(Container obj)
+ {
+ using namespace __gnu_test;
+ time_counter time;
+ resource_counter resource;
+
+ clear_counters(time, resource);
+ start_counters(time, resource);
+
+ pthread_t t1, t2, t3, t4;
+ pthread_create(&t1, 0, &do_loop<Container>, 0);
+ pthread_create(&t2, 0, &do_loop<Container>, 0);
+ pthread_create(&t3, 0, &do_loop<Container>, 0);
+ pthread_create(&t4, 0, &do_loop<Container>, 0);
+
+ pthread_join(t1, NULL);
+ pthread_join(t2, NULL);
+ pthread_join(t3, NULL);
+ pthread_join(t4, NULL);
+
+ stop_counters(time, resource);
+
+ std::ostringstream comment;
+ comment << "iterations: " << iterations << '\t';
+ comment << "type: " << typeid(obj).name();
+ report_header(__FILE__, comment.str());
+ report_performance(__FILE__, string(), time, resource);
+ }
+
+// http://gcc.gnu.org/ml/libstdc++/2001-05/msg00105.html
+// http://gcc.gnu.org/ml/libstdc++/2003-05/msg00231.html
+int main(void)
+{
+ calibrate_iterations<vector<test_type> >();
+ test_container(vector<test_type>());
+ test_container(vector<test_type, malloc_allocator<test_type> >());
+ //test_container(vector<test_type, __mt_alloc<test_type> >());
+
+ calibrate_iterations<list<test_type> >();
+ test_container(list<test_type>());
+ test_container(list<test_type, malloc_allocator<test_type> >());
+ //test_container(list<test_type, __mt_alloc<test_type> >());
+
+ return 0;
+}
OSDN Git Service
