Minimal benchmark

Summary:
Before further prioritizing `result` coro usage in `folly/coro/safe` collector code, I wanted to know if the compiler is currently allocating result coro frames on-stack.

It turned out that prior to llvm/llvm-project#152623, it is not.

```
Before P152623:

============================================================================
[...]lly/result/test/result_coro_bench.cpp     relative  time/iter   iters/s
============================================================================
result_coro_success                                        13.61ns    73.49M
non_catching_result_func_success                            3.39ns   295.00M
catching_result_func_success                                4.41ns   226.88M
result_coro_error                                          19.55ns    51.16M
non_catching_result_func_error                              9.15ns   109.26M
catching_result_func_error                                 10.19ns    98.10M

After P152623:

============================================================================
[...]lly/result/test/result_coro_bench.cpp     relative  time/iter   iters/s
============================================================================
result_coro_success                                        10.59ns    94.39M
non_catching_result_func_success                            3.39ns   295.00M
catching_result_func_success                                4.07ns   245.81M
result_coro_error                                          13.66ns    73.18M
non_catching_result_func_error                              9.00ns   111.11M
catching_result_func_error                                 10.04ns    99.63M
```

While it should be possible to further reduce the optimization gap between coro & non-coro, I'm not planning to work on it in the immediate future.

Reviewed By: ispeters

Differential Revision: D79969519

fbshipit-source-id: 0583a773965f718388715b06067bda4ca8d85737

Author: snarkmaster

third-party/folly/src/folly/result/test/result_coro_bench.cpp

@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdexcept>
+
+#include <folly/Benchmark.h>
+#include <folly/Portability.h>
+#include <folly/lang/Keep.h>
+
+#if FOLLY_HAS_RESULT
+
+#include <folly/result/result.h>
+
+namespace folly {
+
+// Simple result coroutine that adds 1 to the input
+result<int> result_coro(result<int>&& r) {
+  co_return co_await std::move(r) + 1;
+}
+
+// Non-coroutine equivalent using value_or_throw()
+result<int> catching_result_func(result<int>&& r) {
+  return result_catch_all([&]() -> result<int> {
+    if (r.has_value()) {
+      return r.value_or_throw() + 1;
+    }
+    return std::move(r).non_value();
+  });
+}
+
+// Not QUITE equivalent to the coro -- lacks the exception boundary
+result<int> non_catching_result_func(result<int>&& r) {
+  if (r.has_value()) {
+    return r.value_or_throw() + 1;
+  }
+  return std::move(r).non_value();
+}
+
+// The wrappers are for ease of `objdump --disassemble=FN`.
+
+extern "C" FOLLY_KEEP FOLLY_NOINLINE void result_coro_wrapper(result<int> r) {
+  folly::compiler_must_not_elide(result_coro(std::move(r)));
+}
+
+extern "C" FOLLY_KEEP FOLLY_NOINLINE void non_catching_result_func_wrapper(
+    result<int> r) {
+  folly::compiler_must_not_elide(non_catching_result_func(std::move(r)));
+}
+
+extern "C" FOLLY_KEEP FOLLY_NOINLINE void catching_result_func_wrapper(
+    result<int> r) {
+  folly::compiler_must_not_elide(catching_result_func(std::move(r)));
+}
+
+BENCHMARK(result_coro_success, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{42};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(result_coro(input.copy()));
+    }
+  });
+}
+
+BENCHMARK(non_catching_result_func_success, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{42};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(non_catching_result_func(input.copy()));
+    }
+  });
+}
+
+BENCHMARK(catching_result_func_success, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{42};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(catching_result_func(input.copy()));
+    }
+  });
+}
+
+BENCHMARK(result_coro_error, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{non_value_result{std::runtime_error{"test error"}}};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(result_coro(input.copy()));
+    }
+  });
+}
+
+BENCHMARK(non_catching_result_func_error, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{non_value_result{std::runtime_error{"test error"}}};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(non_catching_result_func(input.copy()));
+    }
+  });
+}
+
+BENCHMARK(catching_result_func_error, iters) {
+  BenchmarkSuspender suspender;
+  result<int> input{non_value_result{std::runtime_error{"test error"}}};
+  suspender.dismissing([&] {
+    while (iters--) {
+      folly::compiler_must_not_elide(catching_result_func(input.copy()));
+    }
+  });
+}
+
+} // namespace folly
+
+int main(int argc, char** argv) {
+  folly::gflags::ParseCommandLineFlags(&argc, &argv, true);
+  folly::runBenchmarks();
+  return 0;
+}
+
+#endif // FOLLY_HAS_RESULT