boostorg/container
1
0
Fork 1
mirror of https://github.com/boostorg/container.git synced 2026-07-07 22:20:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add more segmented input/output combinations to the test

Browse Source
This commit is contained in:
Ion Gaztañaga
2026-05-02 01:05:24 +02:00
parent 215b14a762
commit 9d38794a18
1 changed files with 135 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
experimental/bench_segmented_algos.cpp
+135 -129
View File
@@ -1074,15 +1074,15 @@ struct seg_find_last_if_not {
// --- equal ---
template<class C, class R2>
struct std_equal {
const C &c; R2 &range2; int &result;
std_equal(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
std_equal(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = std::equal(c.begin(), c.end(), range2.begin()) ? 1 : 0; escape(&result); }
};
template<class C, class R2, bool Wrap = false>
struct seg_equal {
const C &c; R2 &range2; int &result;
seg_equal(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
seg_equal(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = bc::segmented_equal(iter_w<Wrap>::wrap(c.begin()), iter_w<Wrap>::wrap(c.end()), iter_w<Wrap>::wrap(range2.begin())) ? 1 : 0; escape(&result); }
};
@@ -1324,15 +1324,15 @@ struct seg_merge {
// --- mismatch ---
template<class C, class R2>
struct std_mismatch {
const C &c; R2 &range2; int &result;
std_mismatch(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
std_mismatch(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = (std::mismatch(c.begin(), c.end(), range2.begin()).first == c.end()) ? 1 : 0; escape(&result); }
};
template<class C, class R2, bool Wrap = false>
struct seg_mismatch {
const C &c; R2 &range2; int &result;
seg_mismatch(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
seg_mismatch(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = (bc::segmented_mismatch(iter_w<Wrap>::wrap(c.begin()), iter_w<Wrap>::wrap(c.end()), iter_w<Wrap>::wrap(range2.begin())).first == iter_w<Wrap>::wrap(c.end())) ? 1 : 0; escape(&result); }
};
@@ -1340,15 +1340,15 @@ struct seg_mismatch {
// --- mismatch (two-range) ---
template<class C, class R2>
struct std_mismatch_2r {
const C &c; R2 &range2; int &result;
std_mismatch_2r(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
std_mismatch_2r(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = (bench_detail::mismatch(c.begin(), c.end(), range2.begin(), range2.end()).first == c.end()) ? 1 : 0; escape(&result); }
};
template<class C, class R2, bool Wrap = false>
struct seg_mismatch_2r {
const C &c; R2 &range2; int &result;
seg_mismatch_2r(const C &c_, R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
const C &c; const R2 &range2; int &result;
seg_mismatch_2r(const C &c_, const R2 &r2_, int &r_) : c(c_), range2(r2_), result(r_) {}
BOOST_CONTAINER_FORCEINLINE void operator()()
{ clobber(); result = (bc::segmented_mismatch(iter_w<Wrap>::wrap(c.begin()), iter_w<Wrap>::wrap(c.end()), iter_w<Wrap>::wrap(range2.begin()), iter_w<Wrap>::wrap(range2.end())).first == iter_w<Wrap>::wrap(c.end())) ? 1 : 0; escape(&result); }
};
@@ -1644,29 +1644,25 @@ void bench_for_each(const C &c, std::size_t iters, const char* cname)
bench_ops::seg_for_each<C, true>(c, result), "for_each", cname);
}
template<bool IsDual, class C>
void bench_copy(const C &c, std::size_t iters, const char* cname, const char* label)
template<class InC, class OutC>
void bench_copy(const InC &c, std::size_t iters, const char* cname, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
OutC out(c.size());
compare_batch(iters, c.size(),
bench_ops::std_copy<C, out_t>(c, out),
bench_ops::seg_copy<C, out_t>(c, out),
bench_ops::seg_copy<C, out_t, true>(c, out), label, cname);
bench_ops::std_copy<InC, OutC>(c, out),
bench_ops::seg_copy<InC, OutC>(c, out),
bench_ops::seg_copy<InC, OutC, true>(c, out), label, cname);
}
template<bool IsDual, class C, class Pred>
void bench_copy_if(const C &c, std::size_t iters, const char* cname,
template<class InC, class OutC, class Pred>
void bench_copy_if(const InC &c, std::size_t iters, const char* cname,
Pred pred, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
OutC out(c.size());
compare_batch(iters, c.size(),
bench_ops::std_copy_if<C, out_t, Pred>(c, out, pred),
bench_ops::seg_copy_if<C, out_t, Pred>(c, out, pred),
bench_ops::seg_copy_if<C, out_t, Pred, true>(c, out, pred), label, cname);
bench_ops::std_copy_if<InC, OutC, Pred>(c, out, pred),
bench_ops::seg_copy_if<InC, OutC, Pred>(c, out, pred),
bench_ops::seg_copy_if<InC, OutC, Pred, true>(c, out, pred), label, cname);
}
template<class C>
@@ -1769,18 +1765,15 @@ void bench_find_last_if_not(const C &c, std::size_t iters, const char* cname,
bench_ops::seg_find_last_if_not<C, Pred, true>(c, pred, result), label, cname);
}
template<bool IsDual, class C>
void bench_equal(const C &c, const C &c2, std::size_t iters, const char* cname,
template<class InC1, class InC2>
void bench_equal(const InC1 &c, const InC2 &c2, std::size_t iters, const char* cname,
const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type range2_t;
range2_t range2(c2.begin(), c2.end());
int result = 0;
compare_batch(iters, c.size(),
bench_ops::std_equal<C, range2_t>(c, range2, result),
bench_ops::seg_equal<C, range2_t>(c, range2, result),
bench_ops::seg_equal<C, range2_t, true>(c, range2, result), label, cname);
bench_ops::std_equal<InC1, InC2>(c, c2, result),
bench_ops::seg_equal<InC1, InC2>(c, c2, result),
bench_ops::seg_equal<InC1, InC2, true>(c, c2, result), label, cname);
}
template<class C>
@@ -1837,18 +1830,16 @@ void bench_fill_n(const C &c, std::size_t iters, const char* cname)
bench_ops::seg_fill_n<C, true>(c2, n, val), "fill_n", cname);
}
template<bool IsDual, class C>
void bench_copy_n(const C &c, std::size_t iters, const char* cname, const char* label)
template<class InC, class OutC>
void bench_copy_n(const InC &c, std::size_t iters, const char* cname, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
typename C::difference_type n =
static_cast<typename C::difference_type>(c.size());
OutC out(c.size());
typename InC::difference_type n =
static_cast<typename InC::difference_type>(c.size());
compare_batch(iters, c.size(),
bench_ops::std_copy_n<C, out_t>(c, n, out),
bench_ops::seg_copy_n<C, out_t>(c, n, out),
bench_ops::seg_copy_n<C, out_t, true>(c, n, out), label, cname);
bench_ops::std_copy_n<InC, OutC>(c, n, out),
bench_ops::seg_copy_n<InC, OutC>(c, n, out),
bench_ops::seg_copy_n<InC, OutC, true>(c, n, out), label, cname);
}
template<class C>
@@ -1901,30 +1892,26 @@ void bench_remove_if(const C &c, std::size_t iters, const char* cname,
label, cname);
}
template<bool IsDual, class C>
void bench_remove_copy(const C &c, std::size_t iters, const char* cname,
const typename C::value_type& val, const char* label)
template<class InC, class OutC>
void bench_remove_copy(const InC &c, std::size_t iters, const char* cname,
const typename InC::value_type& val, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
OutC out(c.size());
compare_batch(iters, c.size(),
bench_ops::std_remove_copy<C, out_t>(c, out, val),
bench_ops::seg_remove_copy<C, out_t>(c, out, val),
bench_ops::seg_remove_copy<C, out_t, true>(c, out, val), label, cname);
bench_ops::std_remove_copy<InC, OutC>(c, out, val),
bench_ops::seg_remove_copy<InC, OutC>(c, out, val),
bench_ops::seg_remove_copy<InC, OutC, true>(c, out, val), label, cname);
}
template<bool IsDual, class C, class Pred>
void bench_remove_copy_if(const C &c, std::size_t iters, const char* cname,
template<class InC, class OutC, class Pred>
void bench_remove_copy_if(const InC &c, std::size_t iters, const char* cname,
Pred pred, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
OutC out(c.size());
compare_batch(iters, c.size(),
bench_ops::std_remove_copy_if<C, out_t, Pred>(c, out, pred),
bench_ops::seg_remove_copy_if<C, out_t, Pred>(c, out, pred),
bench_ops::seg_remove_copy_if<C, out_t, Pred, true>(c, out, pred), label, cname);
bench_ops::std_remove_copy_if<InC, OutC, Pred>(c, out, pred),
bench_ops::seg_remove_copy_if<InC, OutC, Pred>(c, out, pred),
bench_ops::seg_remove_copy_if<InC, OutC, Pred, true>(c, out, pred), label, cname);
}
template<class C>
@@ -1938,16 +1925,14 @@ void bench_reverse(const C &c, std::size_t iters, const char* cname)
bench_ops::seg_reverse<C, true>(c2, result), "reverse", cname);
}
template<bool IsDual, class C>
void bench_reverse_copy(const C &c, std::size_t iters, const char* cname, const char* label)
template<class InC, class OutC>
void bench_reverse_copy(const InC &c, std::size_t iters, const char* cname, const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type out_t;
out_t out(c.size());
OutC out(c.size());
compare_batch(iters, c.size(),
bench_ops::std_reverse_copy<C, out_t>(c, out),
bench_ops::seg_reverse_copy<C, out_t>(c, out),
bench_ops::seg_reverse_copy<C, out_t, true>(c, out), label, cname);
bench_ops::std_reverse_copy<InC, OutC>(c, out),
bench_ops::seg_reverse_copy<InC, OutC>(c, out),
bench_ops::seg_reverse_copy<InC, OutC, true>(c, out), label, cname);
}
template<class C>
@@ -1994,32 +1979,26 @@ void bench_merge(const C1 &c1, const C2 &c2, std::size_t iters,
bench_ops::seg_merge<C1, C2, OutT, true>(c1, c2, out), label, cname);
}
template<bool IsDual, class C>
void bench_mismatch(const C &c, const C &c2, std::size_t iters, const char* cname,
template<class InC1, class InC2>
void bench_mismatch(const InC1 &c, const InC2 &c2, std::size_t iters, const char* cname,
const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type range2_t;
range2_t range2(c2.begin(), c2.end());
int result = 0;
compare_batch(iters, c.size(),
bench_ops::std_mismatch<C, range2_t>(c, range2, result),
bench_ops::seg_mismatch<C, range2_t>(c, range2, result),
bench_ops::seg_mismatch<C, range2_t, true>(c, range2, result), label, cname);
bench_ops::std_mismatch<InC1, InC2>(c, c2, result),
bench_ops::seg_mismatch<InC1, InC2>(c, c2, result),
bench_ops::seg_mismatch<InC1, InC2, true>(c, c2, result), label, cname);
}
template<bool IsDual, class C>
void bench_mismatch_2r(const C &c, const C &c2, std::size_t iters, const char* cname,
template<class InC1, class InC2>
void bench_mismatch_2r(const InC1 &c, const InC2 &c2, std::size_t iters, const char* cname,
const char* label)
{
typedef typename C::value_type VT;
typedef typename boost::move_detail::if_c<IsDual, C, boost::container::vector<VT> >::type range2_t;
range2_t range2(c2.begin(), c2.end());
int result = 0;
compare_batch(iters, c.size(),
bench_ops::std_mismatch_2r<C, range2_t>(c, range2, result),
bench_ops::seg_mismatch_2r<C, range2_t>(c, range2, result),
bench_ops::seg_mismatch_2r<C, range2_t, true>(c, range2, result), label, cname);
bench_ops::std_mismatch_2r<InC1, InC2>(c, c2, result),
bench_ops::seg_mismatch_2r<InC1, InC2>(c, c2, result),
bench_ops::seg_mismatch_2r<InC1, InC2, true>(c, c2, result), label, cname);
}
template<class C>
@@ -2167,6 +2146,7 @@ template<class C>
void run_all(const C& c, std::size_t iters, const char* cname)
{
typedef typename C::value_type VT;
typedef boost::container::vector<VT> vec_t;
const VT zero(0);
const VT min1(-1);
@@ -2174,6 +2154,10 @@ void run_all(const C& c, std::size_t iters, const char* cname)
const VT half((int)c.size()/2);
const VT threequart((int)c.size()*3/4);
//Flat (non-segmented) copy of c, used as the first range in the
//"only-second-range-segmented" (2S) variants of dual-shape algorithms.
vec_t cv(c.begin(), c.end());
g_geomean.reset();
print_subheader();
@@ -2186,18 +2170,25 @@ void run_all(const C& c, std::size_t iters, const char* cname)
bench_any_of(c, iters, cname, is_negative<VT>(), "any_of(miss)");
//copy
bench_copy<false>(c, iters, cname, "copy");
bench_copy<true>(c, iters, cname, "copy(2xS)");
// 1S: src = C (segmented), dst = bc::vector
// 2S: src = bc::vector, dst = C
// 2xS: src = C, dst = C
bench_copy<C, vec_t>(c, iters, cname, "copy(1S)");
bench_copy<vec_t, C >(cv, iters, cname, "copy(2S)");
bench_copy<C, C >(c, iters, cname, "copy(2xS)");
//copy_if
bench_copy_if<false>(c, iters, cname, is_odd<VT>(), "copy_if(hit)");
bench_copy_if<true>(c, iters, cname, is_odd<VT>(), "copy_if(2xS hit)");
bench_copy_if<false>(c, iters, cname, is_negative<VT>(), "copy_if(miss)");
bench_copy_if<true>(c, iters, cname, is_negative<VT>(), "copy_if(2xS miss)");
bench_copy_if<C, vec_t>(c, iters, cname, is_odd<VT>(), "copy_if(1S hit)");
bench_copy_if<vec_t, C >(cv, iters, cname, is_odd<VT>(), "copy_if(2S hit)");
bench_copy_if<C, C >(c, iters, cname, is_odd<VT>(), "copy_if(2xS hit)");
bench_copy_if<C, vec_t>(c, iters, cname, is_negative<VT>(), "copy_if(1S miss)");
bench_copy_if<vec_t, C >(cv, iters, cname, is_negative<VT>(), "copy_if(2S miss)");
bench_copy_if<C, C >(c, iters, cname, is_negative<VT>(), "copy_if(2xS miss)");
//copy_n
bench_copy_n<false>(c, iters, cname, "copy_n");
bench_copy_n<true>(c, iters, cname, "copy_n(2xS)");
bench_copy_n<C, vec_t>(c, iters, cname, "copy_n(1S)");
bench_copy_n<vec_t, C >(cv, iters, cname, "copy_n(2S)");
bench_copy_n<C, C >(c, iters, cname, "copy_n(2xS)");
//count
bench_count(c, iters, cname, zero, "count(hit)");
@@ -2210,11 +2201,15 @@ void run_all(const C& c, std::size_t iters, const char* cname)
//equal
{
C c2(c);
bench_equal<false>(c, c2, iters, cname, "equal(hit)");
bench_equal<true>(c, c2, iters, cname, "equal(2xS hit)");
vec_t c2v(c2.begin(), c2.end());
bench_equal<C, vec_t>(c, c2v, iters, cname, "equal(1S hit)");
bench_equal<vec_t, C >(cv, c2, iters, cname, "equal(2S hit)");
bench_equal<C, C >(c, c2, iters, cname, "equal(2xS hit)");
*boost::container::make_iterator_uadvance(c2.begin(), c2.size()/2) = min1;
bench_equal<false>(c, c2, iters, cname, "equal(miss)");
bench_equal<true>(c, c2, iters, cname, "equal(2xS miss)");
c2v.assign(c2.begin(), c2.end());
bench_equal<C, vec_t>(c, c2v, iters, cname, "equal(1S miss)");
bench_equal<vec_t, C >(cv, c2, iters, cname, "equal(2S miss)");
bench_equal<C, C >(c, c2, iters, cname, "equal(2xS miss)");
}
//fill
@@ -2282,48 +2277,54 @@ void run_all(const C& c, std::size_t iters, const char* cname)
//merge
{
typedef boost::container::vector<VT> vec_t;
C c2(c);
for (typename C::iterator it = c2.begin(); it != c2.end(); ++it)
*it = VT(int_value(*it) * 2);
// Flat copies of the inputs for the mixed-shape variants. Both copies
// are sorted (input data is monotonically generated) so the merge
// semantics are preserved.
vec_t v1(c.begin(), c.end());
vec_t v2(c2.begin(), c2.end());
// Flat copy of c2 for the mixed-shape variants. Both copies (cv and
// c2v) remain sorted (input data is monotonically generated) so the
// merge semantics are preserved.
vec_t c2v(c2.begin(), c2.end());
// merge(1): first range = C, second range = bc::vector, out = bc::vector
bench_merge<C, vec_t, vec_t>(c, v2, iters, cname, "merge(1S)");
// merge(2): first range = bc::vector, second range = C, out = bc::vector
bench_merge<vec_t, C, vec_t>(v1, c2, iters, cname, "merge(2S)");
// merge(1S): first range = C, second range = bc::vector, out = bc::vector
bench_merge<C, vec_t, vec_t>(c, c2v, iters, cname, "merge(1S)");
// merge(2S): first range = bc::vector, second range = C, out = bc::vector
bench_merge<vec_t, C, vec_t>(cv, c2, iters, cname, "merge(2S)");
// merge(2xS): both ranges = C, out = bc::vector
bench_merge<C, C, vec_t>(c, c2, iters, cname, "merge(2xS)");
bench_merge<C, C, vec_t>(c, c2, iters, cname, "merge(2xS)");
// merge(3xS): both ranges and out = C
bench_merge<C, C, C >(c, c2, iters, cname, "merge(3xS)");
bench_merge<C, C, C >(c, c2, iters, cname, "merge(3xS)");
}
//mismatch
{
C c2(c);
*boost::container::make_iterator_uadvance(c2.begin(), c2.size()/2) = min1;
bench_mismatch<false>(c, c2, iters, cname, "mismatch(hit)");
bench_mismatch<true>(c, c2, iters, cname, "mismatch(2xS hit)");
vec_t c2v(c2.begin(), c2.end());
bench_mismatch<C, vec_t>(c, c2v, iters, cname, "mismatch(1S hit)");
bench_mismatch<vec_t, C >(cv, c2, iters, cname, "mismatch(2S hit)");
bench_mismatch<C, C >(c, c2, iters, cname, "mismatch(2xS hit)");
*boost::container::make_iterator_uadvance(c2.begin(), c2.size()/2) =
*boost::container::make_iterator_uadvance(c.begin(), c.size()/2);
bench_mismatch<false>(c, c2, iters, cname, "mismatch(miss)");
bench_mismatch<true>(c, c2, iters, cname, "mismatch(2xS miss)");
c2v.assign(c2.begin(), c2.end());
bench_mismatch<C, vec_t>(c, c2v, iters, cname, "mismatch(1S miss)");
bench_mismatch<vec_t, C >(cv, c2, iters, cname, "mismatch(2S miss)");
bench_mismatch<C, C >(c, c2, iters, cname, "mismatch(2xS miss)");
}
//mismatch (two ranges)
{
C c2(c);
*boost::container::make_iterator_uadvance(c2.begin(), c2.size()/2) = min1;
bench_mismatch_2r<false>(c, c2, iters, cname, "mismatch_2r(hit)");
bench_mismatch_2r<true>(c, c2, iters, cname, "mismatch_2r(2xS hit)");
vec_t c2v(c2.begin(), c2.end());
bench_mismatch_2r<C, vec_t>(c, c2v, iters, cname, "mismatch_2r(1S hit)");
bench_mismatch_2r<vec_t, C >(cv, c2, iters, cname, "mismatch_2r(2S hit)");
bench_mismatch_2r<C, C >(c, c2, iters, cname, "mismatch_2r(2xS hit)");
*boost::container::make_iterator_uadvance(c2.begin(), c2.size()/2) =
*boost::container::make_iterator_uadvance(c.begin(), c.size()/2);
bench_mismatch_2r<false>(c, c2, iters, cname, "mismatch_2r(miss)");
bench_mismatch_2r<true>(c, c2, iters, cname, "mismatch_2r(2xS miss)");
c2v.assign(c2.begin(), c2.end());
bench_mismatch_2r<C, vec_t>(c, c2v, iters, cname, "mismatch_2r(1S miss)");
bench_mismatch_2r<vec_t, C >(cv, c2, iters, cname, "mismatch_2r(2S miss)");
bench_mismatch_2r<C, C >(c, c2, iters, cname, "mismatch_2r(2xS miss)");
}
//none_of
@@ -2349,16 +2350,20 @@ void run_all(const C& c, std::size_t iters, const char* cname)
bench_remove_if(c, iters, cname, is_negative<VT>(), "remove_if(miss)");
//remove_copy
bench_remove_copy<false>(c, iters, cname, half, "remove_copy(hit)");
bench_remove_copy<true>(c, iters, cname, half, "remove_copy(2xS hit)");
bench_remove_copy<false>(c, iters, cname, min1, "remove_copy(miss)");
bench_remove_copy<true>(c, iters, cname, min1, "remove_copy(2xS miss)");
bench_remove_copy<C, vec_t>(c, iters, cname, half, "remove_copy(1S hit)");
bench_remove_copy<vec_t, C >(cv, iters, cname, half, "remove_copy(2S hit)");
bench_remove_copy<C, C >(c, iters, cname, half, "remove_copy(2xS hit)");
bench_remove_copy<C, vec_t>(c, iters, cname, min1, "remove_copy(1S miss)");
bench_remove_copy<vec_t, C >(cv, iters, cname, min1, "remove_copy(2S miss)");
bench_remove_copy<C, C >(c, iters, cname, min1, "remove_copy(2xS miss)");
//remove_copy_if
bench_remove_copy_if<false>(c, iters, cname, less_and_greater_ref<VT>(quart, threequart), "remove_copy_if(hit)");
bench_remove_copy_if<true>(c, iters, cname, less_and_greater_ref<VT>(quart, threequart), "remove_copy_if(2xS hit)");
bench_remove_copy_if<false>(c, iters, cname, is_negative<VT>(), "remove_copy_if(miss)");
bench_remove_copy_if<true>(c, iters, cname, is_negative<VT>(), "remove_copy_if(2xS miss)");
bench_remove_copy_if<C, vec_t>(c, iters, cname, less_and_greater_ref<VT>(quart, threequart), "remove_copy_if(1S hit)");
bench_remove_copy_if<vec_t, C >(cv, iters, cname, less_and_greater_ref<VT>(quart, threequart), "remove_copy_if(2S hit)");
bench_remove_copy_if<C, C >(c, iters, cname, less_and_greater_ref<VT>(quart, threequart), "remove_copy_if(2xS hit)");
bench_remove_copy_if<C, vec_t>(c, iters, cname, is_negative<VT>(), "remove_copy_if(1S miss)");
bench_remove_copy_if<vec_t, C >(cv, iters, cname, is_negative<VT>(), "remove_copy_if(2S miss)");
bench_remove_copy_if<C, C >(c, iters, cname, is_negative<VT>(), "remove_copy_if(2xS miss)");
//replace
{ //Replace half of the elements to ensure that the "hit" case is not too fast
@@ -2381,8 +2386,9 @@ void run_all(const C& c, std::size_t iters, const char* cname)
bench_reverse(c, iters, cname);
//reverse_copy
bench_reverse_copy<false>(c, iters, cname, "reverse_copy");
bench_reverse_copy<true>(c, iters, cname, "reverse_copy(2xS)");
bench_reverse_copy<C, vec_t>(c, iters, cname, "reverse_copy(1S)");
bench_reverse_copy<vec_t, C >(cv, iters, cname, "reverse_copy(2S)");
bench_reverse_copy<C, C >(c, iters, cname, "reverse_copy(2xS)");
//search
{