Add a more concrete realworld benchmark with GameObject/Transform/Vector3 position/rotation object hierarchy with shared_ptrs and benchmark moving objects from JS side using embind.

2 files changed, 125 insertions, 0 deletions

diff --git a/tests/embind/embind.benchmark.js b/tests/embind/embind.benchmark.js
index de1cdd2c..959358b6 100644
--- a/tests/embind/embind.benchmark.js
+++ b/tests/embind/embind.benchmark.js
@@ -171,3 +171,31 @@ function _sum_float_benchmark_embind_js() {
     var b = _emscripten_get_now();
     Module.print("JS embind sum_float 100000 iters: " + (b-a)*1000 + " msecs. result: " + r);
 }
+
+function _move_gameobjects_benchmark_embind_js() {
+    var N = 100000;
+    var objects = [];
+    for(i = 0; i < N; ++i) {
+        objects.push(Module['create_game_object']());
+    }
+    
+    var a = _emscripten_get_now();
+    for(i = 0; i < N; ++i) {
+        var t = objects[i].GetTransform();
+        var pos = Module.add(t.GetPosition(), [2, 0, 1]);
+        var rot = Module.add(t.GetRotation(), [0.1, 0.2, 0.3]);
+        t.SetPosition(pos);
+        t.SetRotation(rot);
+        t.delete();
+    }
+    var b = _emscripten_get_now();
+    
+    var accum = [0,0,0];
+    for(i = 0; i < N; ++i) {
+        var t = objects[i].GetTransform();
+        accum = Module.add(Module.add(accum, t.GetPosition()), t.GetRotation());
+        t.delete();
+    }
+    
+    Module.print("JS embind move_gameobjects " + N + " iters: " + 1000*(b-a) + " msecs. Result: " + (accum[0] + accum[1] + accum[2]));
+}
diff --git a/tests/embind/embind_benchmark.cpp b/tests/embind/embind_benchmark.cpp
index 6bf71d56..91efa4af 100644
--- a/tests/embind/embind_benchmark.cpp
+++ b/tests/embind/embind_benchmark.cpp
@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <emscripten.h>
 #include <bind.h>
+#include <memory>
 
 int counter = 0;
 
@@ -43,6 +44,54 @@ extern void sum_int_benchmark_embind_js();
 extern void sum_float_benchmark_embind_js();
 
 extern void increment_class_counter_benchmark_embind_js(int N);
+extern void move_gameobjects_benchmark_embind_js();
+}
+
+class Vec3
+{
+public:
+    Vec3():x(0),y(0),z(0) {}
+    Vec3(float x_, float y_, float z_):x(x_),y(y_),z(z_) {}
+    float x,y,z;
+};
+
+Vec3 add(const Vec3 &lhs, const Vec3 &rhs) { return Vec3(lhs.x+rhs.x, lhs.y+rhs.y, lhs.z+rhs.z); }
+
+class Transform
+{
+public:
+    Transform():scale(1) {}
+
+    Vec3 pos;
+    Vec3 rot;
+    float scale;
+
+    Vec3 GetPosition() { return pos; }
+    Vec3 GetRotation() { return rot; }
+    float GetScale() { return scale; }
+    
+    void SetPosition(const Vec3 &pos_) { pos = pos_; }
+    void SetRotation(const Vec3 &rot_) { rot = rot_; }
+    void SetScale(float scale_) { scale = scale_; }
+};
+typedef std::shared_ptr<Transform> TransformPtr;
+
+class GameObject
+{
+public:
+    GameObject()
+    {
+        transform = std::make_shared<Transform>();
+    }
+    std::shared_ptr<Transform> transform;
+    
+    TransformPtr GetTransform() { return transform; }
+};
+typedef std::shared_ptr<GameObject> GameObjectPtr;
+
+GameObjectPtr create_game_object()
+{
+    return std::make_shared<GameObject>();
 }
 
 class Foo
@@ -75,6 +124,27 @@ EMSCRIPTEN_BINDINGS(benchmark)
 {
     using namespace emscripten;
     
+    class_<GameObject>("GameObject")
+        .smart_ptr<GameObjectPtr>()
+        .function("GetTransform", &GameObject::GetTransform);
+        
+    class_<Transform>("Transform")
+        .smart_ptr<TransformPtr>()
+        .function("GetPosition", &Transform::GetPosition)
+        .function("GetRotation", &Transform::GetRotation)
+        .function("GetScale", &Transform::GetScale)
+        .function("SetPosition", &Transform::SetPosition)
+        .function("SetRotation", &Transform::SetRotation)
+        .function("SetScale", &Transform::SetScale);
+        
+    value_tuple<Vec3>("Vec3")
+        .element(&Vec3::x)
+        .element(&Vec3::y)
+        .element(&Vec3::z);
+        
+    function("create_game_object", &create_game_object);
+    function("add", &add);
+    
     function("get_counter", &get_counter);
     function("increment_counter", &increment_counter);
     function("returns_input", &returns_input);
@@ -212,6 +282,30 @@ void __attribute__((noinline)) sum_float_benchmark()
     printf("C++ sum_float 100000 iters: %f msecs.\n", 1000.f*(t2-t));
 }
 
+void __attribute__((noinline)) move_gameobjects_benchmark()
+{
+    const int N = 100000;
+    GameObjectPtr objects[N];
+    for(int i = 0; i < N; ++i)
+        objects[i] = create_game_object();
+    
+    volatile float t = emscripten_get_now();
+    for(int i = 0; i < N; ++i)
+    {
+        TransformPtr t = objects[i]->GetTransform();
+        Vec3 pos = add(t->GetPosition(), Vec3(2.f, 0.f, 1.f));
+        Vec3 rot = add(t->GetRotation(), Vec3(0.1f, 0.2f, 0.3f));
+        t->SetPosition(pos);
+        t->SetRotation(rot);
+    }
+    volatile float t2 = emscripten_get_now();
+
+    Vec3 accum;
+    for(int i = 0; i < N; ++i)
+        accum = add(add(accum, objects[i]->GetTransform()->GetPosition()), objects[i]->GetTransform()->GetRotation());
+    printf("C++ move_gameobjects %d iters: %f msecs. Result: %f\n", N, 1000.f*(t2-t), accum.x+accum.y+accum.z);
+}
+
 int main()
 {
     for(int i = 1000; i <= 100000; i *= 10)
@@ -244,4 +338,7 @@ int main()
     sum_float_benchmark();
     sum_float_benchmark_js();
     sum_float_benchmark_embind_js();
+    printf("\n");
+    move_gameobjects_benchmark();
+    move_gameobjects_benchmark_embind_js();
 }