More benchmarks

Author: kunitoki

Benchmarks/benchmark_common.hpp

@@ -10,6 +10,7 @@
 #include <benchmark/benchmark.h>
 
 #include <cstdint>
+#include <memory>
 #include <stdexcept>
 #include <string>
 #include <string_view>
@@ -42,6 +43,11 @@ struct Counter
     {
         value = v;
     }
+
+    static int static_add(int a, int b)
+    {
+        return a + b;
+    }
 };
 
 struct Basic
@@ -152,6 +158,16 @@ struct StatefulFunction
     }
 };
 
+struct SharedObject : std::enable_shared_from_this<SharedObject>
+{
+    double value = kMagicValue;
+
+    double get() const
+    {
+        return value;
+    }
+};
+
 inline Basic* basic_return()
 {
     static Basic value{};
@@ -163,6 +179,17 @@ inline double basic_get_var(Basic* b)
     return b ? b->var : 0.0;
 }
 
+inline std::shared_ptr<SharedObject> shared_object_return()
+{
+    static std::shared_ptr<SharedObject> obj = std::make_shared<SharedObject>();
+    return obj;
+}
+
+inline double shared_object_get_value(std::shared_ptr<SharedObject> obj)
+{
+    return obj ? obj->get() : 0.0;
+}
+
 void luaCheckOrThrow(lua_State* L, int status, std::string_view where);
 void luaDoStringOrThrow(lua_State* L, std::string_view code, std::string_view where);
 

Benchmarks/benchmark_luabridge.cpp

@@ -21,6 +21,25 @@ int vanilla_multi_return(lua_State* L)
     return 2;
 }
 
+void registerBasicGetterSetter(lua_State* L)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Basic>("c")
+            .addConstructor<void (*)()>()
+            .addProperty("val", &Basic::get, &Basic::set)
+        .endClass();
+}
+
+void registerCounter(lua_State* L)
+{
+    luabridge::getGlobalNamespace(L)
+        .beginClass<Counter>("Counter")
+            .addConstructor<void (*)()>()
+            .addFunction("get", &Counter::get)
+            .addStaticFunction("static_add", &Counter::static_add)
+        .endClass();
+}
+
 lua_State* makeLua()
 {
     lua_State* L = luaL_newstate();
@@ -342,6 +361,120 @@ void optional_failure_measure(benchmark::State& state)
     benchmark::DoNotOptimize(x);
 }
 
+void userdata_variable_write_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+    registerBasic(L);
+    luaDoStringOrThrow(L, "b = c()", "vanilla userdata_write setup");
+    luaDoStringOrThrow(L, "function write_var() b.var = 24.0 end", "vanilla userdata_write closure setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "write_var");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 0, 0), "vanilla write_var");
+    }
+}
+
+void userdata_property_getter_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+    registerBasicGetterSetter(L);
+    luaDoStringOrThrow(L, "b = c()", "vanilla property_getter setup");
+    luaDoStringOrThrow(L, "function read_getter() return b.val end", "vanilla property_getter closure setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "read_getter");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 1, 0), "vanilla read_getter");
+        lua_pop(L, 1);
+    }
+}
+
+void userdata_property_setter_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+    registerBasicGetterSetter(L);
+    luaDoStringOrThrow(L, "b = c()", "vanilla property_setter setup");
+    luaDoStringOrThrow(L, "function write_setter() b.val = 24.0 end", "vanilla property_setter closure setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "write_setter");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 0, 0), "vanilla write_setter");
+    }
+}
+
+void lambda_capture_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+    double extra = kMagicValue;
+    luabridge::getGlobalNamespace(L).addFunction("f", std::function<double(double)>([extra](double v) { return v + extra; }));
+    luaDoStringOrThrow(L, "function invoke_lambda() return f(24.0) end", "vanilla lambda_capture setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "invoke_lambda");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 1, 0), "vanilla invoke_lambda");
+        lua_pop(L, 1);
+    }
+}
+
+void shared_ptr_return_measure(benchmark::State& state)
+{
+    setSkipped(state, "unsupported shared_ptr container in LuaBridge vanilla");
+}
+
+void shared_ptr_pass_measure(benchmark::State& state)
+{
+    setSkipped(state, "unsupported shared_ptr container in LuaBridge vanilla");
+}
+
+void static_member_function_call_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+    registerCounter(L);
+    luaDoStringOrThrow(L, "function invoke_static() return Counter.static_add(10, 32) end", "vanilla static_member_function setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "invoke_static");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 1, 0), "vanilla invoke_static");
+        lua_pop(L, 1);
+    }
+}
+
+void derived_method_call_measure(benchmark::State& state)
+{
+    lua_State* L = makeLua();
+
+    luabridge::getGlobalNamespace(L)
+        .beginClass<ComplexBaseA>("ComplexBaseA")
+            .addFunction("a_func", &ComplexBaseA::a_func)
+            .addProperty("a", &ComplexBaseA::a)
+        .endClass()
+        .deriveClass<ComplexAB, ComplexBaseA>("ComplexAB")
+            .addConstructor<void (*)()>()
+            .addFunction("ab_func", &ComplexAB::ab_func)
+            .addProperty("ab", &ComplexAB::ab)
+        .endClass();
+
+    luaDoStringOrThrow(L, "obj = ComplexAB()", "vanilla derived_method setup");
+    luaDoStringOrThrow(L, "function call_derived() return obj:ab_func() end", "vanilla derived_method closure setup");
+
+    for (auto _ : state)
+    {
+        (void) _;
+        lua_getglobal(L, "call_derived");
+        luaCheckOrThrow(L, lua_pcall(L, 0, 1, 0), "vanilla call_derived");
+        lua_pop(L, 1);
+    }
+}
+
 void implicit_inheritance_measure(benchmark::State& state)
 {
     setSkipped(state, "unsupported for multi inheritance in LuaBridge vanilla");
@@ -371,3 +504,11 @@ BENCHMARK(optional_success_measure)->Name("optional_success_measure");
 BENCHMARK(optional_half_failure_measure)->Name("optional_half_failure_measure");
 BENCHMARK(optional_failure_measure)->Name("optional_failure_measure");
 BENCHMARK(implicit_inheritance_measure)->Name("implicit_inheritance_measure");
+BENCHMARK(userdata_variable_write_measure)->Name("userdata_variable_write_measure");
+BENCHMARK(userdata_property_getter_measure)->Name("userdata_property_getter_measure");
+BENCHMARK(userdata_property_setter_measure)->Name("userdata_property_setter_measure");
+BENCHMARK(lambda_capture_measure)->Name("lambda_capture_measure");
+BENCHMARK(shared_ptr_return_measure)->Name("shared_ptr_return_measure");
+BENCHMARK(shared_ptr_pass_measure)->Name("shared_ptr_pass_measure");
+BENCHMARK(static_member_function_call_measure)->Name("static_member_function_call_measure");
+BENCHMARK(derived_method_call_measure)->Name("derived_method_call_measure");