[wip] Duktape optimization

bench/src/benchStyleContext.cpp

@@ -7,6 +7,7 @@
 #include "mockPlatform.h"
 #include "log.h"
 #include "data/tileSource.h"
+#include "scene/filters.h"
 #include "scene/importer.h"
 #include "scene/scene.h"
 #include "scene/dataLayer.h"
@@ -19,14 +20,54 @@
 
 #include <functional>
 
+#define NUM_ITERATIONS 0
+
+#if NUM_ITERATIONS
+#define ITERATIONS ->Iterations(NUM_ITERATIONS)
+#else
+#define ITERATIONS
+#endif
+
 #define RUN(FIXTURE, NAME)                                              \
     BENCHMARK_DEFINE_F(FIXTURE, NAME)(benchmark::State& st) { while (st.KeepRunning()) { run(); } } \
-    BENCHMARK_REGISTER_F(FIXTURE, NAME); //->Iterations(10000);
+    BENCHMARK_REGISTER_F(FIXTURE, NAME) ITERATIONS;
 
 using namespace Tangram;
 
-//const char scene_file[] = "bubble-wrap-style.zip";
-const char scene_file[] = "res/scene.yaml";
+template<class Context>
+class GetPropertyFixtureFixture : public benchmark::Fixture {
+public:
+    Context ctx;
+    Feature feature;
+    void SetUp(const ::benchmark::State& state) override {
+        JavaScriptScope<Context> jsScope(ctx);
+        ctx.setGlobalValue("language", jsScope.newString("en"));
+        feature.props.set("name:en", "Ozymandias");
+        feature.props.set("title", "King of Kings");
+        feature.props.set("number", 17);
+        ctx.setCurrentFeature(&feature);
+        ctx.setFunction(0, "function () { return (language && feature['name:' + language]) || title; }");
+        ctx.setFunction(1, "function () { return feature.order || feature.number; }");
+    }
+    __attribute__ ((noinline)) void run() {
+        StyleParam::Value value;
+        benchmark::DoNotOptimize(value);
+        JavaScriptScope<Context> jsScope(ctx);
+        value = jsScope.getFunctionResult(0).toString();
+        value = (float)jsScope.getFunctionResult(1).toDouble();
+     }
+};
+
+#ifdef TANGRAM_USE_JSCORE
+using JSCoreGetPropertyFixture = GetPropertyFixtureFixture<JSCore::Context>;
+RUN(JSCoreGetPropertyFixture, JSCoreGetPropertyBench)
+#endif
+
+using DuktapeGetPropertyFixture = GetPropertyFixtureFixture<Duktape::Context>;
+RUN(DuktapeGetPropertyFixture, DuktapeGetPropertyBench)
+
+const char scene_file[] = "bubble-wrap-style.zip";
+//const char scene_file[] = "res/scene.yaml";
 const char tile_file[] = "res/tile.mvt";
 
 std::shared_ptr<Scene> scene;
@@ -72,95 +113,91 @@ void globalSetup() {
     }
 }
 
+__attribute__ ((noinline))
+void filter(StyleContext& ctx, const SceneLayer& layer, const Feature& feature) {
+    StyleParam::Value styleValue;
+    benchmark::DoNotOptimize(styleValue);
+
+    if (layer.filter().eval(feature, ctx)) {
+        for (auto& r : layer.rules()) {
+            for (auto& sp : r.parameters) {
+                if (sp.function >= 0) {
+                    //evalCnt++;
+                    ctx.evalStyle(sp.function, sp.key, styleValue);
+                }
+            }
+        }
+        for (const auto& sublayer : layer.sublayers()) {
+            filter(ctx, sublayer, feature);
+        }
+    }
+}
 
-template<class Context>
-class JSGetPropertyFixture : public benchmark::Fixture {
-public:
-    Context ctx;
-    Feature feature;
+void applyStyling(StyleContext& ctx) {
+    for (const auto& datalayer : scene->layers()) {
+        for (const auto& collection : tileData->layers) {
+            if (!collection.name.empty()) {
+                const auto& dlc = datalayer.collections();
+                bool layerContainsCollection =
+                    std::find(dlc.begin(), dlc.end(), collection.name) != dlc.end();
+
+                if (!layerContainsCollection) { continue; }
+            }
+
+            for (const auto& feature : collection.features) {
+                ctx.setFeature(feature);
+                filter(ctx, datalayer, feature);
+            }
+        }
+    }
+}
+
+template<size_t jsCore>
+struct JSTileStyleFnFixture : public benchmark::Fixture {
+    std::unique_ptr<StyleContext> ctx;
     void SetUp(const ::benchmark::State& state) override {
-        JavaScriptScope<Context> jsScope(ctx);
-        ctx.setGlobalValue("language", jsScope.newString("en"));
-        feature.props.set("name:en", "Ozymandias");
-        feature.props.set("title", "King of Kings");
-        feature.props.set("number", 17);
-        ctx.setCurrentFeature(&feature);
-        ctx.setFunction(0, "function () { return (language && feature['name:' + language]) || title; }");
-        ctx.setFunction(1, "function () { return feature.order || feature.number; }");
+        globalSetup();
+        ctx.reset(new StyleContext(jsCore));
+        ctx->initScene(*scene);
+        ctx->setFilterKey(Filter::Key::zoom, 10);
     }
     __attribute__ ((noinline)) void run() {
-        StyleParam::Value value;
-        benchmark::DoNotOptimize(value);
-        JavaScriptScope<Context> jsScope(ctx);
-        value = jsScope.getFunctionResult(0).toString();
-        value = (float)jsScope.getFunctionResult(1).toDouble();
-     }
+        applyStyling(*ctx);
+    }
 };
 
 #ifdef TANGRAM_USE_JSCORE
