| // -*- C++ -*- |
| // Testing performance utilities for the C++ library testsuite. |
| // |
| // Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009 |
| // 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 3, 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 COPYING3. If not see |
| // <http://www.gnu.org/licenses/>. |
| // |
| |
| #ifndef _GLIBCXX_PERFORMANCE_H |
| #define _GLIBCXX_PERFORMANCE_H |
| |
| #include <sys/times.h> |
| #include <sys/resource.h> |
| #include <cstdlib> |
| #include <cstring> |
| #include <string> |
| #include <fstream> |
| #include <iomanip> |
| #include <typeinfo> |
| #include <stdexcept> |
| #include <sstream> |
| #include <cxxabi.h> |
| #include <testsuite_common_types.h> |
| |
| #ifdef __linux__ |
| #include <malloc.h> |
| #elif defined (__FreeBSD__) |
| extern "C" |
| { |
| struct mallinfo |
| { |
| int uordblks; |
| int hblkhd; |
| }; |
| |
| struct mallinfo |
| mallinfo(void) |
| { |
| struct mallinfo m = { (((size_t) sbrk (0) + 1023) / 1024), 0 }; |
| return m; |
| } |
| } |
| #elif !defined (__hpux__) |
| extern "C" |
| { |
| struct mallinfo |
| { |
| int uordblks; |
| int hblkhd; |
| }; |
| |
| struct mallinfo empty = { 0, 0 }; |
| |
| struct mallinfo |
| mallinfo(void) |
| { return empty; } |
| } |
| #endif |
| |
| namespace __gnu_test |
| { |
| class time_counter |
| { |
| private: |
| clock_t elapsed_begin; |
| clock_t elapsed_end; |
| tms tms_begin; |
| tms tms_end; |
| |
| public: |
| explicit |
| time_counter() : elapsed_begin(), elapsed_end(), tms_begin(), tms_end() |
| { } |
| |
| void |
| clear() throw() |
| { |
| elapsed_begin = clock_t(); |
| elapsed_end = clock_t(); |
| tms_begin = tms(); |
| tms_end = tms(); |
| } |
| |
| void |
| start() |
| { |
| this->clear(); |
| elapsed_begin = times(&tms_begin); |
| const clock_t err = clock_t(-1); |
| if (elapsed_begin == err) |
| std::__throw_runtime_error("time_counter::start"); |
| } |
| |
| void |
| stop() |
| { |
| elapsed_end = times(&tms_end); |
| const clock_t err = clock_t(-1); |
| if (elapsed_end == err) |
| std::__throw_runtime_error("time_counter::stop"); |
| } |
| |
| size_t |
| real_time() const |
| { return elapsed_end - elapsed_begin; } |
| |
| size_t |
| user_time() const |
| { return tms_end.tms_utime - tms_begin.tms_utime; } |
| |
| size_t |
| system_time() const |
| { return tms_end.tms_stime - tms_begin.tms_stime; } |
| }; |
| |
| class resource_counter |
| { |
| int who; |
| rusage rusage_begin; |
| rusage rusage_end; |
| struct mallinfo allocation_begin; |
| struct mallinfo allocation_end; |
| |
| public: |
| resource_counter(int i = RUSAGE_SELF) : who(i) |
| { this->clear(); } |
| |
| void |
| clear() throw() |
| { |
| memset(&rusage_begin, 0, sizeof(rusage_begin)); |
| memset(&rusage_end, 0, sizeof(rusage_end)); |
| memset(&allocation_begin, 0, sizeof(allocation_begin)); |
| memset(&allocation_end, 0, sizeof(allocation_end)); |
| } |
| |
| void |
| start() |
| { |
| if (getrusage(who, &rusage_begin) != 0 ) |
| memset(&rusage_begin, 0, sizeof(rusage_begin)); |
| malloc(0); // Needed for some implementations. |
| allocation_begin = mallinfo(); |
| } |
| |
| void |
| stop() |
| { |
| if (getrusage(who, &rusage_end) != 0 ) |
| memset(&rusage_end, 0, sizeof(rusage_end)); |
| allocation_end = mallinfo(); |
| } |
| |
| int |
| allocated_memory() const |
| { return ((allocation_end.uordblks - allocation_begin.uordblks) |
| + (allocation_end.hblkhd - allocation_begin.hblkhd)); } |
| |
| long |
| hard_page_fault() const |
| { return rusage_end.ru_majflt - rusage_begin.ru_majflt; } |
| |
| long |
| swapped() const |
| { return rusage_end.ru_nswap - rusage_begin.ru_nswap; } |
| }; |
| |
| inline void |
| start_counters(time_counter& t, resource_counter& r) |
| { |
| t.start(); |
| r.start(); |
| } |
| |
| inline void |
| stop_counters(time_counter& t, resource_counter& r) |
| { |
| t.stop(); |
| r.stop(); |
| } |
| |
| inline void |
| clear_counters(time_counter& t, resource_counter& r) |
| { |
| t.clear(); |
| r.clear(); |
| } |
| |
| void |
| report_performance(const std::string file, const std::string comment, |
| const time_counter& t, const resource_counter& r) |
| { |
| const char space = ' '; |
| const char tab = '\t'; |
| const char* name = "libstdc++-performance.sum"; |
| std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1; |
| std::string testname(i, file.end()); |
| |
| std::ofstream out(name, std::ios_base::app); |
| |
| #ifdef __GTHREADS |
| if (__gthread_active_p()) |
| testname.append("-thread"); |
| #endif |
| |
| out.setf(std::ios_base::left); |
| out << std::setw(25) << testname << tab; |
| out << std::setw(25) << comment << tab; |
| |
| out.setf(std::ios_base::right); |
| out << std::setw(4) << t.real_time() << "r" << space; |
| out << std::setw(4) << t.user_time() << "u" << space; |
| out << std::setw(4) << t.system_time() << "s" << space; |
| out << std::setw(8) << r.allocated_memory() << "mem" << space; |
| out << std::setw(4) << r.hard_page_fault() << "pf" << space; |
| |
| out << std::endl; |
| out.close(); |
| } |
| |
| void |
| report_header(const std::string file, const std::string header) |
| { |
| const char space = ' '; |
| const char tab = '\t'; |
| const char* name = "libstdc++-performance.sum"; |
| std::string::const_iterator i = file.begin() + file.find_last_of('/') + 1; |
| std::string testname(i, file.end()); |
| |
| std::ofstream out(name, std::ios_base::app); |
| |
| #ifdef __GTHREADS |
| if (__gthread_active_p ()) |
| testname.append("-thread"); |
| #endif |
| |
| out.setf(std::ios_base::left); |
| out << std::setw(25) << testname << tab; |
| out << std::setw(40) << header << tab; |
| |
| out << std::endl; |
| out.close(); |
| } |
| } // namespace __gnu_test |
| |
| |
| // Ah, we wish it wasn't so... |
| bool first_container = false; |
| extern const char* filename; |
| |
| typedef std::string::size_type (*callback_type) (std::string&); |
| |
| template<typename Container, int Iter, bool Thread> |
| void |
| write_viz_container(callback_type find_container, const char* filename) |
| { |
| typedef std::string string; |
| |
| // Create title. |
| { |
| const char ws(' '); |
| std::ostringstream title; |
| |
| std::string titlename(filename); |
| std::string::size_type n = titlename.find('.'); |
| if (n != string::npos) |
| titlename = std::string(titlename.begin(), titlename.begin() + n); |
| |
| title << titlename; |
| title << ws; |
| title << Iter; |
| title << ws; |
| #if 0 |
| title << "thread<"; |
| std::boolalpha(title); |
| title << Thread; |
| title << '>'; |
| #endif |
| |
| titlename += ".title"; |
| std::ofstream titlefile(titlename.c_str()); |
| if (!titlefile.good()) |
| throw std::runtime_error("write_viz_data cannot open titlename"); |
| titlefile << title.str() << std::endl; |
| } |
| |
| // Create compressed type name. |
| Container obj; |
| int status; |
| std::string type(abi::__cxa_demangle(typeid(obj).name(), 0, 0, &status)); |
| |
| // Extract fully-qualified typename. |
| // Assumes "set" or "map" are uniquely determinate. |
| string::iterator beg = type.begin(); |
| string::iterator end; |
| string::size_type n = (*find_container)(type); |
| |
| // Find start of fully-qualified name. |
| // Assume map, find end. |
| string::size_type nend = type.find('<', n); |
| if (nend != string::npos) |
| end = type.begin() + nend; |
| |
| string compressed_type; |
| compressed_type += '"'; |
| compressed_type += string(beg, end); |
| compressed_type += '<'; |
| #if 0 |
| typename Container::key_type v; |
| compressed_type += typeid(v).name(); |
| #else |
| compressed_type += "int"; |
| #endif |
| compressed_type += ", A>"; |
| |
| // XXX |
| if (Thread == true) |
| compressed_type += " thread"; |
| compressed_type += '"'; |
| |
| std::ofstream file(filename, std::ios_base::app); |
| if (!file.good()) |
| throw std::runtime_error("write_viz_data cannot open filename"); |
| |
| file << compressed_type; |
| first_container = false; |
| } |
| |
| |
| void |
| write_viz_data(__gnu_test::time_counter& time, const char* filename) |
| { |
| std::ofstream file(filename, std::ios_base::app); |
| if (!file.good()) |
| throw std::runtime_error("write_viz_data cannot open filename"); |
| |
| // Print out score in appropriate column. |
| const char tab('\t'); |
| int score = time.real_time(); |
| file << tab << score; |
| } |
| |
| void |
| write_viz_endl(const char* filename) |
| { |
| std::ofstream file(filename, std::ios_base::app); |
| if (!file.good()) |
| throw std::runtime_error("write_viz_endl cannot open filename"); |
| file << std::endl; |
| } |
| |
| |
| // 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()(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 // _GLIBCXX_PERFORMANCE_H |
| |