Sprite loader, GeoJSON and Style are scheduler-aware

mwilsnd · Jun 24, 2024 · 0e97700 · 0e97700
1 parent a90548c
commit 0e97700
Show file tree

Hide file tree

Showing 32 changed files with 173 additions and 108 deletions.
diff --git a/include/mbgl/actor/scheduler.hpp b/include/mbgl/actor/scheduler.hpp
@@ -68,9 +68,9 @@ class Scheduler {
     /// The |TaskFn| return type must be compatible with the |ReplyFn| argument
     /// type. Note: the task result is copied and passed by value.
     template <typename TaskFn, typename ReplyFn>
-    void scheduleAndReplyValue(const TaskFn& task, const ReplyFn& reply) {
+    void scheduleAndReplyValue(const util::SimpleIdentity tag, TaskFn&& task, ReplyFn&& reply) {
         assert(GetCurrent());
-        scheduleAndReplyValue(task, reply, GetCurrent()->makeWeakPtr());
+        scheduleAndReplyValue(tag, task, reply, GetCurrent()->makeWeakPtr());
     }
 
     /// Wait until there's nothing pending or in process
@@ -104,18 +104,19 @@ class Scheduler {
 
 protected:
     template <typename TaskFn, typename ReplyFn>
-    void scheduleAndReplyValue(const TaskFn& task,
+    void scheduleAndReplyValue(const util::SimpleIdentity tag,
+                               const TaskFn& task,
                                const ReplyFn& reply,
                                mapbox::base::WeakPtr<Scheduler> replyScheduler) {
-        auto scheduled = [replyScheduler = std::move(replyScheduler), task, reply] {
+        auto scheduled = [replyScheduler = std::move(replyScheduler), tag, task, reply] {
             auto lock = replyScheduler.lock();
             if (!replyScheduler) return;
             auto scheduledReply = [reply, result = task()] {
                 reply(result);
             };
-            replyScheduler->schedule(std::move(scheduledReply));
+            replyScheduler->schedule(tag, std::move(scheduledReply));
         };
-        schedule(std::move(scheduled));
+        schedule(tag, std::move(scheduled));
     }
 
     std::function<void(const std::exception_ptr)> handler;
@@ -141,6 +142,12 @@ class TaggedScheduler {
     void runRenderJobs(bool closeQueue = false) { scheduler->runRenderJobs(tag, closeQueue); }
     void waitForEmpty() const noexcept { scheduler->waitForEmpty(tag); }
 
+    /// type. Note: the task result is copied and passed by value.
+    template <typename TaskFn, typename ReplyFn>
+    void scheduleAndReplyValue(TaskFn&& task, ReplyFn&& reply) {
+        scheduler->scheduleAndReplyValue(tag, task, reply);
+    }
+
     const mbgl::util::SimpleIdentity tag;
 
 private:

diff --git a/include/mbgl/renderer/renderer_frontend.hpp b/include/mbgl/renderer/renderer_frontend.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/gfx/drawable.hpp>
 #endif
 
+#include <mbgl/actor/scheduler.hpp>
 #include <memory>
 
 namespace mbgl {
@@ -30,6 +31,8 @@ class RendererFrontend {
     /// Coalescing updates is up to the implementer
     virtual void update(std::shared_ptr<UpdateParameters>) = 0;
 
+    virtual const TaggedScheduler& getThreadPool() const = 0;
+
 protected:
 };
 

diff --git a/include/mbgl/style/sources/geojson_source.hpp b/include/mbgl/style/sources/geojson_source.hpp
@@ -41,7 +41,7 @@ class GeoJSONData {
     using TileFeatures = mapbox::feature::feature_collection<int16_t>;
     using Features = mapbox::feature::feature_collection<double>;
     static std::shared_ptr<GeoJSONData> create(const GeoJSON&,
-                                               std::shared_ptr<Scheduler> scheduler,
+                                               std::shared_ptr<Scheduler> sequencedScheduler,
                                                const Immutable<GeoJSONOptions>& = GeoJSONOptions::defaultOptions());
 
     virtual ~GeoJSONData() = default;

diff --git a/include/mbgl/style/style.hpp b/include/mbgl/style/style.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/map/camera.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/style/transition_options.hpp>
@@ -22,7 +23,7 @@ class Layer;
 
 class Style {
 public:
-    Style(std::shared_ptr<FileSource>, float pixelRatio);
+    Style(std::shared_ptr<FileSource>, float pixelRatio, const TaggedScheduler& threadPool_);
     ~Style();
 
     void loadJSON(const std::string&);

diff --git a/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp b/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.cpp
@@ -82,6 +82,10 @@ void AndroidRendererFrontend::update(std::shared_ptr<UpdateParameters> params) {
     updateAsyncTask->send();
 }
 
+const TaggedScheduler& AndroidRendererFrontend::getThreadPool() const {
+    return mapRenderer.getRendererBackend().getThreadPool();
+}
+
 void AndroidRendererFrontend::reduceMemoryUse() {
     mapRenderer.actor().invoke(&Renderer::reduceMemoryUse);
 }

diff --git a/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.hpp b/platform/android/MapLibreAndroid/src/cpp/android_renderer_frontend.hpp
@@ -37,6 +37,8 @@ class AndroidRendererFrontend : public RendererFrontend {
 
     void update(std::shared_ptr<UpdateParameters>) override;
 
+    const TaggedScheduler& getThreadPool() const override;
+
     // Feature querying
     std::vector<Feature> queryRenderedFeatures(const ScreenCoordinate&, const RenderedQueryOptions&) const;
     std::vector<Feature> queryRenderedFeatures(const ScreenBox&, const RenderedQueryOptions&) const;

diff --git a/platform/android/MapLibreAndroid/src/cpp/map_renderer.hpp b/platform/android/MapLibreAndroid/src/cpp/map_renderer.hpp
@@ -80,6 +80,8 @@ class MapRenderer : public Scheduler {
     using SnapshotCallback = std::function<void(PremultipliedImage)>;
     void requestSnapshot(SnapshotCallback);
 
+    AndroidRendererBackend& getRendererBackend() const { return *backend; }
+
 protected:
     // Called from the GL Thread //
 

diff --git a/platform/darwin/src/MLNRendererFrontend.h b/platform/darwin/src/MLNRendererFrontend.h
@@ -1,3 +1,4 @@
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/gfx/renderer_backend.hpp>
 #include <mbgl/renderer/renderer.hpp>
@@ -33,6 +34,10 @@ class MLNRenderFrontend : public mbgl::RendererFrontend {
     }
   }
 
+  const TaggedScheduler& getThreadPool() const override {
+    return mbglBackend.getThreadPool();
+  }
+
   void setObserver(mbgl::RendererObserver& observer) override {
     if (!renderer) return;
     renderer->setObserver(&observer);

diff --git a/platform/default/include/mbgl/gfx/headless_frontend.hpp b/platform/default/include/mbgl/gfx/headless_frontend.hpp
@@ -37,6 +37,7 @@ class HeadlessFrontend : public RendererFrontend {
 
     void reset() override;
     void update(std::shared_ptr<UpdateParameters>) override;
+    const TaggedScheduler& getThreadPool() const override;
     void setObserver(RendererObserver&) override;
 
     double getFrameTime() const;

diff --git a/platform/default/src/mbgl/gfx/headless_frontend.cpp b/platform/default/src/mbgl/gfx/headless_frontend.cpp
@@ -48,6 +48,10 @@ void HeadlessFrontend::update(std::shared_ptr<UpdateParameters> updateParameters
     }
 }
 
+const TaggedScheduler& HeadlessFrontend::getThreadPool() const {
+    return backend->getRendererBackend()->getThreadPool();
+}
+
 void HeadlessFrontend::setObserver(RendererObserver& observer_) {
     assert(renderer);
     renderer->setObserver(&observer_);

diff --git a/platform/default/src/mbgl/map/map_snapshotter.cpp b/platform/default/src/mbgl/map/map_snapshotter.cpp
@@ -118,6 +118,10 @@ class SnapshotterRenderer final : public RendererObserver {
         return std::move(stillImage);
     }
 
+    const TaggedScheduler& getThreadPool() const {
+        return frontend.getThreadPool();
+    }
+
 private:
     PremultipliedImage stillImage;
     bool hasPendingStillImageRequest = false;
@@ -156,6 +160,10 @@ class SnapshotterRendererFrontend final : public RendererFrontend {
 
     PremultipliedImage takeImage() { return renderer->actor().ask(&SnapshotterRenderer::takeImage).get(); }
 
+    const mbgl::TaggedScheduler& getThreadPool() const override {
+        return renderer->actor().ask(&SnapshotterRenderer::getThreadPool).get();
+    }
+
 private:
     std::shared_ptr<UpdateParameters> updateParameters;
     const std::unique_ptr<util::Thread<SnapshotterRenderer>> renderer;

diff --git a/platform/glfw/glfw_renderer_frontend.cpp b/platform/glfw/glfw_renderer_frontend.cpp
@@ -27,6 +27,10 @@ void GLFWRendererFrontend::update(std::shared_ptr<mbgl::UpdateParameters> params
     glfwView.invalidate();
 }
 
+const TaggedScheduler& GLFWRendererFrontend::getThreadPool() const {
+    return glfwView.getRendererBackend().getThreadPool();
+}
+
 void GLFWRendererFrontend::render() {
     MLN_TRACE_FUNC();
 

diff --git a/platform/glfw/glfw_renderer_frontend.hpp b/platform/glfw/glfw_renderer_frontend.hpp
@@ -18,6 +18,7 @@ class GLFWRendererFrontend : public mbgl::RendererFrontend {
     void setObserver(mbgl::RendererObserver&) override;
 
     void update(std::shared_ptr<mbgl::UpdateParameters>) override;
+    const TaggedScheduler& getThreadPool() const override;
     void render();
 
     mbgl::Renderer* getRenderer();

diff --git a/src/mbgl/map/map_impl.cpp b/src/mbgl/map/map_impl.cpp
@@ -52,7 +52,7 @@ Map::Impl::Impl(RendererFrontend& frontend_,
       pixelRatio(mapOptions.pixelRatio()),
       crossSourceCollisions(mapOptions.crossSourceCollisions()),
       fileSource(std::move(fileSource_)),
-      style(std::make_unique<style::Style>(fileSource, pixelRatio)),
+      style(std::make_unique<style::Style>(fileSource, pixelRatio, frontend_.getThreadPool())),
       annotationManager(*style) {
     transform.setNorthOrientation(mapOptions.northOrientation());
     style->impl->setObserver(this);

diff --git a/src/mbgl/sprite/sprite_loader.cpp b/src/mbgl/sprite/sprite_loader.cpp
@@ -26,10 +26,10 @@ struct SpriteLoader::Data {
     std::unique_ptr<AsyncRequest> spriteRequest;
 };
 
-SpriteLoader::SpriteLoader(float pixelRatio_)
+SpriteLoader::SpriteLoader(float pixelRatio_, const TaggedScheduler& threadPool_)
     : pixelRatio(pixelRatio_),
       observer(&nullObserver),
-      threadPool(Scheduler::GetBackground()) {}
+      threadPool(threadPool_) {}
 
 SpriteLoader::~SpriteLoader() = default;
 
@@ -93,25 +93,26 @@ void SpriteLoader::emitSpriteLoadedIfComplete(style::Sprite sprite) {
         std::exception_ptr error;
     };
 
-    auto parseClosure = [sprite = sprite, image = data->image, json = data->json]() -> ParseResult {
-        try {
-            return {parseSprite(sprite.id, *image, *json), nullptr};
-        } catch (...) {
-            return {{}, std::current_exception()};
-        }
-    };
-
-    auto resultClosure = [this, sprite = sprite, weak = weakFactory.makeWeakPtr()](ParseResult result) {
-        if (!weak) return; // This instance has been deleted.
+    threadPool.scheduleAndReplyValue(
+        /* parseClosure */
+        [sprite = sprite, image = data->image, json = data->json]() -> ParseResult {
+            try {
+                return {parseSprite(sprite.id, *image, *json), nullptr};
+            } catch (...) {
+                return {{}, std::current_exception()};
+            }
+        },
+        /* resultClosure */
+        [this, sprite = sprite, weak = weakFactory.makeWeakPtr()](ParseResult result) {
+            if (!weak) return; // This instance has been deleted.
 
-        if (result.error) {
-            observer->onSpriteError(std::optional(sprite), result.error);
-            return;
-        }
-        observer->onSpriteLoaded(std::optional(sprite), std::move(result.images));
-    };
+            if (result.error) {
+                observer->onSpriteError(std::optional(sprite), result.error);
+                return;
+            }
+            observer->onSpriteLoaded(std::optional(sprite), std::move(result.images));
+        });
 
-    threadPool->scheduleAndReplyValue(parseClosure, resultClosure);
 }
 
 void SpriteLoader::setObserver(SpriteLoaderObserver* observer_) {

diff --git a/src/mbgl/sprite/sprite_loader.hpp b/src/mbgl/sprite/sprite_loader.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/style/image.hpp>
 #include <mbgl/style/sprite.hpp>
 #include <mapbox/std/weak.hpp>
@@ -15,11 +16,10 @@ namespace mbgl {
 
 class FileSource;
 class SpriteLoaderObserver;
-class Scheduler;
 
 class SpriteLoader {
 public:
-    SpriteLoader(float pixelRatio);
+    SpriteLoader(float pixelRatio, const TaggedScheduler& threadPool_);
     ~SpriteLoader();
 
     void load(const std::optional<style::Sprite> sprite, FileSource&);
@@ -39,7 +39,7 @@ class SpriteLoader {
     std::mutex dataMapMutex;
 
     SpriteLoaderObserver* observer = nullptr;
-    std::shared_ptr<Scheduler> threadPool;
+    TaggedScheduler threadPool;
     mapbox::base::WeakPtrFactory<SpriteLoader> weakFactory{this};
     // Do not add members here, see `WeakPtrFactory`
 };

diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp
@@ -9,6 +9,7 @@
 #include <mbgl/util/async_request.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/thread_pool.hpp>
+#include <mbgl/util/identity.hpp>
 
 namespace mbgl {
 namespace style {
@@ -21,7 +22,6 @@ Immutable<GeoJSONOptions> GeoJSONOptions::defaultOptions() {
 
 GeoJSONSource::GeoJSONSource(std::string id, Immutable<GeoJSONOptions> options)
     : Source(makeMutable<Impl>(std::move(id), std::move(options))),
-      threadPool(Scheduler::GetBackground()),
       sequencedScheduler(Scheduler::GetSequenced()) {}
 
 GeoJSONSource::~GeoJSONSource() = default;
@@ -102,7 +102,7 @@ void GeoJSONSource::loadDescription(FileSource& fileSource) {
                 loaded = true;
                 observer->onSourceLoaded(*this);
             };
-            threadPool->scheduleAndReplyValue(makeImplInBackground, onImplReady);
+            threadPool->scheduleAndReplyValue(util::SimpleIdentity::Empty, makeImplInBackground, onImplReady);
         }
     });
 }

diff --git a/src/mbgl/style/sources/geojson_source_impl.cpp b/src/mbgl/style/sources/geojson_source_impl.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/util/feature.hpp>
 #include <mbgl/util/string.hpp>
 #include <mbgl/util/thread_pool.hpp>
+#include <mbgl/util/identity.hpp>
 
 #ifdef _MSC_VER
 #pragma warning(push)
@@ -25,7 +26,8 @@ namespace style {
 class GeoJSONVTData final : public GeoJSONData {
     void getTile(const CanonicalTileID& id, const std::function<void(TileFeatures)>& fn) final {
         assert(fn);
-        scheduler->scheduleAndReplyValue(
+        sequencedScheduler->scheduleAndReplyValue(
+            util::SimpleIdentity::Empty,
             [id, geoJSONVT_impl = this->impl]() -> TileFeatures {
                 return geoJSONVT_impl->getTile(id.z, id.x, id.y).features;
             },
@@ -41,14 +43,14 @@ class GeoJSONVTData final : public GeoJSONData {
     friend GeoJSONData;
     GeoJSONVTData(const GeoJSON& geoJSON,
                   const mapbox::geojsonvt::Options& options,
-                  std::shared_ptr<Scheduler> scheduler_)
+                  std::shared_ptr<Scheduler> sequencedScheduler_)
         : impl(std::make_shared<mapbox::geojsonvt::GeoJSONVT>(geoJSON, options)),
-          scheduler(std::move(scheduler_)) {
-        assert(scheduler);
+          sequencedScheduler(std::move(sequencedScheduler_)) {
+        assert(sequencedScheduler);
     }
 
     std::shared_ptr<mapbox::geojsonvt::GeoJSONVT> impl; // Accessed on worker thread.
-    std::shared_ptr<Scheduler> scheduler;
+    std::shared_ptr<Scheduler> sequencedScheduler;
 };
 
 class SuperclusterData final : public GeoJSONData {
@@ -89,7 +91,7 @@ T evaluateFeature(const mapbox::feature::feature<double>& f,
 
 // static
 std::shared_ptr<GeoJSONData> GeoJSONData::create(const GeoJSON& geoJSON,
-                                                 std::shared_ptr<Scheduler> scheduler,
+                                                 std::shared_ptr<Scheduler> sequencedScheduler,
                                                  const Immutable<GeoJSONOptions>& options) {
     constexpr double scale = util::EXTENT / util::tileSize_D;
     if (options->cluster && geoJSON.is<Features>() && !geoJSON.get<Features>().empty()) {
@@ -126,7 +128,7 @@ std::shared_ptr<GeoJSONData> GeoJSONData::create(const GeoJSON& geoJSON,
     vtOptions.buffer = static_cast<uint16_t>(::round(scale * options->buffer));
     vtOptions.tolerance = scale * options->tolerance;
     vtOptions.lineMetrics = options->lineMetrics;
-    return std::shared_ptr<GeoJSONData>(new GeoJSONVTData(geoJSON, vtOptions, std::move(scheduler)));
+    return std::shared_ptr<GeoJSONData>(new GeoJSONVTData(geoJSON, vtOptions, std::move(sequencedScheduler)));
 }
 
 GeoJSONSource::Impl::Impl(std::string id_, Immutable<GeoJSONOptions> options_)

diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
@@ -10,8 +10,8 @@
 namespace mbgl {
 namespace style {
 
-Style::Style(std::shared_ptr<FileSource> fileSource, float pixelRatio)
-    : impl(std::make_unique<Impl>(std::move(fileSource), pixelRatio)) {}
+Style::Style(std::shared_ptr<FileSource> fileSource, float pixelRatio, const TaggedScheduler& threadPool_)
+    : impl(std::make_unique<Impl>(std::move(fileSource), pixelRatio, threadPool_)) {}
 
 Style::~Style() = default;
 

diff --git a/src/mbgl/style/style_impl.cpp b/src/mbgl/style/style_impl.cpp
@@ -30,9 +30,9 @@ namespace style {
 
 static Observer nullObserver;
 
-Style::Impl::Impl(std::shared_ptr<FileSource> fileSource_, float pixelRatio)
+Style::Impl::Impl(std::shared_ptr<FileSource> fileSource_, float pixelRatio, const TaggedScheduler& threadPool_)
     : fileSource(std::move(fileSource_)),
-      spriteLoader(std::make_unique<SpriteLoader>(pixelRatio)),
+      spriteLoader(std::make_unique<SpriteLoader>(pixelRatio, threadPool_)),
       light(std::make_unique<Light>()),
       observer(&nullObserver) {
     spriteLoader->setObserver(this);