《OGRE 3D 渲染引擎原理与架构》14.3 多线程渲染

ResourceBackgroundQueue 是资源操作的线程封装:每个方法把工作包成 std::packaged_task 交给共享 WorkQueue,返回 std::future<void>。OGRE_THREAD_SUPPORT 不等于 1 时 load 在后台 prepare、主线程 load,监听回调在主线程泵里触发。lab 复现分阶段与 future 就绪。

14.3 多线程渲染

资源加载是后台化的重头戏:解码贴图、解析网格不该卡主线程。ResourceBackgroundQueue 把「资源操作」翻译成「WorkQueue 上的任务」,每个方法都返回 std::future<void>,主线程可以随时查进度。它本身不再带锁——并行化全部收敛在 WorkQueue 里(源文件注释明说「this class is entirely single-threaded」)。这一节看它怎么用 packaged_task 包装、怎么按线程支持拆 prepare/load。

本章与站内既有内容的分工

14.2 的 WorkQueue 是通用任务队列,这一节的 ResourceBackgroundQueue 是它的资源专用门面;卷一 ogre-core 的 ResourceGroupManager::loadResourceGroup 是真正干活的函数,这里只决定它在哪个线程跑。与 cg 三卷无关,此节是线程模型设计。

资源后台队列的定位

ResourceBackgroundQueue 是单例,所有操作都借道 Root::getWorkQueue() 共享线程池。头文件开头就写清了「future 何时 ready、监听回调何时跑」:

// OgreMain/include/OgreResourceBackgroundQueue.h:ResourceBackgroundQueue 类说明(v14.6.3 源码摘录,已删减)
        Every call returns a `std::future<void>` that becomes ready when the
        background portion of the operation has finished. This may be before the
        corresponding Resource::Listener callback has run, because those callbacks
        are dispatched back to the main thread. Use the future to wait for the data
        to become available, and a listener to observe the completed resource.

        Which resource methods can run on a worker thread depends on
        `OGRE_THREAD_SUPPORT`. With the default configuration (3), workers cannot
        access the RenderSystem: prepare() runs Resource::prepare in the background,
        while load() prepares in the background and performs the actual load on the
        main thread. With `OGRE_THREAD_SUPPORT == 1`, resources are fully thread-safe
        and load() runs entirely in the background.

两句话是理解全文的关键:

概念语义
future 何时 ready后台部分结束即 ready,早于主线程的监听回调
监听回调在哪跑_firePreparingComplete/_fireLoadingComplete 派回主线程泵
默认配置(THREAD_SUPPORT=3)后台不能碰 RenderSystem:prepare 后台、load 的主线程部分回主线程
THREAD_SUPPORT=1资源全线程安全,load 整个在后台跑

packaged_task + future:包装范式

每个公共方法都是同一个三步:造 packaged_task → addTask 投递 → 返回 get_future()。以 prepare 为例:

// OgreMain/src/OgreResourceBackgroundQueue.cpp:ResourceBackgroundQueue::prepare(v14.6.3 源码摘录,已删减)
    std::future<void> ResourceBackgroundQueue::prepare(const ResourcePtr& res)
    {
        auto task = std::make_shared<std::packaged_task<void()>>(
            [res]()
            {
                res->prepare(true);
                Root::getSingleton().getWorkQueue()->addMainThreadTask([res]() { res->_firePreparingComplete(); });
            });
        Root::getSingleton().getWorkQueue()->addTask([task]() { (*task)(); });
        return task->get_future();
    }

std::make_shared<std::packaged_task<void()>> 包住 ResourcePtr,lambda 里干两件事:后台跑 res->prepare(true),再把 _firePreparingComplete 派回主线程队列。addTask 的捕获 [task] 让队列持有 packaged_task 的共享所有权;任务执行时 (*task)() 真正跑。get_future() 让调用方拿到就绪信号。

load 的分阶段拆解

load 是拆分的集大成者:根据 OGRE_THREAD_SUPPORT 走两条路。默认配置下后台只做 prepare,真正的 load 连同 _fireLoadingComplete 一起回主线程:

