Load shared libs impls

Author: ggcr

benchmark/Makefile

@@ -22,19 +22,26 @@ $(BUILD_DIR):
 	mkdir -p $@
 	echo "" > $(IMPLEMENTATIONS_INC)
 
-$(GO_LIB): $(BUILD_DIR)
+$(GO_LIB): | $(BUILD_DIR)
 	cd ./aws-sdk-go-v2 && go build -buildmode=c-shared -o ../$(BUILD_DIR)/libgo$(so_ext) .
 
-$(CPP_LIB): $(BUILD_DIR)
-	c++ -std=c++23 -shared -fPIC s3cpp/task.cpp -o $(BUILD_DIR)/libs3cpp$(so_ext)
+$(CPP_LIB): | $(BUILD_DIR)
+	c++ -std=c++26 -shared -fPIC s3cpp/task.cpp -o $(BUILD_DIR)/libs3cpp$(so_ext)
 
-$(RUST_LIB): $(BUILD_DIR)
+$(RUST_LIB): | $(BUILD_DIR)
 	cargo build --release --manifest-path ./aws-sdk-rust/Cargo.toml
 	mv ./aws-sdk-rust/target/release/librust$(so_ext) $(BUILD_DIR)/.
 
-$(IMPLEMENTATIONS_INC): $(GO_LIB) $(CPP_LIB) $(RUST_LIB) $(BUILD_DIR)
+$(IMPLEMENTATIONS_INC): $(GO_LIB) $(CPP_LIB) $(RUST_LIB) | $(BUILD_DIR)
 	printf '"./%s",\n' $(GO_LIB) $(CPP_LIB) $(RUST_LIB) > $@
 
+bench: $(IMPLEMENTATIONS_INC) $(GO_LIB) $(CPP_LIB) $(RUST_LIB) | $(BUILD_DIR)
+	c++ -std=c++26 main.cpp -o $(BUILD_DIR)/bench
+
+test: $(IMPLEMENTATIONS_INC) $(GO_LIB) $(CPP_LIB) $(RUST_LIB) | $(BUILD_DIR)
+	c++ -std=c++26 test.cpp -o $(BUILD_DIR)/test
+
+
 .PHONY: all clean
 clean:
 	rm -rf $(BUILD_DIR)

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

@@ -6,10 +6,10 @@ package main
 import "C"
 import "unsafe"
 
-// export get_object
+//export get_object
 func get_object(key *C.char) *C.char {
 	k := C.GoString(key)
-	s := "Hello from Go! Key: " + k
+	s := "go: Key: " + k
 	return C.CString(s)
 }
 

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

