Function correctness_sweep

examples/sort/bench_stable_sort.cpp:302–333

template <typename T>
void correctness_sweep(const char * type_name) {
    const size_t  ns[]   = { 0, 1, 2, 3, 5, 15, 16, 17, 31, 32, 33, 63, 64, 65, 100, 1000, 4096 };
    const Pattern pats[] = { Pattern::Random, Pattern::Dups, Pattern::Sorted,
                             Pattern::Partial, Pattern::Reverse, Pattern::AllEqual };
    int cases = 0;
    for (uint32_t seed = 1; seed <= 5; seed++) {
        for (size_t n : ns) {
            for (Pattern p : pats) {
                auto in = make_pattern<T>(p, n, seed * 7919u);
                // Run each candidate on its own fresh copy, verify against the pristine input.
                auto fail = [&](const char * nm) {
                    std::fprintf(stderr, "CORRECTNESS FAIL: %s on %s n=%zu pattern=%s seed=%u\n",
                                 nm, type_name, n, pattern_name(p), seed);
                    std::abort();
                };
                auto run = [&](const char * nm, auto fn) {
                    auto out = in;
                    fn(out.data(), out.size(), sizeof(T), key_less);
                    if (!verify_full(out, in)) fail(nm);
                    cases++;
                };
                // Shipped functions (das_qsort_r.h): byte + typed.
                run("#3 byte",  [](void * b, size_t e, size_t w, bool(*c)(const void*, const void*)) { das_stable_sort_r(b, e, w, c); });
                { auto out = in; das_stable_sort(out.data(), out.data() + out.size(), TypedLess<T>()); if (!verify_full(out, in)) fail("#3 typed"); cases++; }
                // Reference candidates (bake-off record): #1 dropped, #4 deferred.
                run("#1 merge", [](void * b, size_t e, size_t w, bool(*c)(const void*, const void*)) { das_stable_merge_r(b, e, w, c); });
                run("#4 index", [](void * b, size_t e, size_t w, bool(*c)(const void*, const void*)) { das_stable_index_r(b, e, w, c); });
            }
        }
    }
    std::printf("correctness: %-14s %d cases OK (sorted + stable + permutation + element-integrity)\n", type_name, cases);
}

int pick_iters(size_t n) {
    if (n <= 1000)  return 5000;