// OgreMain/src/OgreResourceBackgroundQueue.cpp:ResourceBackgroundQueue::load(v14.6.3 源码摘录,已删减)
    std::future<void> ResourceBackgroundQueue::load(const ResourcePtr& res)
    {
        auto task = std::make_shared<std::packaged_task<void()>>(
            [res]()
            {
#if OGRE_THREAD_SUPPORT == 1
                res->load(true);
                Root::getSingleton().getWorkQueue()->addMainThreadTask([res]() { res->_fireLoadingComplete(); });
#else
                res->prepare(true);
                Root::getSingleton().getWorkQueue()->addMainThreadTask(
                    [res]()
                    {
                        res->load(true);
                        res->_fireLoadingComplete();
                    });
#endif
            });
        Root::getSingleton().getWorkQueue()->addTask([task]() { (*task)(); });
        return task->get_future();
    }
分支后台线程做主线程队列做
OGRE_THREAD_SUPPORT == 1load(true)仅 _fireLoadingComplete
默认(!= 1)prepare(true)load(true) + _fireLoadingComplete

注意默认分支里 future 在后台 prepare 结束时已 ready,而资源真正 load 完还在主线程泵之后——这正是头文件那句「future 可能早于监听回调」的实例。资源组级的 initialiseResourceGroup/loadResourceGroup 用同一包装范式,只是 lambda 调 ResourceGroupManager 的对应函数。

源码定位

上游引用固定到 OGRE v14.6.3 源码 。

可运行产物:C++ 最小验证

下面复现 packaged_task 包装、后台/主线程拆分与静默丢弃。它与 src/14-3-multithread-render.cpp 逐字节一致:

// file: src/14-3-multithread-render.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/14-3-multithread-render.cpp -o bin/14-3-multithread-render && ./bin/14-3-multithread-render
//
// 复现 ResourceBackgroundQueue 的 packaged_task 包装与「后台 prepare、主线程 load」拆分
//   (对应 OgreResourceBackgroundQueue.cpp 50-137 与 OgreResourceBackgroundQueue.h 49-71):
//   每次操作包成 std::packaged_task 交给 WorkQueue::addTask,返回 std::future<void>;
//   OGRE_THREAD_SUPPORT != 1 时 load 在后台做 prepare,再把真正 load 派给主线程队列;
//   后台任务被静默丢弃时 prepare 永不发生。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <chrono>
#include <cstddef>
#include <deque>
#include <functional>
#include <future>
#include <memory>

namespace ogre_repro {

class ResourceRepro {
 public:
  void prepare(bool) { mPrepared = true; }
  void load(bool) { mLoaded = true; }
  void _firePreparingComplete() {}
  void _fireLoadingComplete() {}
  bool isPrepared() const { return mPrepared; }
  bool isLoaded() const { return mLoaded; }

 private:
  bool mPrepared = false;
  bool mLoaded = false;
};

// 简化版 DefaultWorkQueueBase(对应 OgreWorkQueue.cpp 的双队列)
class WorkQueueRepro {
 public:
  void addTask(std::function<void()> task) {
    if (!mAcceptRequests || mShuttingDown) return;
    mTasks.push_back(std::move(task));
  }
  void addMainThreadTask(std::function<void()> task) {
    if (!mAcceptRequests || mShuttingDown) return;
    mMainTasks.push_back(std::move(task));
  }
  void setRequestsAccepted(bool accept) { mAcceptRequests = accept; }
  void _processNextRequest() {
    if (mTasks.empty()) return;
    std::function<void()> task = std::move(mTasks.front());
    mTasks.pop_front();
    task();
  }
  void processMainThreadTasks() {
    while (!mMainTasks.empty()) {
      std::function<void()> task = std::move(mMainTasks.front());
      mMainTasks.pop_front();
      task();
    }
  }
  size_t pendingBackground() const { return mTasks.size(); }
  size_t pendingMain() const { return mMainTasks.size(); }

