OSDN Git Service

78fe1fe7fcaa4a26924ed9df149d94864d732fd3
[pf3gnuchains/gcc-fork.git] / libstdc++-v3 / testsuite / util / testsuite_common_types.h
1 // -*- C++ -*-
2 // typelist for the C++ library testsuite. 
3 //
4 // Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library.  This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 2, or (at your option)
10 // any later version.
11 //
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 // GNU General Public License for more details.
16 //
17 // You should have received a copy of the GNU General Public License along
18 // with this library; see the file COPYING.  If not, write to the Free
19 // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 // USA.
21 //
22 // As a special exception, you may use this file as part of a free software
23 // library without restriction.  Specifically, if other files instantiate
24 // templates or use macros or inline functions from this file, or you compile
25 // this file and link it with other files to produce an executable, this
26 // file does not by itself cause the resulting executable to be covered by
27 // the GNU General Public License.  This exception does not however
28 // invalidate any other reasons why the executable file might be covered by
29 // the GNU General Public License.
30
31 #ifndef _TESTSUITE_COMMON_TYPES_H
32 #define _TESTSUITE_COMMON_TYPES_H 1
33
34 #include <testsuite_visualization.h>
35 #include <ext/typelist.h>
36
37 #include <ext/new_allocator.h>
38 #include <ext/malloc_allocator.h>
39 #include <ext/mt_allocator.h>
40 #include <ext/bitmap_allocator.h>
41 #include <ext/pool_allocator.h>
42
43 #include <algorithm>
44
45 #include <vector>
46 #include <list>
47 #include <deque>
48 #include <string>
49
50 #include <map>
51 #include <set>
52 #include <tr1/functional>
53 #include <tr1/unordered_map>
54 #include <tr1/unordered_set>
55
56 namespace __gnu_test
57 {
58   using __gnu_cxx::typelist::node;
59   using __gnu_cxx::typelist::transform;
60   using __gnu_cxx::typelist::append;
61
62   // All the allocators to test.
63   template<typename Tp, bool Thread>
64     struct allocator_policies
65     {
66       typedef Tp                                value_type;
67       typedef __gnu_cxx::new_allocator<Tp>              a1;
68       typedef __gnu_cxx::malloc_allocator<Tp>           a2;
69       typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy;
70       typedef __gnu_cxx::__mt_alloc<Tp, pool_policy>    a3;
71       typedef __gnu_cxx::bitmap_allocator<Tp>           a4;
72       typedef __gnu_cxx::__pool_alloc<Tp>               a5;
73       typedef node<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type;
74     };
75
76   // Typelists for vector, string, list, deque.
77   // XXX should just use template templates
78   template<typename Tp, bool Thread>
79     struct vectors
80     {
81       typedef Tp                                        value_type;
82
83       template<typename Tl>
84         struct vector_shell
85         {
86           typedef Tl                                    allocator_type;
87           typedef std::vector<value_type, allocator_type>       type;
88         };
89
90       typedef allocator_policies<value_type, Thread>    allocator_types;
91       typedef typename allocator_types::type            allocator_typelist;
92       typedef typename transform<allocator_typelist, vector_shell>::type type;
93     };
94
95   template<typename Tp, bool Thread>
96     struct lists
97     {
98       typedef Tp                                        value_type;
99
100       template<typename Tl>
101         struct list_shell
102         {
103           typedef Tl                                    allocator_type;
104           typedef std::list<value_type, allocator_type> type;
105         };
106
107       typedef allocator_policies<value_type, Thread>    allocator_types;
108       typedef typename allocator_types::type            allocator_typelist;
109       typedef typename transform<allocator_typelist, list_shell>::type type;
110     };
111
112   template<typename Tp, bool Thread>
113     struct deques
114     {
115       typedef Tp                                        value_type;
116
117       template<typename Tl>
118         struct deque_shell
119         {
120           typedef Tl                                    allocator_type;
121           typedef std::deque<value_type, allocator_type>        type;
122         };
123
124       typedef allocator_policies<value_type, Thread>    allocator_types;
125       typedef typename allocator_types::type            allocator_typelist;
126       typedef typename transform<allocator_typelist, deque_shell>::type type;
127     };
128
129   template<typename Tp, bool Thread>
130     struct strings
131     {
132       typedef Tp                                        value_type;
133
134       template<typename Tl>
135         struct string_shell
136         {
137           typedef Tl                                    allocator_type;
138           typedef std::char_traits<value_type>          traits_type;
139           typedef std::basic_string<value_type, traits_type, allocator_type>    type;
140         };
141
142       typedef allocator_policies<value_type, Thread>    allocator_types;
143       typedef typename allocator_types::type            allocator_typelist;
144       typedef typename transform<allocator_typelist, string_shell>::type type;
145     };
146
147   // A typelist of vector, list, deque, and string all instantiated
148   // with each of the allocator policies.
149   template<typename Tp, bool Thread>
150     struct sequence_containers
151     {
152       typedef Tp                                        value_type;
153
154       typedef typename vectors<value_type, Thread>::type vector_typelist;
155       typedef typename lists<value_type, Thread>::type   list_typelist;
156       typedef typename deques<value_type, Thread>::type  deque_typelist;
157       typedef typename strings<value_type, Thread>::type string_typelist;
158
159       typedef typename append<vector_typelist, list_typelist>::type a1;
160       typedef typename append<deque_typelist, string_typelist>::type a2;
161       typedef typename append<a1, a2>::type type;
162     };
163
164   // Typelists for map, set, unordered_set, unordered_map.
165   template<typename Tp, bool Thread>
166     struct maps
167     {
168       typedef Tp                                        value_type;
169       typedef Tp                                        key_type;
170       typedef std::pair<const key_type, value_type>     pair_type;
171       typedef std::less<key_type>                       compare_function;
172
173       template<typename Tl>
174         struct container
175         {
176           typedef Tl                                    allocator_type;
177           typedef std::map<key_type, value_type, compare_function, allocator_type>      type;
178         };
179
180       typedef allocator_policies<pair_type, Thread>     allocator_types;
181       typedef typename allocator_types::type            allocator_typelist;
182       typedef typename transform<allocator_typelist, container>::type type;
183     };
184
185   template<typename Tp, bool Thread>
186     struct unordered_maps
187     {
188       typedef Tp                                        value_type;
189       typedef Tp                                        key_type;
190       typedef std::pair<const key_type, value_type>     pair_type;
191       typedef std::tr1::hash<key_type>                  hash_function;
192       typedef std::equal_to<key_type>                   equality_function;
193
194       template<typename Tl>
195         struct container
196         {
197           typedef Tl                                    allocator_type;
198           typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type>       type;
199         };
200
201       typedef allocator_policies<pair_type, Thread>     allocator_types;
202       typedef typename allocator_types::type            allocator_typelist;
203       typedef typename transform<allocator_typelist, container>::type type;
204     };
205
206   template<typename Tp, bool Thread>
207     struct sets
208     {
209       typedef Tp                                        value_type;
210       typedef Tp                                        key_type;
211       typedef std::less<key_type>                       compare_function;
212
213       template<typename Tl>
214         struct container
215         {
216           typedef Tl                                    allocator_type;
217           typedef std::set<key_type, compare_function, allocator_type>  type;
218         };
219
220       typedef allocator_policies<key_type, Thread>      allocator_types;
221       typedef typename allocator_types::type            allocator_typelist;
222       typedef typename transform<allocator_typelist, container>::type type;
223     };
224
225   template<typename Tp, bool Thread>
226     struct unordered_sets
227     {
228       typedef Tp                                        value_type;
229       typedef Tp                                        key_type;
230       typedef std::tr1::hash<key_type>                  hash_function;
231       typedef std::equal_to<key_type>                   equality_function;
232
233       template<typename Tl>
234         struct container
235         {
236           typedef Tl                                    allocator_type;
237           typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type>   type;
238         };
239
240       typedef allocator_policies<key_type, Thread>      allocator_types;
241       typedef typename allocator_types::type            allocator_typelist;
242       typedef typename transform<allocator_typelist, container>::type type;
243     };
244
245
246   // A typelist  of all associated  container types, with each  of the
247   // allocator policies.
248   template<typename Tp, bool Thread>
249     struct associative_containers
250     {
251       typedef Tp                                        value_type;
252
253       typedef typename maps<value_type, Thread>::type map_typelist;
254       typedef typename sets<value_type, Thread>::type set_typelist;
255       typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist;
256       typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist;
257
258       typedef typename append<map_typelist, unordered_map_typelist>::type a1;
259       typedef typename append<set_typelist, unordered_set_typelist>::type a2;
260       typedef typename append<a1, a2>::type type;
261     };
262
263 } // namespace __gnu_test
264
265
266 // Function template, function objects for the tests.
267 template<typename TestType>
268   struct value_type : public std::pair<const TestType, TestType>
269   {
270     inline value_type& operator++() 
271     { 
272       ++this->second;
273       return *this; 
274     }
275     
276     inline operator TestType() const { return this->second; }
277   };
278
279 template<typename Container, int Iter>
280   void
281   do_loop();
282
283 template<typename Container, int Iter>
284   void*
285   do_thread(void* p = NULL)
286   {
287     do_loop<Container, Iter>();
288     return p;
289   }
290
291 template<typename Container, int Iter, bool Thread>
292   void
293   test_container(const char* filename)
294   {
295     using namespace __gnu_test;
296     time_counter time;
297     resource_counter resource;
298     {
299       start_counters(time, resource);
300       if (!Thread)
301         {
302           // No threads, so run 4x.
303           do_loop<Container, Iter * 4>();
304         }
305       else
306         {
307 #if defined (_GLIBCXX_GCC_GTHR_POSIX_H) && !defined (NOTHREAD)
308           pthread_t  t1, t2, t3, t4;
309           pthread_create(&t1, 0, &do_thread<Container, Iter>, 0);
310           pthread_create(&t2, 0, &do_thread<Container, Iter>, 0);
311           pthread_create(&t3, 0, &do_thread<Container, Iter>, 0);
312           pthread_create(&t4, 0, &do_thread<Container, Iter>, 0);
313           
314           pthread_join(t1, NULL);
315           pthread_join(t2, NULL);
316           pthread_join(t3, NULL);
317           pthread_join(t4, NULL);
318 #endif
319         }
320       stop_counters(time, resource);
321
322       // Detailed text data.
323       Container obj;
324       int status;
325       std::ostringstream comment;
326       comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),
327                                                  0, 0, &status);
328       report_header(filename, comment.str());
329       report_performance("", "", time, resource);
330
331       // Detailed data for visualization.
332       std::string vizfilename(filename);
333       vizfilename += ".dat";
334       write_viz_data(time, vizfilename.c_str());
335     }
336   }
337
338 template<bool Thread>
339   struct test_sequence
340   {
341     test_sequence(const char* filename) : _M_filename(filename) { }
342
343     template<class Container>
344       void
345       operator()(Container)
346       {
347         const int i = 20000;
348         test_container<Container, i, Thread>(_M_filename); 
349       }
350
351   private:
352     const char* _M_filename;
353   };
354
355
356 inline std::string::size_type
357 sequence_find_container(std::string& type)
358 {
359   const std::string::size_type npos = std::string::npos;
360   std::string::size_type n1 = type.find("vector");
361   std::string::size_type n2 = type.find("list");
362   std::string::size_type n3 = type.find("deque");
363   std::string::size_type n4 = type.find("string");
364   
365   if (n1 != npos || n2 != npos || n3 != npos || n4 != npos)
366     return std::min(std::min(n1, n2), std::min(n3, n4));
367   else
368     throw std::runtime_error("sequence_find_container not found");
369 }
370
371 inline std::string::size_type
372 associative_find_container(std::string& type)
373 {
374   using std::string;
375   string::size_type n1 = type.find("map");
376   string::size_type n2 = type.find("set");
377   if (n1 != string::npos || n2 != string::npos)
378     return std::min(n1, n2);
379   else
380     throw std::runtime_error("associative_find_container not found");
381 }
382 #endif