-using JSCoreGetPropertyFixture = JSGetPropertyFixture<JSCoreContext>;
-RUN(JSCoreGetPropertyFixture, JSCoreGetPropertyBench)
-#else
-using DuktapeGetPropertyFixture = JSGetPropertyFixture<DuktapeContext>;
-RUN(DuktapeGetPropertyFixture, DuktapeGetPropertyBench)
+using JSCoreTileStyleFnFixture = JSTileStyleFnFixture<1>;
+RUN(JSCoreTileStyleFnFixture, JSCoreTileStyleFnBench)
 #endif
+using DuktapeTileStyleFnFixture = JSTileStyleFnFixture<0>;
+RUN(DuktapeTileStyleFnFixture, DuktapeTileStyleFnBench)
 
-struct JSTileStyleFnFixture : public benchmark::Fixture {
-    StyleContext ctx;
-    Feature feature;
-    uint32_t numFunctions = 0;
-    uint32_t evalCnt = 0;
 
+template<size_t jsCore>
+struct JSTileStyleFnReplayFixture : public benchmark::Fixture {
+    std::unique_ptr<StyleContext> ctx;
     void SetUp(const ::benchmark::State& state) override {
         globalSetup();
-        ctx.initFunctions(*scene);
-        ctx.setKeywordZoom(10);
-    }
-    void TearDown(const ::benchmark::State& state) override {
-        LOG(">>> %d", evalCnt);
+        ctx.reset(new StyleContext(jsCore, true));
+        ctx->initScene(*scene);
+        ctx->setFilterKey(Filter::Key::zoom, 10);
+        applyStyling(*ctx);
+        ctx->impl->recorderLog();
     }
     __attribute__ ((noinline)) void run() {
-        StyleParam::Value styleValue;
-        benchmark::DoNotOptimize(styleValue);
-
-        for (const auto& datalayer : scene->layers()) {
-            for (const auto& collection : tileData->layers) {
-                if (!collection.name.empty()) {
-                    const auto& dlc = datalayer.collections();
-                    bool layerContainsCollection =
-                        std::find(dlc.begin(), dlc.end(), collection.name) != dlc.end();
-
-                    if (!layerContainsCollection) { continue; }
-                }
-
-                for (const auto& feat : collection.features) {
-                    ctx.setFeature(feat);
-
-                    std::function<void(const SceneLayer& layer)> filter;
-                    filter = [&](const auto& layer) {
-                        if (layer.filter().eval(feature, ctx)) {
-                            for (auto& r : layer.rules()) {
-                                for (auto& sp : r.parameters) {
-                                    if (sp.function >= 0) {
-                                        evalCnt++;
-                                        ctx.evalStyle(sp.function, sp.key, styleValue);
-                                    }
-                                }
-                            }
-
-                            for (const auto& sublayer : layer.sublayers()) {
-                                filter(sublayer);
-                            }
-                        }
-                    };
-                    filter(datalayer);
-                }
-            }
-        }
+        ctx->impl->replayFilters();
+        ctx->impl->replayStyles();
     }
 };
 
-RUN(JSTileStyleFnFixture, TileStyleFnBench);
+#ifdef TANGRAM_USE_JSCORE
+using JSCoreTileStyleFnReplayFixture = JSTileStyleFnReplayFixture<1>;
+RUN(JSCoreTileStyleFnReplayFixture, JSCoreTileStyleFnReplayBench)
+#endif
+using DuktapeTileStyleFnReplayFixture = JSTileStyleFnReplayFixture<0>;
+RUN(DuktapeTileStyleFnReplayFixture, DuktapeTileStyleFnReplayBench)
+
 
 class DirectGetPropertyFixture : public benchmark::Fixture {
 public:
@@ -182,6 +219,6 @@ BENCHMARK_DEFINE_F(DirectGetPropertyFixture, DirectGetPropertyBench)(benchmark::
         }
     }
 }
-BENCHMARK_REGISTER_F(DirectGetPropertyFixture, DirectGetPropertyBench);
+BENCHMARK_REGISTER_F(DirectGetPropertyFixture, DirectGetPropertyBench) ITERATIONS;
 
 BENCHMARK_MAIN();

bench/src/benchTileBuilder.cpp