@@ -1,8 +1,23 @@
-use std::ffi::CString;
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
 
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn get_object(key: *const std::ffi::c_char) -> *const std::ffi::c_char {
-    let result = format!("Hello from Rust! Key: {:?}", key).to_string();
-    let c_result = CString::new(result).expect("CString::new failed");
-    c_result.as_ptr()
+pub unsafe extern "C" fn get_object(key: *const c_char) -> *mut c_char {
+    let key_str = if key.is_null() {
+        "<null>".to_string()
+    } else {
+        unsafe { CStr::from_ptr(key) }.to_string_lossy().into_owned()
+    };
+
+    let result = format!("rust: Key: {}", key_str);
+    CString::new(result).unwrap().into_raw()
+}
+
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn free_object(ptr: *mut c_char) {
+    if !ptr.is_null() {
+        unsafe {
+            drop(CString::from_raw(ptr));
+        }
+    }
 }

benchmark/implementations.h

@@ -0,0 +1,63 @@
+#ifndef S3CPP_BENCHMARK_IMPLEMENTATIONS_H
+#define S3CPP_BENCHMARK_IMPLEMENTATIONS_H
+
+#include "tasks.h"
+#include <cstddef>
+#include <cstdio>
+#include <dlfcn.h>
+#include <iterator>
+#include <print>
+#include <vector>
+
+namespace s3b {
+
+#define SO_SYMBOLS "init", "get_object"
+
+constexpr const char *implementations_so[] = {
+#include "build/implementations.inc"
+};
+
+constexpr std::size_t implementations_count = std::size(implementations_so);
+
+struct implementation {
+  const char *name;
+  init_f *init;
+  get_object_f *get_object;
+};
+
+inline implementation parse_implementation(const char *so_path) {
+  void *so_handle = dlopen(so_path, RTLD_LAZY);
+  if (so_handle == NULL) {
+    std::println(stderr, "fatal: unable to get handle {}", so_path);
+    std::exit(1);
+  }
+
+  std::string symbol_name = "init";
+  init_f *init = reinterpret_cast<init_f *>(dlsym(so_handle, symbol_name.c_str()));
+  if (init == NULL) {
+    std::println(stderr, "fatal: {} for {}", ::dlerror(), so_path);
+    std::exit(1);
+  }
+
+  symbol_name = "get_object";
+  get_object_f *get_object =
+      reinterpret_cast<get_object_f *>(dlsym(so_handle, symbol_name.c_str()));
+  if (get_object == NULL) {
+    std::println(stderr, "fatal: {} for {}", ::dlerror(), so_path);
+    std::exit(1);
+  }
+  return implementation{so_path, init, get_object};
+}
+
+inline std::array<implementation, implementations_count>
+parse_implementations() {
+  std::array<implementation, implementations_count> implementations{};
+  for (size_t i = 0; i < implementations_count; i++) {
+    implementations[i] = parse_implementation(implementations_so[i]);
+  }
+  return implementations;
+}
+
+} // namespace s3b
+
+#endif

benchmark/main.cpp

@@ -0,0 +1,11 @@
+#include "implementations.h"
+#include "tasks.h"
+#include <print>
+
+using namespace s3b;
+
+int main(int argc, char *argv[]) {
+  std::array<implementation, implementations_count> implementations =
+      parse_implementations();
+  return 0;
+}

benchmark/s3cpp/task.cpp

@@ -1,9 +1,18 @@
-#include "task.h"
 #include <format>
 #include <string>
 
-const char *s3bench::get_object(const char *key) noexcept {
+extern "C" {
+
+const char *init(const char *access, const char *secret,
+                 const char *endpoint) noexcept {
+  static std::string result;
+  result = std::format("c++: access: {}", access);
+  return result.c_str();
+}
+
+const char *get_object(const char *key) noexcept {
   static std::string result;
-  result = std::format("Hello from C++!\nKey: {}", key);
+  result = std::format("c++: Key: {}", key);
   return result.c_str();
 }
+}

benchmark/s3cpp/task.h

@@ -0,0 +1,16 @@
+#ifndef S3CPP_BENCHMARK_TASKS_H
+#define S3CPP_BENCHMARK_TASKS_H
+
+namespace s3b {
+
+typedef const char* init_f(const char* access, const char* secret, const char* endpoint) noexcept;
+typedef const char* get_object_f(const char* key) noexcept;
+
+extern "C" {
+__attribute__((visibility("default"))) init_f init;
+__attribute__((visibility("default"))) get_object_f get_object;
+}
+
+} // namespace s3bench
+
+#endif

benchmark/tasks.h

@@ -0,0 +1,20 @@
+#include "implementations.h"
+#include "tasks.h"
+
+namespace s3b {
+
+void test_get_object(const char *name, get_object_f *get_object) {
+  for (const auto key : {"one", "two", "three"}) {
+    std::println("{}", get_object(key));
+  }
+}
+
+} // namespace s3b
+
+int main() {
+  std::array<s3b::implementation, s3b::implementations_count> implementations =
+      s3b::parse_implementations();
+  for (const auto &implementation : implementations) {
+    s3b::test_get_object(implementation.name, implementation.get_object);
+  }
+}