1 // Copyright (C) 2003, 2004 Free Software Foundation, Inc.
3 // This file is part of the GNU ISO C++ Library. This library is free
4 // software; you can redistribute it and/or modify it under the
5 // terms of the GNU General Public License as published by the
6 // Free Software Foundation; either version 2, or (at your option)
9 // This library is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 // GNU General Public License for more details.
14 // You should have received a copy of the GNU General Public License along
15 // with this library; see the file COPYING. If not, write to the Free
16 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19 // As a special exception, you may use this file as part of a free software
20 // library without restriction. Specifically, if other files instantiate
21 // templates or use macros or inline functions from this file, or you compile
22 // this file and link it with other files to produce an executable, this
23 // file does not by itself cause the resulting executable to be covered by
24 // the GNU General Public License. This exception does not however
25 // invalidate any other reasons why the executable file might be covered by
26 // the GNU General Public License.
29 * The goal with this application is to compare the performance
30 * between different std::allocator implementations. The results are
31 * influenced by the underlying allocator in the "C" library, malloc.
34 // 2003-02-05 Stefan Olsson <stefan@snon.net>
43 #include <ext/mt_allocator.h>
44 #include <ext/new_allocator.h>
45 #include <ext/malloc_allocator.h>
47 #include <testsuite_performance.h>
51 typedef int test_type;
53 // The number of iterations to be performed.
54 int iterations = 100000;
56 // The number of values to insert in the container, 32 will cause 5
57 // (re)allocations to be performed (sizes 4, 8, 16, 32 and 64)
58 // This means that all allocations are within _MAX_BYTES = 128 as
59 // defined in stl_alloc.h for __pool_alloc. Whether or not this
60 // value is relevant in "the real world" or not I don't know and
61 // should probably be investigated in more detail.
62 int insert_values = 128;
64 template<typename TestType>
65 struct value_type : public pair<TestType, TestType>
67 value_type() : pair<TestType, TestType>(0, 0) { }
69 inline value_type operator++() { return ++this->first, *this; }
70 inline operator TestType() const { return this->first; }
73 template<typename Container>
75 do_loop(Container& obj)
77 int test_iterations = 0;
80 value_type<test_type> test_value;
81 while (test_iterations < iterations)
83 for (int j = 0; j < insert_values; ++j)
84 obj.insert(obj.end(), ++test_value);
90 // No point allocating all available memory, repeatedly.
92 return test_iterations;
95 template<typename Container>
97 test_container(Container obj)
99 using namespace __gnu_test;
103 resource_counter resource;
104 clear_counters(time, resource);
105 start_counters(time, resource);
106 int test_iterations = do_loop(obj);
107 stop_counters(time, resource);
109 std::ostringstream comment;
110 comment << "iterations: " << test_iterations << '\t';
111 comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),
113 report_header(__FILE__, comment.str());
114 report_performance(__FILE__, string(), time, resource);
117 // http://gcc.gnu.org/ml/libstdc++/2001-05/msg00105.html
118 // http://gcc.gnu.org/ml/libstdc++/2003-05/msg00231.html
121 typedef __gnu_cxx::malloc_allocator<test_type> m_alloc_type;
122 typedef __gnu_cxx::new_allocator<test_type> n_alloc_type;
123 typedef __gnu_cxx::__mt_alloc<test_type> so_alloc_type;
126 test_container(vector<test_type, m_alloc_type>());
129 test_container(vector<test_type, n_alloc_type>());
132 test_container(vector<test_type, so_alloc_type>());
136 test_container(list<test_type, m_alloc_type>());
139 test_container(list<test_type, n_alloc_type>());
142 test_container(list<test_type, so_alloc_type>());
146 test_container(deque<test_type, m_alloc_type>());
149 test_container(deque<test_type, n_alloc_type>());
152 test_container(deque<test_type, so_alloc_type>());
155 typedef less<test_type> compare_type;
157 test_container(map<test_type, test_type, compare_type, m_alloc_type>());
160 test_container(map<test_type, test_type, compare_type, n_alloc_type>());
163 test_container(map<test_type, test_type, compare_type, so_alloc_type>());
167 test_container(set<test_type, compare_type, m_alloc_type>());
170 test_container(set<test_type, compare_type, n_alloc_type>());
173 test_container(set<test_type, compare_type, so_alloc_type>());