@@ -18,26 +18,34 @@
 #include <iostream>
 #include <vector>
 
+#define NUM_ITERATIONS 0
+
+#if NUM_ITERATIONS
+#define ITERATIONS ->Iterations(NUM_ITERATIONS)
+#else
+#define ITERATIONS
+#endif
 
 #define RUN(FIXTURE, NAME)                                              \
     BENCHMARK_DEFINE_F(FIXTURE, NAME)(benchmark::State& st) { while (st.KeepRunning()) { run(); } } \
-    BENCHMARK_REGISTER_F(FIXTURE, NAME);  //->Iterations(1)
+    BENCHMARK_REGISTER_F(FIXTURE, NAME)ITERATIONS;
 
 using namespace Tangram;
 
-//const char scene_file[] = "bubble-wrap-style.zip";
-const char scene_file[] = "res/scene.yaml";
+const char scene_file[] = "bubble-wrap-style.zip";
+//const char scene_file[] = "res/scene.yaml";
 const char tile_file[] = "res/tile.mvt";
 
 std::shared_ptr<Scene> scene;
 std::shared_ptr<TileSource> source;
 std::shared_ptr<TileData> tileData;
+std::shared_ptr<MockPlatform> platform;
 
 void globalSetup() {
-    static std::atomic<bool> initialized{false};
-    if (initialized.exchange(true)) { return; }
+    static bool initialized = false;
+    if (initialized) { return; }
 
-    std::shared_ptr<MockPlatform> platform = std::make_shared<MockPlatform>();
+    platform = std::make_shared<MockPlatform>();
 
     Url sceneUrl(scene_file);
     platform->putMockUrlContents(sceneUrl, MockPlatform::getBytesFromFile(scene_file));
@@ -74,27 +82,35 @@ void globalSetup() {
         LOGE("Invalid tile file '%s'", tile_file);
         exit(-1);
     }
+    initialized = true;
 }
 
+template<size_t jscontext>
 class TileBuilderFixture : public benchmark::Fixture {
 public:
     std::unique_ptr<TileBuilder> tileBuilder;
+    StyleContext* styleContext;
     std::shared_ptr<Tile> result;
     void SetUp(const ::benchmark::State& state) override {
         globalSetup();
-        tileBuilder = std::make_unique<TileBuilder>(scene, new StyleContext());
+        styleContext = new StyleContext(jscontext);
+        tileBuilder = std::make_unique<TileBuilder>(scene, styleContext);
     }
     void TearDown(const ::benchmark::State& state) override {
         result.reset();
     }
 
     __attribute__ ((noinline)) void run() {
         result = tileBuilder->build({0,0,10,10}, *tileData, *source);
+        styleContext->clear();
     }
 };
 
-RUN(TileBuilderFixture, TileBuilderBench);
+using DUKTileBuilderFixture = TileBuilderFixture<0>;
+using JSCTileBuilderFixture = TileBuilderFixture<1>;
 
+RUN(DUKTileBuilderFixture, DUKTileBuilderBench)
+RUN(JSCTileBuilderFixture, JSCTileBuilderBench)
 
 
 BENCHMARK_MAIN();

core/CMakeLists.txt

@@ -138,18 +138,18 @@ target_link_libraries(tangram-core
 
 # Add JavaScript implementation.
 if(TANGRAM_JSCORE_ENABLED)
-  target_sources(tangram-core PRIVATE src/js/JSCoreContext.cpp)
   if (TANGRAM_USE_JSCORE_STATIC)
-    target_link_libraries(tangram-core PRIVATE jscore-static)
+    # target_link_libraries(tangram-core PRIVATE jscore-static)
+    pkg_check_modules(JSCORE REQUIRED IMPORTED_TARGET javascriptcoregtk-4.0)
+    target_link_libraries(tangram-core PRIVATE PkgConfig::JSCORE)
   else()
     target_link_libraries(tangram-core PRIVATE "-framework JavaScriptCore")
   endif()
   target_compile_definitions(tangram-core PRIVATE TANGRAM_USE_JSCORE=1)
-else()
-  target_sources(tangram-core PRIVATE src/js/DuktapeContext.cpp)
-  target_link_libraries(tangram-core PRIVATE duktape)
 endif()
 
+target_link_libraries(tangram-core PRIVATE duktape)
+
 # Add MBTiles implementation.
 if(TANGRAM_MBTILES_DATASOURCE)
   target_sources(tangram-core PRIVATE src/data/mbtilesDataSource.cpp)

core/deps/duktape/CMakeLists.txt

@@ -1,9 +1,11 @@
-add_library(duktape duktape.c)
+add_library(duktape duktape.c extstr.c)
 
 target_compile_options(duktape PRIVATE
   -fstrict-aliasing
   -fomit-frame-pointer
   -std=c99
   -Wall)
 
-target_include_directories(duktape PUBLIC .)
+target_include_directories(duktape
+  PUBLIC
+  ${CMAKE_CURRENT_SOURCE_DIR})