wip

include/mbgl/actor/actor.hpp

@@ -14,6 +14,8 @@
 
 namespace mbgl {
 
+class TaggedScheduler;
+
 /**
     An `Actor<O>` is an owning reference to an asynchronous object of type `O`:
    an "actor". Communication with an actor happens via message passing: you send
@@ -66,11 +68,20 @@ class Actor {
         : retainer(std::move(scheduler)),
           target(*retainer, parent, std::forward<Args>(args)...) {}
 
+    template <class... Args>
+    Actor(TaggedScheduler& scheduler, Args&&... args)
+        : schedulerTag(scheduler.tag()),
+          retainer(scheduler.get()),
+          target(*retainer, parent, std::forward<Args>(args)...) {}
+
+
+
     Actor(const Actor&) = delete;
 
     ActorRef<std::decay_t<Object>> self() { return parent.self(); }
 
 private:
+    const void* schedulerTag = nullptr;
     const std::shared_ptr<Scheduler> retainer;
     AspiringActor<Object> parent;
     EstablishedActor<Object> target;

include/mbgl/actor/scheduler.hpp

@@ -43,10 +43,11 @@ class Scheduler {
 
     /// Makes a weak pointer to this Scheduler.
     virtual mapbox::base::WeakPtr<Scheduler> makeWeakPtr() = 0;
-    /// Enqueues a function for execution on the render thread.
-    virtual void runOnRenderThread(std::function<void()>&&) {};
-    virtual void runRenderJobs() {}
-
+    /// Enqueues a function for execution on the render thread owned by the given tag.
+    virtual void runOnRenderThread(const void*, std::function<void()>&&) {}
+    /// Run render thread jobs for the given tag address
+    /// @param closeQueue Runs all render jobs and then removes the internal queue.
+    virtual void runRenderJobs(const void*, bool closeQueue = false) {}
     /// Returns a closure wrapping the given one.
     ///
     /// When the returned closure is invoked for the first time, it schedules
@@ -130,8 +131,11 @@ class TaggedScheduler {
     /// @brief Get the wrapped scheduler
     /// @return
     const std::shared_ptr<Scheduler>& get() const noexcept { return scheduler; }
+    const void* tag() const noexcept { return tagAddr; }
 
     void schedule(std::function<void()>&& fn) { scheduler->schedule(tagAddr, std::move(fn)); }
+    void runOnRenderThread(std::function<void()>&& fn) { scheduler->runOnRenderThread(tagAddr, std::move(fn)); }
+    void runRenderJobs(bool closeQueue = false) { scheduler->runRenderJobs(tagAddr, closeQueue); }
     void waitForEmpty() const noexcept { scheduler->waitForEmpty(tagAddr); }
 
 private:

include/mbgl/gfx/renderer_backend.hpp

@@ -8,6 +8,7 @@
 namespace mbgl {
 
 class ProgramParameters;
+class Map;
 
 namespace gfx {
 
@@ -24,7 +25,7 @@ enum class ContextMode : bool {
 
 class RendererBackend {
 protected:
-    explicit RendererBackend(ContextMode);
+    explicit RendererBackend(ContextMode, mbgl::Map*);
 
 public:
     virtual ~RendererBackend();
@@ -69,6 +70,7 @@ class RendererBackend {
 protected:
     std::unique_ptr<Context> context;
     const ContextMode contextMode;
+    const mbgl::Map* owner;
     std::once_flag initialized;
 
     friend class BackendScope;

include/mbgl/gl/renderer_backend.hpp

@@ -16,7 +16,7 @@ using FramebufferID = uint32_t;
 
 class RendererBackend : public gfx::RendererBackend {
 public:
-    RendererBackend(gfx::ContextMode);
+    RendererBackend(gfx::ContextMode, mbgl::Map*);
     ~RendererBackend() override;
 
     /// Called prior to rendering to update the internally assumed OpenGL state.

include/mbgl/mtl/context.hpp

@@ -44,7 +44,7 @@ using UniqueVertexBufferResource = std::unique_ptr<VertexBufferResource>;
 
 class Context final : public gfx::Context {
 public:
-    Context(RendererBackend&);
+    Context(RendererBackend&, TaggedScheduler);
     ~Context() noexcept override;
     Context(const Context&) = delete;
     Context& operator=(const Context& other) = delete;
@@ -159,6 +159,7 @@ class Context final : public gfx::Context {
 
 private:
     RendererBackend& backend;
+    TaggedScheduler& scheduler;
     bool cleanupOnDestruction = true;
 
     std::optional<BufferResource> emptyBuffer;

include/mbgl/mtl/renderer_backend.hpp

@@ -21,7 +21,7 @@ using FramebufferID = uint32_t;
 
 class RendererBackend : public gfx::RendererBackend {
 public:
-    RendererBackend(gfx::ContextMode);
+    RendererBackend(gfx::ContextMode, mbgl::Map*);
     ~RendererBackend() override;
 
     /// Called prior to rendering to update the internally assumed MetalMetal  state.

src/mbgl/gfx/renderer_backend.cpp

@@ -5,8 +5,9 @@
 namespace mbgl {
 namespace gfx {
 
-RendererBackend::RendererBackend(const ContextMode contextMode_)
-    : contextMode(contextMode_) {}
+RendererBackend::RendererBackend(const ContextMode contextMode_, mbgl::Map* map)
+    : contextMode(contextMode_),
+      owner(map) {}
 RendererBackend::~RendererBackend() = default;
 
 gfx::Context& RendererBackend::getContext() {

src/mbgl/gl/context.cpp

@@ -72,17 +72,18 @@ GLint getMaxVertexAttribs() {
 }
 } // namespace
 
-Context::Context(RendererBackend& backend_)
+Context::Context(RendererBackend& backend_, TaggedScheduler scheduler_)
     : gfx::Context(/*maximumVertexBindingCount=*/getMaxVertexAttribs()),
