PATCH: new threaded test case from libstdc++/13823

[Loren James Rittle <rittle at latour dot rsch dot comm dot mot dot com>]

This test has a different performance profile than the existing
allocator_thread.cc upon which it is based.  The core was abstracted
from a real application by Dan Evison (the PR submitter) on an MP.

BTW, the latest __mt_alloc patches from Stefan make this test fly
almost as fast as the FreeBSD system malloc on a single i686.  This is
a major improvement over unpatched __mt_alloc & the default node
allocator (with threaded test cases) on this platform.  Great work
Stefan!

allocator_map_thread.cc         iterations: 17241       type: __gnu_norm::map<int, int, std::less<int>, std::allocator<std::pair<int const, int> > >    
allocator_map_thread.cc                                         1045r 1041u    0s     1220mem    0pf 
allocator_map_thread.cc         iterations: 17241       type: __gnu_norm::map<int, int, std::less<int const>, __gnu_cxx::malloc_allocator<int> >        
allocator_map_thread.cc                                          227r  225u    1s     1416mem    0pf 
allocator_map_thread.cc         iterations: 17241       type: __gnu_norm::map<int, int, std::less<int const>, __gnu_cxx::__mt_alloc<std::pair<int const, int> > >       
allocator_map_thread.cc                                          242r  242u    0s     1924mem    0pf 

Committed to mainline.

	libstdc++/13823
	* testsuite/performance/allocator_map_thread.cc: New test.

Index: testsuite/performance/allocator_map_thread.cc
===================================================================
RCS file: testsuite/performance/allocator_map_thread.cc
diff -N testsuite/performance/allocator_map_thread.cc
*** /dev/null	1 Jan 1970 00:00:00 -0000
--- testsuite/performance/allocator_map_thread.cc	23 Jan 2004 06:30:49 -0000
***************
*** 0 ****
--- 1,132 ----
+ // Copyright (C) 2004 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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ // 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.
+ 
+ /*
+  * The goal with this application is to compare the performance
+  * between different std::allocator implementations. The results are
+  * influenced by the underlying allocator in the "C" library, malloc.
+  */
+ 
+ // libstdc++/13823 recast for this testing framework
+ 
+ #include <map>
+ #include <iostream>
+ #include <typeinfo>
+ #include <sstream>
+ #include <cxxabi.h>
+ #include <ext/mt_allocator.h>
+ #include <ext/malloc_allocator.h>
+ #include <testsuite_performance.h>
+ 
+ using namespace std;
+ using __gnu_cxx::malloc_allocator;
+ using __gnu_cxx::__mt_alloc;
+ 
+ // The number of iterations to be performed.
+ int iterations;
+ 
+ template<typename Container>
+   void*
+   do_loop(void* p = NULL)
+   {
+     try
+       {
+ 	for (int c = 0; c < 10; c++)
+ 	  {
+ 	    Container m;
+ 
+ 	    for (unsigned i = 0; i < iterations; ++i) 
+ 	      m[i] = i;
+ 	  }
+       }
+     catch(...)
+       {
+ 	// No point allocating all available memory, repeatedly.	
+       }
+   }
+ 
+ template<typename Container>
+   void
+   calibrate_iterations()
+   {
+     int try_iterations = iterations = 10000;
+ 
+     __gnu_test::time_counter timer;
+     timer.start();
+     do_loop<Container>();
+     timer.stop();
+ 
+     double tics = timer.real_time();
+     double iterpc = iterations / tics; //iterations per clock
+     double xtics = 100; // works for linux 2gig x86
+     iterations = static_cast<int>(xtics * iterpc);
+   }
+ 
+ template<typename Container>
+   void
+   test_container(Container obj)
+   {
+     using namespace __gnu_test;
+     int status;
+ 
+     time_counter time;
+     resource_counter resource;
+ 
+     clear_counters(time, resource);
+     start_counters(time, resource);
+     
+     pthread_t  t1, t2, t3, t4;
+     pthread_create(&t1, NULL, &do_loop<Container>, NULL);
+     pthread_create(&t2, NULL, &do_loop<Container>, NULL);
+     pthread_create(&t3, NULL, &do_loop<Container>, NULL);
+     pthread_create(&t4, NULL, &do_loop<Container>, NULL);
+ 
+     pthread_join(t1, NULL);
+     pthread_join(t2, NULL);
+     pthread_join(t3, NULL);
+     pthread_join(t4, NULL);
+ 
+     stop_counters(time, resource);
+  
+     std::ostringstream comment;
+     comment << "iterations: " << iterations << '\t';
+     comment << "type: " << abi::__cxa_demangle(typeid(obj).name(),
+ 					       0, 0, &status);
+     report_header(__FILE__, comment.str());
+     report_performance(__FILE__, string(), time, resource);
+   }
+ 
+ int main(void)
+ {
+   calibrate_iterations<map<int, int> >();
+   test_container(map<int, int>());
+   test_container(map<int, int, less<const int>, malloc_allocator<int> >());
+   test_container(map<int, int, less<const int>,
+                      __mt_alloc< pair<const int, int> > >());
+ 
+   return 0;
+ }