Add a minimal micro-benchmark suite to validate filtering hot-path optimizations

[sentomk]

While reading the scan-planning filtering path, I found a small optimization in the metrics evaluators. Using it as a concrete example to raise a broader question about how to validate this kind of change.

Proposed change

The metrics evaluators run per data file. Each predicate currently calls expr->reference() repeatedly, and reference() returns a shared_ptr via shared_from_this() — an atomic refcount bump every time. The StrictMetricsEvaluator macro even discards a dynamic_cast result only to re-fetch the same reference:

- #define RETURN_IF_NOT_REFERENCE(expr)                                         \
-   if (auto ref = dynamic_cast<BoundReference*>(expr.get()); ref == nullptr) { \
-     return kRowsMightNotMatch;                                                \
-   }
+ #define BIND_REFERENCE_OR_RETURN(ref, expr)                            \
+   const auto* ref = dynamic_cast<const BoundReference*>((expr).get()); \
+   if (ref == nullptr) {                                                \
+     return kRowsMightNotMatch;                                         \
+   }

    Result<bool> IsNull(const std::shared_ptr<Bound>& expr) override {
-     RETURN_IF_NOT_REFERENCE(expr);
-     int32_t id = expr->reference()->field().field_id();
+     BIND_REFERENCE_OR_RETURN(ref, expr);
+     int32_t id = ref->field().field_id();
      ...

Reusing the cast result drops the repeated virtual reference() calls (and their atomic ops) across every predicate, with no behavior change.

Expected benefit

The win is on the CPU-bound filtering step, evaluated in isolation. Scan planning as a whole is IO-bound, so on an e2e scan this kind of change is almost certainly unmeasurable — which is exactly why it needs to be measured on the filtering step alone.

Which raises the question: do we need a benchmark suite?

This is exactly the kind of change that's hard to justify without one. The repo has no benchmark infrastructure today, only the gtest suite. A minimal benchmark on the filtering path would let us measure such changes on the CPU-bound step alone, rather than guessing or claiming a win against IO-dominated planning.

So before going further:

1. How should we add it — Google Benchmark fetched the same way googletest already is, behind an off-by-default CMake option?
2. Where should it live — a top-level benchmark/, or co-located under src/iceberg/**/?

I'm happy to put up a draft PR for a minimal suite + the filtering benchmark above once there's agreement on direction.

[zhjwpku]

It seems that all RETURN_IF_NOT_REFERENCE usages share the same pattern, so +1 for this improvement.

For benchmarking, we discussed [0] this briefly when choosing the unit test framework. Another option besides Google Test was Catch2 [1], which has microbenchmark and BDD features. We didn't choose it back then because most people involved were more familiar with Google Test.

Maybe it's time to spend some effort evaluating the benchmarking infrastructure and making a choice.

[0] #12
[1] https://github.com/catchorg/Catch2

[sentomk]

Thanks for the context!

I'd lean toward Google Benchmark here. Catch2's benchmarking is part of its test framework — you write benchmarks as Catch2 cases — so since the tests are all GTest today, using it just for benchmarks would mean maintaining two test frameworks side by side; it only really pays off if we migrate the tests too, which is a much bigger call. Google Benchmark, by contrast, is a standalone library that's orthogonal to GTest, so it can sit behind its own ICEBERG_BUILD_BENCHMARKS option without touching the test setup. It's also familiar ground here.

That said, these are two separable paths. One is to add benchmarks only: a standalone Google Benchmark target that leaves the test stack untouched. That's my preference, and it's all the filtering example needs. The other is to re-evaluate the whole test/bench stack with Catch2 for both, which is a larger discussion that reopens #12. Happy to go either way the team prefers.

If the benchmarks-only path sounds reasonable, I can put up a draft PR with the minimal setup plus the filtering benchmark. And the RETURN_IF_NOT_REFERENCE cleanup can land independently whenever — thanks for the +1.

[zhjwpku]

I also prefer Google Benchmark since we're already using Google Test, and switching to Catch2 would introduce a fair amount of code churn.

Another reason to choose Google Benchmark is that Apache Arrow uses it as well. We've learned a lot from Arrow project, including parts of our build system and the pluggable interface design, so following the same benchmarking infrastructure makes sense to me.