k-bench | Workload Benchmark for Kubernetes | Performance Testing library

The reason for the time complexity difference is that std::find operates with iterators, and it, indeed, does treat std::set as a sequence container, while std::set::find uses container properties.

As for why st.begin() is faster than std::begin(st), they are actually identical. The reason why second is faster is that both of your functions are doing the same thing, and as benchmarks are run consecutively, the execution of the second function is faster because probably cache misses are lower and similar things. I changed the order of these two functions and got exactly opposite result with std::begin(st) being faster. See this modified benchmark here: https://quick-bench.com/q/iM6e3iT1XbqnW_s-v_kyrs6kqrQ

libstdc++'s std::string_view::find_first_of looks something like:

For small strings, there's no point using dynamic storage. The allocation itself is slower than the comparison. Standard library implementers know this and have optimised std::basic_string to not use dynamic storage with small strings.

Using C-strings is not an "optimisation".

"Issue" with cond ? mod_power2 : mod is that it is a function pointer, which is harder to inline.

Different lambdas have no common type. Using type-erasure such as std::function has overhead, and devirtualization is even harder to optimize.

So, only option I see is to be able to write run1 in a "nicer" way:

Factorize the creation of the lambda; you need to turn mod/mod_power2 into functors (else we have same issue than run2 Demo):

Shifting is standard; you can get some simple rounding by first adding half of the least-significant preserved bit’s value before shifting, although that doesn’t implement proper round-to-even and you have to worry about overflow.

Your tests are invalid because you're doing blocking I/O inside the timing.

However, we can use quick-bench to analyze: https://quick-bench.com/q/gt2KzKOFP4iV3ajmqANL_MhnMZk. This shows the timings are all virtually identical. What about the compiler-generated assembly code?

Why does it work so much slower?

The problem you're running into is one of the differences between the C++98/C++17 iterator model and the C++20 iterator model. One of the old requirements for X to be a forward iterator was:

if X is a mutable iterator, reference is a reference to T; if X is a constant iterator, reference is a reference to const T,

That is, the iterator's reference type had to be a true reference. It could not be a proxy reference or a prvalue. Any iterator whose reference is a prvalue is automatically an input iterator only.

There is no such requirement in C++20.

So if you look at foo | std::ranges::views::transform(convert), this is a range of prvalue int. In the C++20 iterator model, this is a random access range. But in the C++17, because we're dealing with prvalues, this is an input range only.

vector's iterator-pair constructor is not based on the C++20 iterator model, it is based on the C++98/C++17 iterator model. It's using the old understanding of iterator category, not the new understanding. And the C++20 range adaptors work very hard to ensure that they do the "right thing" with respect to the old iterator model. Our adapted range does correctly advertise itself as random access when checked as C++20 and input when checked as C++17:

Line 36:

Some remarks on your methodology:

• It is very unusual to have a channel with a buffer size of 1 million. I would not expect benchmarks derived from such usage to have much applicability to real-world programs. Just use a buffer size of 1. This is plenty for this application to succeed, and more closely mirrors real-world usage.
• You don't need to pick such a gigantic n. If your function runs more quickly, criterium can take more samples, getting a more accurate estimate of its average time. n=100 is plenty.

After making those changes, here is the benchmark data I see: