Free client after each init

Author: ggcr

benchmark/aws-sdk-cpp/task.cpp

@@ -108,3 +108,7 @@ extern "C" const char *get_object(bench::ClientHandle handle,
   result = do_get_object(handle, bucket, key);
   return result.c_str();
 }
+
+extern "C" void free_client(bench::ClientHandle handle) noexcept {
+  delete reinterpret_cast<Aws::S3::S3Client *>(handle);
+}

benchmark/aws-sdk-go-v2/main.go

@@ -120,4 +120,10 @@ func get_object(handle unsafe.Pointer, bucket *C.char, key *C.char) *C.char {
 	return C.CString(contents)
 }
 
+//export free_client
+func free_client(handle unsafe.Pointer) {
+	h := *(*cgo.Handle)(handle)
+	h.Delete()
+}
+
 func main() {}

benchmark/aws-sdk-rust/src/lib.rs

@@ -11,10 +11,13 @@ struct ClientState {
 }
 
 fn initialize_client(access: String, secret: String, endpoint: String) -> ClientState {
-    let runtime = tokio::runtime::Runtime::new().unwrap_or_else(|err| {
-        eprintln!("fatal(rust): failed to create tokio runtime: {err}");
-        std::process::exit(1);
-    });
+    let runtime = tokio::runtime::Builder::new_current_thread()
+        .enable_all()
+        .build()
+        .unwrap_or_else(|err| {
+            eprintln!("fatal(rust): failed to create tokio runtime: {err}");
+            std::process::exit(1);
+        });
 
     let credentials = Credentials::from_keys(access, secret, None);
     let config = Config::builder()
@@ -140,3 +143,8 @@ pub unsafe extern "C" fn get_object(handle: *mut c_void, bucket: *const c_char,
         })
         .into_raw()
 }
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_client(handle: *mut c_void) {
+    drop(unsafe { Box::from_raw(handle as *mut ClientState) });
+}

benchmark/benchmark.cpp

@@ -11,7 +11,11 @@ static void benchmark_init_client(::benchmark::State &state, s3b::implementation
   const std::string secret_ = "minio_secret";
   const std::string endpoint_ = "127.0.0.1:9000";
   for (auto _ : state) {
-    ::benchmark::DoNotOptimize(impl.init_client("minio_access", "minio_secret", "127.0.0.1:9000"));
+    auto handle = impl.init_client("minio_access", "minio_secret", "127.0.0.1:9000");
+    ::benchmark::DoNotOptimize(handle);
+    state.PauseTiming();
+    impl.free_client(handle);
+    state.ResumeTiming();
   }
   s3b::clean_up();
 }
@@ -33,6 +37,7 @@ static void benchmark_create_bucket(::benchmark::State &state, s3b::implementati
     state.ResumeTiming();
     impl.create_bucket(handle, bucket.c_str());
   }
+
   s3b::clean_up();
 }
 

benchmark/implementations.h

@@ -26,6 +26,7 @@ struct implementation {
   bench::create_bucket_f *create_bucket;
   bench::put_object_f *put_object;
   bench::get_object_f *get_object;
+  bench::free_client_f *free_client;
 };
 
 inline implementation parse_implementation(const char *so_path) {
@@ -69,9 +70,17 @@ inline implementation parse_implementation(const char *so_path) {
     std::exit(1);
   }
 
+  symbol_name = "free_client";
+  bench::free_client_f *free_client =
+      reinterpret_cast<bench::free_client_f *>(dlsym(so_handle, symbol_name.c_str()));
+  if (free_client == NULL) {
+    std::println(stderr, "fatal: {} for {}", ::dlerror(), so_path);
+    std::exit(1);
+  }
+
   return implementation{so_path,     init_client("minio_access", "minio_secret", "127.0.0.1:9000"),
                         init_client, create_bucket,
-                        put_object,  get_object};
+                        put_object,  get_object, free_client};
 }
 
 inline std::array<implementation, implementations_count> parse_implementations() {

benchmark/s3cpp/task.cpp

@@ -72,3 +72,7 @@ extern "C" const char *get_object(bench::ClientHandle handle,
   result = do_get_object(handle, bucket, key);
   return result.c_str();
 }
+
+extern "C" void free_client(bench::ClientHandle handle) noexcept {
+    delete reinterpret_cast<S3Client *>(handle);
+}

benchmark/tasks.h

@@ -8,12 +8,14 @@ using init_client_f = ClientHandle(const char *access, const char *secret, const
 using create_bucket_f = void(ClientHandle client, const char *bucketName) noexcept;
 using put_object_f = void(ClientHandle client, const char *bucket, const char* key, const char* contents) noexcept;
 using get_object_f = const char *(ClientHandle client, const char *bucket, const char *key) noexcept;
+using free_client_f = void(ClientHandle client) noexcept;
 
 extern "C" {
 __attribute__((visibility("default"))) init_client_f init_client;
 __attribute__((visibility("default"))) create_bucket_f create_bucket;
 __attribute__((visibility("default"))) put_object_f put_object;
 __attribute__((visibility("default"))) get_object_f get_object;
+__attribute__((visibility("default"))) free_client_f free_client;
 }
 
 } // namespace bench

benchmark/test.cpp

@@ -31,6 +31,12 @@ void test_init_client(implementation impl) {
 }
 
 
+void test_free_client(implementation impl) {
+  bench::ClientHandle handle = impl.init_client("minio_access", "minio_secret", "127.0.0.1:9000");
+  impl.free_client(handle);
+  std::println("  OK free_client");
+}
+
 void test_create_bucket(implementation impl, const std::string &bucket) {
   bench::ClientHandle handle = impl.handler;
   impl.create_bucket(handle, bucket.c_str());
@@ -66,6 +72,7 @@ int main() {
   for (const auto &impl : implementations) {
     std::println("{}", impl.name);
     s3b::test_init_client(impl);
+    s3b::test_free_client(impl);
     std::string bucket = s3b::bucket_name_for(impl.name);
     s3b::test_create_bucket(impl, bucket);
     s3b::test_put_object(impl, bucket);