 private:
  bool mAcceptRequests = true;
  bool mShuttingDown = false;
  std::deque<std::function<void()>> mTasks;
  std::deque<std::function<void()>> mMainTasks;
};

// 对应 ResourceBackgroundQueue:方法把任务包成 packaged_task 交给 WorkQueue
class ResourceBackgroundQueueRepro {
 public:
  explicit ResourceBackgroundQueueRepro(WorkQueueRepro* wq) : mWq(wq) {}

  // 对应 ResourceBackgroundQueue::load(OGRE_THREAD_SUPPORT != 1 分支)
  std::future<void> load(const std::shared_ptr<ResourceRepro>& res) {
    auto task = std::make_shared<std::packaged_task<void()>>(
        [res, this]() {
          res->prepare(true);
          mWq->addMainThreadTask(
              [res]() { res->load(true); res->_fireLoadingComplete(); });
        });
    mWq->addTask([task]() { (*task)(); });
    return task->get_future();
  }

  // 对应 ResourceBackgroundQueue::prepare:纯后台
  std::future<void> prepare(const std::shared_ptr<ResourceRepro>& res) {
    auto task = std::make_shared<std::packaged_task<void()>>(
        [res]() { res->prepare(true); });
    mWq->addTask([task]() { (*task)(); });
    return task->get_future();
  }

 private:
  WorkQueueRepro* mWq;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  WorkQueueRepro wq;
  ResourceBackgroundQueueRepro rbq(&wq);

  // load():后台 prepare + 主线程 load,future 立即可查询
  auto res = std::make_shared<ResourceRepro>();
  std::future<void> fut = rbq.load(res);
  CHECK(!res->isPrepared());
  CHECK(!res->isLoaded());
  CHECK_EQ(wq.pendingBackground(), size_t(1));
  CHECK_EQ(wq.pendingMain(), size_t(0));
  CHECK(fut.wait_for(std::chrono::milliseconds(0)) == std::future_status::timeout);

  // 后台 worker 跑 packaged_task:prepare 完成,且向主线程派发 load
  wq._processNextRequest();
  CHECK(res->isPrepared());
  CHECK(!res->isLoaded());
  CHECK_EQ(wq.pendingBackground(), size_t(0));
  CHECK_EQ(wq.pendingMain(), size_t(1));
  CHECK(fut.wait_for(std::chrono::milliseconds(0)) == std::future_status::ready);

  // 主线程泵:真正的 load 发生,future 已 ready
  wq.processMainThreadTasks();
  CHECK(res->isLoaded());
  CHECK_EQ(wq.pendingMain(), size_t(0));

  // 拒绝接受新任务:packaged_task 被静默丢弃,prepare 永不发生
  wq.setRequestsAccepted(false);
  auto res2 = std::make_shared<ResourceRepro>();
  std::future<void> fut2 = rbq.load(res2);
  CHECK_EQ(wq.pendingBackground(), size_t(0));
  wq._processNextRequest();
  CHECK(!res2->isPrepared());
  CHECK(!res2->isLoaded());

  return lab::report("14-3 多线程渲染");
}

本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 15/15 通过。

future 就绪与资源可用

默认线程模式下,future 跟踪后台 packaged task。worker 准备资源并将 load(true) 投递到主线程后,future 就可能就绪。调用方需要等主线程处理加载和完成通知,才能按加载完成使用该资源。

小结

  • ResourceBackgroundQueue 本身单线程无锁,并行化全部收敛在共享 WorkQueue。
  • 每个方法三步曲:packaged_task 包装 → addTask 投递 → 返回 get_future()。
  • 默认配置下 load 拆两段:后台 prepare、主线程 load + _fireLoadingComplete。
  • future 在后台段结束即 ready,可能早于主线程的监听回调。
  • 任务在关停/拒绝期被静默丢弃时,资源永远停在未准备状态。

阅读导航:上一节:14.2 WorkQueue 与后台加载 · 下一节:15.1 选择渲染后端 。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图