Function run_expensive_cmp

examples/sort/bench_stable_sort.cpp:373–395

// comparator dominates. Shows whether #4's 2× comparator calls flip the movement-bound win.
template <typename T>
void run_expensive_cmp(const char * type_name) {
    const size_t sizes[]     = { 10000, 100000 };
    const Pattern patterns[] = { Pattern::Random, Pattern::Dups, Pattern::Sorted, Pattern::Partial, Pattern::Reverse };
    std::printf("\n## EXPENSIVE comparator — %s (sizeof=%zu) — daslang-interp proxy (byte path)\n\n", type_name, sizeof(T));
    std::printf("| N      | pattern    | std::stable | #3 byte   | #1 merge  | #4 index  | b/std | m/std | i/std |\n");
    std::printf("|--------|------------|------------:|----------:|----------:|----------:|------:|------:|------:|\n");
    for (size_t n : sizes) {
        int iters = pick_iters(n) / 4 + 1;          // expensive cmp → fewer iters
        for (Pattern pat : patterns) {
            auto data = make_pattern<T>(pat, n, 0xC0FFEEu);
            double s_std = bench_one("std::stable_sort", pat, data, iters,
                [](std::vector<T> & a) { std::stable_sort(a.begin(), a.end(), ExpensiveLess<T>()); });
            double d_b = bench_one("#3 byte", pat, data, iters,
                [](std::vector<T> & a) { das_stable_sort_r(a.data(), a.size(), sizeof(T), key_less_expensive); });
            double d_m = bench_one("#1 merge", pat, data, iters,
                [](std::vector<T> & a) { das_stable_merge_r(a.data(), a.size(), sizeof(T), key_less_expensive); });
            double d_i = bench_one("#4 index", pat, data, iters,
                [](std::vector<T> & a) { das_stable_index_r(a.data(), a.size(), sizeof(T), key_less_expensive); });
            std::printf("| %-6zu | %-10s | %11.0f | %9.0f | %9.0f | %9.0f | %5.2f | %5.2f | %5.2f |\n",
                n, pattern_name(pat), s_std, d_b, d_m, d_i, d_b/s_std, d_m/s_std, d_i/s_std);
        }
    }
}

template <typename T>
void run_cmp_counts(const char * type_name) {