update sources to v12.2.3

[ceph.git] / ceph / src / boost / libs / move / test / adaptive_merge_test.cpp

diff --git a/ceph/src/boost/libs/move/test/adaptive_merge_test.cpp b/ceph/src/boost/libs/move/test/adaptive_merge_test.cpp
index 5365e786c50af3e281ac4b9e53ab52146157be51..95226257e9c8b34f70d8a28f26f9f3e9c75fa00a 100644 (file)
--- a/ceph/src/boost/libs/move/test/adaptive_merge_test.cpp
+++ b/ceph/src/boost/libs/move/test/adaptive_merge_test.cpp
@@ -10,20 +10,15 @@
 //////////////////////////////////////////////////////////////////////////////
 
 #include <cstdlib>   //std::srand
-#include <algorithm> //std::next_permutation
 #include <iostream>  //std::cout
 
 #include <boost/config.hpp>
 
 #include <boost/move/unique_ptr.hpp>
-#include <boost/container/vector.hpp>
-#include <boost/timer/timer.hpp>
-
-using boost::timer::cpu_timer;
-using boost::timer::cpu_times;
-using boost::timer::nanosecond_type;
+#include <boost/move/algo/detail/merge_sort.hpp>
 
 #include "order_type.hpp"
+#include "random_shuffle.hpp"
 
 #include <boost/move/algo/adaptive_merge.hpp>
 #include <boost/move/core.hpp>
@@ -46,7 +41,7 @@ bool test_random_shuffled(std::size_t const element_count, std::size_t const num
 
    for (std::size_t i = 0; i != num_iter; ++i)
    {
-      std::random_shuffle(elements.get(), elements.get() + element_count);
+      ::random_shuffle(elements.get(), elements.get() + element_count);
       for(std::size_t i = 0; i < (num_keys ? num_keys : element_count); ++i){
          key_reps[i]=0;
       }
@@ -54,14 +49,15 @@ bool test_random_shuffled(std::size_t const element_count, std::size_t const num
          elements[i].val = key_reps[elements[i].key]++;
       }
 
-      boost::container::vector<order_type> tmp(elements.get(), elements.get()+element_count);
+      boost::movelib::unique_ptr<char[]> buf(new char [sizeof(T)*(element_count-element_count/2)]);
+
       std::size_t const split = std::size_t(std::rand()) % element_count;
-      std::stable_sort(tmp.data(), tmp.data()+split, order_type_less<order_type>());
-      std::stable_sort(tmp.data()+split, tmp.data()+element_count, order_type_less<order_type>());
+      boost::movelib::merge_sort(elements.get(), elements.get()+split, order_type_less(), (T*)buf.get());
+      boost::movelib::merge_sort(elements.get()+split, elements.get()+element_count, order_type_less(), (T*)buf.get());
       
-      boost::movelib::adaptive_merge(tmp.data(), tmp.data()+split, tmp.data()+element_count, order_type_less<order_type>());
+      boost::movelib::adaptive_merge(elements.get(), elements.get()+split, elements.get()+element_count, order_type_less());
 
-      if (!is_order_type_ordered(tmp.data(), element_count))
+      if (!is_order_type_ordered(elements.get(), element_count))
       {
          std::cout <<  "\n ERROR\n";
          throw int(0);
@@ -72,16 +68,13 @@ bool test_random_shuffled(std::size_t const element_count, std::size_t const num
 
 int main()
 {
-   #ifdef NDEBUG
    const std::size_t NIter = 100;
-   #else
-   const std::size_t NIter = 10;
-   #endif
-   test_random_shuffled<order_type>(10001, 65,   NIter);
-   test_random_shuffled<order_type>(10001, 101,  NIter);
-   test_random_shuffled<order_type>(10001, 1023, NIter);
-   test_random_shuffled<order_type>(10001, 4095, NIter);
-   test_random_shuffled<order_type>(10001, 0,    NIter);
+   test_random_shuffled<order_move_type>(10001, 3,    NIter);
+   test_random_shuffled<order_move_type>(10001, 65,   NIter);
+   test_random_shuffled<order_move_type>(10001, 101,  NIter);
+   test_random_shuffled<order_move_type>(10001, 1023, NIter);
+   test_random_shuffled<order_move_type>(10001, 4095, NIter);
+   test_random_shuffled<order_move_type>(10001, 0,    NIter);
 
    return 0;
 }