The old implementation of String matchers worked by making a, potentially lower-cased, copy of both the constructor arg, and the arg to `match` calls. The new implementation does not make copies, and instead does per-character lowering if needed. This is a win in **most** cases, with two exceptions: 1) Case-insensitive `Equals` between long strings. The old implementation is easy to autovectorize by the compiler, which wins over the extra copy with sufficiently long inputs. 2) Case-insensitive `ContainsSubstring` with inputs that trigger the worst case complexity of O(m*n) of the naive implementation. The latter is fixable with some elbow grease by implementing a proper string search algorithm, but the former is a cost we have to live with.
This provides further speed-ups for TUs with many test cases templated over the same set of types. For especially test-heavy (but still realistic) TUs, the speed up is up to 20%.
This provides small (but measurable) improvements in compilation times when a TU has multiple test cases templated over the same types.
We used to store a full vector of "views" of the registered test infos, so that it can be retrieved externally. However, the only user of that interface left was `Session`, specifically `Session::applyFilenameAsTags`. By moving the adding of the filename tags into the `ITestCaseRegistry` interface, we avoid storing the vector and make the initial test registration faster. The new code is ugly and shows a design/layering issue, but no worse than the previous approach did.
The underlying benchmarking machinery is templated, so that it can use different clock implementations (either for testing, or to support user with platform-specific clocks). However, 99.99% of all users interact with it using the `BENCHMARK` macro, which means that they use it with `std::chrono::steady_clock`. By adding outlined implementation of benchmarking helpers specialized onto `std::chrono::steady_clock`, we save some amount of time per every TU that uses benchmarks.
The goal is to do the equivalent of clobbering memory, which forces
the compiler to keep side effects that are external to the benchmarked
function, while allowing it to optimize inside the benchmarked function.
E.g. this cannot be optimized away:
```cpp
BENCHMARK("foo") {
global_count += 1;
};
```
while this can:
```cpp
BENCHMARK("bar") {
size_t local_count = 0;
for (size_t i = 0; i < 100; ++i) {
local_count += 1;
}
};
```
Preallocating to some reasonable and small number of tests avoids much of the geometric-reallocation threashing at low sizes, without taking up too much memory for tiny test binaries.
* fix: work around clang 20/21 + libc++ compile failure in TEMPLATE_PRODUCT_TEST_CASE with differing arities Fixes #3115 * docs: reference llvm/llvm-project#130778 in the clang 20/21 workaround comment --------- Co-authored-by: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>