libstdc++-v3/testsuite/performance/20_util/allocator/map_mt_find.cc

   1 // Copyright (C) 2004 Free Software Foundation, Inc.
   2 //
   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)
   7 // any later version.
   8
   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.
  13
  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,
  17 // USA.
  18
  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.
  27
  28 // 2004-03-11  Dhruv Matani  <dhruvbird@HotPOP.com>
  29
  30 #include <new>
  31 #include <map>
  32 #include <cstdlib>
  33 #include <string>
  34 #include <pthread.h>
  35 #include <typeinfo>
  36 #include <sstream>
  37 #include <ext/mt_allocator.h>
  38 #include <ext/new_allocator.h>
  39 #include <ext/malloc_allocator.h>
  40 #include <ext/bitmap_allocator.h>
  41 #include <ext/pool_allocator.h>
  42 #include <cxxabi.h>
  43 #include <testsuite_performance.h>
  44
  45 using namespace std;
  46 using __gnu_cxx::malloc_allocator;
  47 using __gnu_cxx::new_allocator;
  48 using __gnu_cxx::__mt_alloc;
  49 using __gnu_cxx::bitmap_allocator;
  50 using __gnu_cxx::__pool_alloc;
  51
  52 bool less_int(int x1, int x2) { return x1 < x2; }
  53
  54 #if defined USE_FUNCTION_COMPARE
  55 #define COMPARE_T typeof(&less_int)
  56 #define COMPARE_F &less_int
  57 #else
  58 #define COMPARE_T std::less<int>
  59 #define COMPARE_F std::less<int>()
  60 #endif
  61
  62 template <typename Alloc>
  63   void*
  64   find_proc(void *_vptr)
  65   {
  66     map<int, string, COMPARE_T, Alloc> *_mptr =
  67       reinterpret_cast<map<int, string, COMPARE_T, Alloc>*>(_vptr);
  68
  69     for (int i = 0; i < 700000; ++i)
  70       {
  71         int Finder = rand() % 2000000;
  72         _mptr->find(Finder);
  73       }
  74     return _vptr;
  75   }
  76
  77
  78 template <typename Alloc>
  79   int
  80   do_test()
  81   {
  82     COMPARE_T _comp = COMPARE_F;
  83     map<int, string, COMPARE_T, Alloc> imap(_comp);
  84     int x = 2;
  85     pthread_t thr[3];
  86     const int Iter = 1000000;
  87
  88     while (x--)
  89       {
  90         for (int i = 0; i < 300000; ++i)
  91           imap.insert(make_pair(rand()%1000000, "_test_data"));
  92
  93         for (int i = 0; i < 100000; ++i)
  94           imap.insert(make_pair(rand()%2000000, "_test_data"));
  95
  96         pthread_create(&thr[0], NULL, find_proc<Alloc>, (void*)&imap);
  97         pthread_create(&thr[1], NULL, find_proc<Alloc>, (void*)&imap);
  98         pthread_create(&thr[2], NULL, find_proc<Alloc>, (void*)&imap);
  99
 100         pthread_join(thr[0], 0);
 101         pthread_join(thr[1], 0);
 102         pthread_join(thr[2], 0);
 103
 104         imap.clear();
 105       }
 106     return Iter;
 107   }
 108
 109 template <typename Alloc>
 110   void
 111   exec_tests()
 112   {
 113     using namespace __gnu_test;
 114     int status;
 115     COMPARE_T _comp = COMPARE_F;
 116     map<int, string, COMPARE_T, Alloc> obj(_comp);
 117
 118     time_counter time;
 119     resource_counter resource;
 120     clear_counters(time, resource);
 121     start_counters(time, resource);
 122     int test_iterations = do_test<Alloc>();
 123     stop_counters(time, resource);
 124
 125     std::ostringstream comment;
 126     comment << "iterations: " << test_iterations << '\t';
 127     comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),
 128                                                0, 0, &status);
 129     report_header(__FILE__, comment.str());
 130     report_performance(__FILE__, string(), time, resource);
 131   }
 132
 133 int main()
 134 {
 135   typedef pair<const int, string> pair_type;
 136
 137 #ifdef TEST_T0
 138   exec_tests<new_allocator<pair_type> >();
 139 #endif
 140 #ifdef TEST_T1
 141   exec_tests<malloc_allocator<pair_type> >();
 142 #endif
 143 #ifdef TEST_T2
 144   exec_tests<__mt_alloc<pair_type> >();
 145 #endif
 146 #ifdef TEST_T3
 147   exec_tests<bitmap_allocator<pair_type> >();
 148 #endif
 149 #ifdef TEST_T4
 150   exec_tests<__pool_alloc<pair_type> >();
 151 #endif
 152 }