URL
https://opencores.org/ocsvn/scarts/scarts/trunk
Subversion Repositories scarts
[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [libstdc++-v3/] [testsuite/] [testsuite_common_types.h] - Rev 19
Compare with Previous | Blame | View Log
// -*- C++ -*- // typelist for the C++ library testsuite. // // Copyright (C) 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, // 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. #ifndef _TESTSUITE_COMMON_TYPES_H #define _TESTSUITE_COMMON_TYPES_H 1 #include <testsuite_visualization.h> #include <ext/typelist.h> #include <ext/new_allocator.h> #include <ext/malloc_allocator.h> #include <ext/mt_allocator.h> #include <ext/bitmap_allocator.h> #include <ext/pool_allocator.h> #include <vector> #include <list> #include <deque> #include <string> #include <map> #include <set> #include <ext/hash_map> #include <ext/hash_set> #include <tr1/unordered_map> #include <tr1/unordered_set> namespace __gnu_test { using __gnu_cxx::typelist; using __gnu_cxx::transform; using __gnu_cxx::append; // All the allocators to test. template<typename Tp, bool Thread> struct allocator_policies { typedef Tp value_type; typedef __gnu_cxx::new_allocator<Tp> a1; typedef __gnu_cxx::malloc_allocator<Tp> a2; typedef __gnu_cxx::__common_pool_policy<__gnu_cxx::__pool, Thread> pool_policy; typedef __gnu_cxx::__mt_alloc<Tp, pool_policy> a3; typedef __gnu_cxx::bitmap_allocator<Tp> a4; typedef __gnu_cxx::__pool_alloc<Tp> a5; typedef typelist<_GLIBCXX_TYPELIST_CHAIN5(a1, a2, a3, a4, a5)> type; }; // Typelists for vector, string, list, deque. // XXX should just use template templates template<typename Tp, bool Thread> struct vectors { typedef Tp value_type; template<typename Tl> struct vector_shell { typedef Tl allocator_type; typedef std::vector<value_type, allocator_type> type; }; typedef allocator_policies<value_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, vector_shell>::type type; }; template<typename Tp, bool Thread> struct lists { typedef Tp value_type; template<typename Tl> struct list_shell { typedef Tl allocator_type; typedef std::list<value_type, allocator_type> type; }; typedef allocator_policies<value_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, list_shell>::type type; }; template<typename Tp, bool Thread> struct deques { typedef Tp value_type; template<typename Tl> struct deque_shell { typedef Tl allocator_type; typedef std::deque<value_type, allocator_type> type; }; typedef allocator_policies<value_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, deque_shell>::type type; }; template<typename Tp, bool Thread> struct strings { typedef Tp value_type; template<typename Tl> struct string_shell { typedef Tl allocator_type; typedef std::char_traits<value_type> traits_type; typedef std::basic_string<value_type, traits_type, allocator_type> type; }; typedef allocator_policies<value_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, string_shell>::type type; }; // A typelist of vector, list, deque, and string all instantiated // with each of the allocator policies. template<typename Tp, bool Thread> struct sequence_containers { typedef Tp value_type; typedef typename vectors<value_type, Thread>::type vector_typelist; typedef typename lists<value_type, Thread>::type list_typelist; typedef typename deques<value_type, Thread>::type deque_typelist; typedef typename strings<value_type, Thread>::type string_typelist; typedef typename append<vector_typelist, list_typelist>::type a1; typedef typename append<deque_typelist, string_typelist>::type a2; typedef typename append<a1, a2>::type type; }; // Typelists for map, set, hash_map, hash_set, unordered_set, unordered_map. template<typename Tp, bool Thread> struct maps { typedef Tp value_type; typedef Tp key_type; typedef std::pair<const key_type, value_type> pair_type; typedef std::less<key_type> compare_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef std::map<key_type, value_type, compare_function, allocator_type> type; }; typedef allocator_policies<pair_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; template<typename Tp, bool Thread> struct hash_maps { typedef Tp value_type; typedef Tp key_type; typedef __gnu_cxx::hash<key_type> hash_function; typedef std::equal_to<key_type> equality_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef __gnu_cxx::hash_map<key_type, value_type, hash_function, equality_function, allocator_type> type; }; typedef allocator_policies<value_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; template<typename Tp, bool Thread> struct unordered_maps { typedef Tp value_type; typedef Tp key_type; typedef std::pair<const key_type, value_type> pair_type; typedef std::tr1::hash<key_type> hash_function; typedef std::equal_to<key_type> equality_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef std::tr1::unordered_map<key_type, value_type, hash_function, equality_function, allocator_type> type; }; typedef allocator_policies<pair_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; template<typename Tp, bool Thread> struct sets { typedef Tp value_type; typedef Tp key_type; typedef std::less<key_type> compare_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef std::set<key_type, compare_function, allocator_type> type; }; typedef allocator_policies<key_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; template<typename Tp, bool Thread> struct hash_sets { typedef Tp value_type; typedef Tp key_type; typedef __gnu_cxx::hash<key_type> hash_function; typedef std::equal_to<key_type> equality_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef __gnu_cxx::hash_set<key_type, hash_function, equality_function, allocator_type> type; }; typedef allocator_policies<key_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; template<typename Tp, bool Thread> struct unordered_sets { typedef Tp value_type; typedef Tp key_type; typedef std::tr1::hash<key_type> hash_function; typedef std::equal_to<key_type> equality_function; template<typename Tl> struct container { typedef Tl allocator_type; typedef std::tr1::unordered_set<key_type, hash_function, equality_function, allocator_type> type; }; typedef allocator_policies<key_type, Thread> allocator_types; typedef typename allocator_types::type allocator_typelist; typedef typename transform<allocator_typelist, container>::type type; }; // A typelist of all associated container types, with each of the // allocator policies. template<typename Tp, bool Thread> struct associative_containers { typedef Tp value_type; typedef typename maps<value_type, Thread>::type map_typelist; typedef typename sets<value_type, Thread>::type set_typelist; typedef typename hash_maps<value_type, Thread>::type hash_map_typelist; typedef typename hash_sets<value_type, Thread>::type hash_set_typelist; typedef typename unordered_maps<value_type, Thread>::type unordered_map_typelist; typedef typename unordered_sets<value_type, Thread>::type unordered_set_typelist; typedef typename append<map_typelist, hash_map_typelist>::type a1; typedef typename append<a1, unordered_map_typelist>::type a2; typedef typename append<set_typelist, hash_set_typelist>::type a3; typedef typename append<a3, unordered_set_typelist>::type a4; typedef typename append<a2, a4>::type type; }; } // namespace __gnu_test // Function template, function objects for the tests. template<typename TestType> struct value_type : public std::pair<const TestType, TestType> { inline value_type& operator++() { ++this->second; return *this; } inline operator TestType() const { return this->second; } }; template<typename Container, int Iter> void do_loop(); template<typename Container, int Iter> void* do_thread(void* p = NULL) { do_loop<Container, Iter>(); return p; } template<typename Container, int Iter, bool Thread> void test_container(const char* filename) { using namespace __gnu_test; time_counter time; resource_counter resource; { start_counters(time, resource); if (!Thread) { // No threads, so run 4x. do_loop<Container, Iter * 4>(); } else { #if defined (_GLIBCXX_GCC_GTHR_POSIX_H) && !defined (NOTHREAD) pthread_t t1, t2, t3, t4; pthread_create(&t1, 0, &do_thread<Container, Iter>, 0); pthread_create(&t2, 0, &do_thread<Container, Iter>, 0); pthread_create(&t3, 0, &do_thread<Container, Iter>, 0); pthread_create(&t4, 0, &do_thread<Container, Iter>, 0); pthread_join(t1, NULL); pthread_join(t2, NULL); pthread_join(t3, NULL); pthread_join(t4, NULL); #endif } stop_counters(time, resource); // Detailed text data. Container obj; int status; std::ostringstream comment; comment << "type: " << abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status); report_header(filename, comment.str()); report_performance("", "", time, resource); // Detailed data for visualization. std::string vizfilename(filename); vizfilename += ".dat"; write_viz_data(time, vizfilename.c_str()); } } template<bool Thread> struct test_sequence { test_sequence(const char* filename) : _M_filename(filename) { } template<class Container> void operator()(__gnu_cxx::detail::type_to_type<Container>) { const int i = 20000; test_container<Container, i, Thread>(_M_filename); } private: const char* _M_filename; }; inline std::string::size_type sequence_find_container(std::string& type) { const std::string::size_type npos = std::string::npos; std::string::size_type n1 = type.find("vector"); std::string::size_type n2 = type.find("list"); std::string::size_type n3 = type.find("deque"); std::string::size_type n4 = type.find("string"); if (n1 != npos || n2 != npos || n3 != npos || n4 != npos) return std::min(std::min(n1, n2), std::min(n3, n4)); else throw std::runtime_error("sequence_find_container not found"); } inline std::string::size_type associative_find_container(std::string& type) { using std::string; string::size_type n1 = type.find("map"); string::size_type n2 = type.find("set"); if (n1 != string::npos || n2 != string::npos) return std::min(n1, n2); else throw std::runtime_error("associative_find_container not found"); } #endif