-      backend(backend_) {
+      backend(backend_),
+      scheduler(std::move(scheduler_)) {
 #if MLN_DRAWABLE_RENDERER
     uboAllocator = std::make_unique<gl::UniformBufferAllocator>();
 #endif
 }
 
 Context::~Context() noexcept {
     if (cleanupOnDestruction) {
-        Scheduler::GetBackground()->runRenderJobs();
+        scheduler.runRenderJobs(true /* closeQueue */);
 
         reset();
 #if !defined(NDEBUG)
@@ -93,7 +94,7 @@ Context::~Context() noexcept {
 }
 
 void Context::beginFrame() {
-    Scheduler::GetBackground()->runRenderJobs();
+    scheduler.runRenderJobs();
 
 #if MLN_DRAWABLE_RENDERER
     frameInFlightFence = std::make_shared<gl::Fence>();

src/mbgl/gl/context.hpp

@@ -40,7 +40,7 @@ class Debugging;
 
 class Context final : public gfx::Context {
 public:
-    Context(RendererBackend&);
+    Context(RendererBackend&, TaggedScheduler);
     ~Context() noexcept override;
     Context(const Context&) = delete;
     Context& operator=(const Context& other) = delete;
@@ -153,6 +153,7 @@ class Context final : public gfx::Context {
 
 private:
     RendererBackend& backend;
+    TaggedScheduler scheduler;
     bool cleanupOnDestruction = true;
 
     std::unique_ptr<extension::Debugging> debugging;

src/mbgl/gl/renderer_backend.cpp

@@ -15,11 +15,12 @@
 namespace mbgl {
 namespace gl {
 
-RendererBackend::RendererBackend(const gfx::ContextMode contextMode_)
-    : gfx::RendererBackend(contextMode_) {}
+RendererBackend::RendererBackend(const gfx::ContextMode contextMode_, mbgl::Map* map)
+    : gfx::RendererBackend(contextMode_, map) {}
 
 std::unique_ptr<gfx::Context> RendererBackend::createContext() {
-    auto result = std::make_unique<gl::Context>(*this);
+    auto result = std::make_unique<gl::Context>(*this,
+        TaggedScheduler{Scheduler::GetBackground(), static_cast<const void*>(owner)});
     result->enableDebugging();
     result->initializeExtensions(std::bind(&RendererBackend::getExtensionFunctionPointer, this, std::placeholders::_1));
     return result;

src/mbgl/mtl/context.cpp

@@ -38,13 +38,14 @@ namespace mtl {
 // 31 for Apple2-8, Mac2, per https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
 constexpr uint32_t maximumVertexBindingCount = 31;
 
-Context::Context(RendererBackend& backend_)
+Context::Context(RendererBackend& backend_, TaggedScheduler scheduler_)
     : gfx::Context(mtl::maximumVertexBindingCount),
-      backend(backend_) {}
+      backend(backend_),
+      scheduler(std::move(scheduler_)) {}
 
 Context::~Context() noexcept {
     if (cleanupOnDestruction) {
-        Scheduler::GetBackground()->runRenderJobs();
+        scheduler.runRenderJobs(true /* closeQueue */);
         performCleanup();
 
         emptyVertexBuffer.reset();
@@ -68,7 +69,7 @@ Context::~Context() noexcept {
 }
 
 void Context::beginFrame() {
-    Scheduler::GetBackground()->runRenderJobs();
+    scheduler.runRenderJobs();
 }
 
 void Context::endFrame() {}

src/mbgl/mtl/renderer_backend.cpp

@@ -40,8 +40,8 @@
 namespace mbgl {
 namespace mtl {
 
-RendererBackend::RendererBackend(const gfx::ContextMode contextMode_)
-    : gfx::RendererBackend(contextMode_),
+RendererBackend::RendererBackend(const gfx::ContextMode contextMode_, mbgl::Map* map)
+    : gfx::RendererBackend(contextMode_, map),
       device(NS::TransferPtr(MTL::CreateSystemDefaultDevice())),
       commandQueue(NS::TransferPtr(device->newCommandQueue())) {
     assert(device);
@@ -51,7 +51,8 @@ RendererBackend::RendererBackend(const gfx::ContextMode contextMode_)
 RendererBackend::~RendererBackend() = default;
 
 std::unique_ptr<gfx::Context> RendererBackend::createContext() {
-    return std::make_unique<mtl::Context>(*this);
+    return std::make_unique<mtl::Context>(*this,
+        TaggedScheduler{Scheduler::GetBackground(), static_cast<const void*>(owner)});
 }
 
 PremultipliedImage RendererBackend::readFramebuffer(const Size& size) {

src/mbgl/tile/geometry_tile.cpp

@@ -156,14 +156,15 @@ const LayerRenderData* GeometryTileRenderData::getLayerRenderData(const style::L
    that could flag the tile as non-pending too early.
  */
 
-GeometryTile::GeometryTile(const OverscaledTileID& id_, std::string sourceID_, const TileParameters& parameters)
+GeometryTile::GeometryTile(const OverscaledTileID& id_, std::string sourceID_, const TileParameters& parameters, TaggedScheduler& scheduler)
     : Tile(Kind::Geometry, id_),
       ImageRequestor(parameters.imageManager),
       sourceID(std::move(sourceID_)),
-      threadPool(Scheduler::GetBackground()),
+      threadPool(scheduler),
       mailbox(std::make_shared<Mailbox>(*Scheduler::GetCurrent())),
-      worker(threadPool,
+      worker(threadPool, // TaggedScheduler reference for the Actor retainer
              ActorRef<GeometryTile>(*this, mailbox),
+             threadPool, // TaggedScheduler reference for the worker
              id_,
              sourceID,
              obsolete,
@@ -183,7 +184,7 @@ GeometryTile::~GeometryTile() {
     imageManager->removeRequestor(*this);
 
     if (layoutResult) {
-        threadPool->runOnRenderThread(
+        threadPool.runOnRenderThread(
             [layoutResult_{std::move(layoutResult)}, atlasTextures_{std::move(atlasTextures)}]() {});
     }
 }

src/mbgl/tile/geometry_tile.hpp

@@ -28,7 +28,7 @@ class TileAtlasTextures;
 
 class GeometryTile : public Tile, public GlyphRequestor, public ImageRequestor {
 public:
-    GeometryTile(const OverscaledTileID&, std::string sourceID, const TileParameters&);
+    GeometryTile(const OverscaledTileID&, std::string sourceID, const TileParameters&, TaggedScheduler& scheduler);
 
     ~GeometryTile() override;
 
@@ -106,7 +106,7 @@ class GeometryTile : public Tile, public GlyphRequestor, public ImageRequestor {
     // Used to signal the worker that it should abandon parsing this tile as soon as possible.
     std::atomic<bool> obsolete{false};
 
-    const std::shared_ptr<Scheduler> threadPool;
+    TaggedScheduler threadPool;
 
     const std::shared_ptr<Mailbox> mailbox;
     Actor<GeometryTileWorker> worker;

src/mbgl/tile/geometry_tile_worker.cpp

@@ -30,6 +30,7 @@ using namespace style;
 
 GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
                                        ActorRef<GeometryTile> parent_,
+                                       TaggedScheduler& scheduler_,
                                        OverscaledTileID id_,
                                        std::string sourceID_,
                                        const std::atomic<bool>& obsolete_,
@@ -38,6 +39,7 @@ GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
                                        const bool showCollisionBoxes_)
     : self(std::move(self_)),
       parent(std::move(parent_)),
+      scheduler(scheduler_),
       id(id_),
       sourceID(std::move(sourceID_)),
       obsolete(obsolete_),
@@ -46,7 +48,7 @@ GeometryTileWorker::GeometryTileWorker(ActorRef<GeometryTileWorker> self_,
       showCollisionBoxes(showCollisionBoxes_) {}
 
 GeometryTileWorker::~GeometryTileWorker() {
-    Scheduler::GetBackground()->runOnRenderThread([renderData_{std::move(renderData)}]() {});
+    scheduler.runOnRenderThread([renderData_{std::move(renderData)}]() {});
 }
 
 /*

src/mbgl/tile/geometry_tile_worker.hpp

@@ -30,6 +30,7 @@ class GeometryTileWorker {
 public:
     GeometryTileWorker(ActorRef<GeometryTileWorker> self,
                        ActorRef<GeometryTile> parent,
+                       TaggedScheduler& scheduler_,
                        OverscaledTileID,
                        std::string,
                        const std::atomic<bool>&,
@@ -71,6 +72,7 @@ class GeometryTileWorker {
 
     ActorRef<GeometryTileWorker> self;
     ActorRef<GeometryTile> parent;
+    TaggedScheduler scheduler;
 
     const OverscaledTileID id;
     const std::string sourceID;