chore: import upstream snapshot with attribution

bindings/rust/src/ffi.rs

@@ -0,0 +1,21 @@
+#[cxx::bridge]
+pub mod ffi {
+    #[namespace = "benchmark"]
+    unsafe extern "C++" {
+        include!("benchmark/benchmark.h");
+
+        type State;
+
+        fn KeepRunning(self: Pin<&mut State>) -> bool;
+        fn RunSpecifiedBenchmarks() -> usize;
+    }
+
+    #[namespace = "benchmark::rust_api"]
+    unsafe extern "C++" {
+        include!("rust_api.h");
+
+        unsafe fn SkipWithError(state: Pin<&mut State>, msg: &str);
+        unsafe fn RegisterBenchmark(name: &str, func: fn(Pin<&mut State>));
+        unsafe fn Initialize(argc: *mut i32, argv: usize);
+    }
+}

bindings/rust/src/lib.rs

@@ -0,0 +1,66 @@
+pub mod ffi;
+
+use std::ffi::CString;
+use std::os::raw::c_char;
+use std::pin::Pin;
+
+pub struct State<'a> {
+    #[doc(hidden)]
+    pub inner: Pin<&'a mut ffi::ffi::State>,
+}
+
+impl<'a> State<'a> {
+    /// Returns true if the benchmark should continue running.
+    ///
+    /// **Note:** `keep_running()` currently has a small per-iteration overhead due to the FFI boundary.
+    /// In the future, this could be optimized using `KeepRunningBatch` under the hood.
+    #[inline]
+    pub fn keep_running(&mut self) -> bool {
+        self.inner.as_mut().KeepRunning()
+    }
+
+    pub fn skip_with_error(&mut self, msg: &str) {
+        unsafe {
+            ffi::ffi::SkipWithError(self.inner.as_mut(), msg);
+        }
+    }
+}
+
+/// Initialize the benchmark library.
+/// This should be called before `run_specified_benchmarks`.
+pub fn initialize(args: &Vec<String>) {
+    let mut c_args: Vec<CString> = args.iter()
+        .map(|arg| CString::new(arg.as_str()).unwrap())
+        .collect();
+        
+    let mut c_ptrs: Vec<*mut c_char> = c_args.iter_mut()
+        .map(|c| c.as_ptr() as *mut c_char)
+        .collect();
+        
+    let mut argc = c_ptrs.len() as i32;
+    let argv = c_ptrs.as_mut_ptr();
+
+    unsafe {
+        ffi::ffi::Initialize(&mut argc as *mut _, argv as usize);
+    }
+}
+
+#[macro_export]
+macro_rules! register_benchmark {
+    ($name:expr, $func:path) => {
+        {
+            fn trampoline(mut state: std::pin::Pin<&mut $crate::ffi::ffi::State>) {
+                let mut wrapped = $crate::State { inner: state.as_mut() };
+                $func(&mut wrapped);
+            }
+            unsafe {
+                $crate::ffi::ffi::RegisterBenchmark($name, trampoline);
+            }
+        }
+    };
+}
+
+/// Run all registered benchmarks.
+pub fn run_specified_benchmarks() -> usize {
+    ffi::ffi::RunSpecifiedBenchmarks()
+}

bindings/rust/src/rust_api.cc

@@ -0,0 +1,33 @@
+#include "rust_api.h"
+
+#include <string>
+
+namespace benchmark {
+namespace rust_api {
+
+void RegisterBenchmark(rust::Str name, rust::Fn<void(benchmark::State&)> func);
+void Initialize(int* argc, size_t argv);
+void SkipWithError(benchmark::State& state, rust::Str msg);
+
+void RegisterBenchmark(rust::Str name, rust::Fn<void(benchmark::State&)> func) {
+  ::benchmark::RegisterBenchmark(std::string(name).c_str(),
+                                 [func](benchmark::State& st) { func(st); });
+}
+
+void Initialize(int* argc, size_t argv) {
+  char** argv_ptr = reinterpret_cast<char**>(argv);
+  if (argc != nullptr && *argc > 0 && argv_ptr != nullptr &&
+      argv_ptr[0] != nullptr) {
+    static std::string executable_name;
+    executable_name = argv_ptr[0];
+    argv_ptr[0] = executable_name.data();
+  }
+  ::benchmark::Initialize(argc, argv_ptr);
+}
+
+void SkipWithError(benchmark::State& state, rust::Str msg) {
+  state.SkipWithError(std::string(msg).c_str());
+}
+
+}  // namespace rust_api
+}  // namespace benchmark

bindings/rust/src/rust_api.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "benchmark/benchmark.h"
+#include "rust/cxx.h"
+
+namespace benchmark {
+namespace rust_api {
+
+void RegisterBenchmark(rust::Str name, rust::Fn<void(benchmark::State&)> func);
+void Initialize(int* argc, size_t argv);
+void SkipWithError(benchmark::State& state, rust::Str msg);
+
+}  // namespace rust_api
+}  // namespace benchmark