《OGRE 3D 渲染引擎原理与架构》2.1 硬件缓冲抽象

HardwareBuffer 是显存缓冲的抽象:Usage 枚举标注数据去向、LockOptions 标注锁定方式,shadow buffer 机制让可读写的系统内存副本与高效的显存写专用缓冲协同。lock/unlock 时自动同步,readData 读 shadow、writeData 双写。lab 复现 shadow buffer 同步链。

2.1 硬件缓冲抽象

顶点、索引、像素、统一数据——GPU 能高效读的都是硬件缓冲。HardwareBuffer 是这一切的抽象基类,它解决一个 GPU 世界特有的矛盾:显存缓冲读写不对称——写可以快,读常常慢甚至不允许。这一节看 OGRE 怎么用「Usage + LockOptions + shadow buffer」三件套管理这种不对称。

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

卷一 7.2/7.3 讲顶点声明与索引数据是「逻辑结构」;这里是它们底下的存储层——真正的字节住在哪、怎么同步。helio 引擎的 Buffer 是 TypeScript 包装 WebGL 数组缓冲,OGRE 多了一层 shadow buffer 同步策略。

矛盾:写快读慢的显存

OgreHardwareBuffer.h 的开头注释直接点出问题:

it is often either impossible, or extremely undesirable from a performance standpoint to read from a hardware buffer; when writing to hardware buffers, you should also write every byte and do it sequentially. In situations where this is too restrictive, it is possible to create a hardware, write-only buffer (the most efficient kind) and to back it with a system memory ‘shadow’ copy which can be read and updated arbitrarily.

翻译成机制:写专用缓冲最高效,但代价是不能随便读;要读?在系统内存里放一份 shadow 副本,随意读、随意改,再由 OGRE 负责同步。

Usage:告诉系统数据往哪去

// OgreMain/include/OgreHardwareBuffer.h:HardwareBuffer::UsageEnum(v14.6.3 源码摘录,已删减)
            enum UsageEnum
            {
                /// same as #HBU_GPU_TO_CPU
                HBU_STATIC = HBU_GPU_TO_CPU,
                /// same as #HBU_CPU_ONLY
                HBU_DYNAMIC = HBU_CPU_ONLY,
                /// same as #HBU_GPU_ONLY
                HBU_STATIC_WRITE_ONLY = HBU_GPU_ONLY,
                /// same as #HBU_CPU_TO_GPU
                HBU_DYNAMIC_WRITE_ONLY = HBU_CPU_TO_GPU,
            };

旧命名全部是底层 Flag 的别名:HBU_STATIC 就是 HBU_GPU_TO_CPU(数据主要从 GPU 读回,静态),HBU_DYNAMIC_WRITE_ONLY 就是 HBU_CPU_TO_GPU(CPU 频繁写入 GPU,动态)。选对 Usage 直接决定驱动的内存布局选择。

LockOptions:一次锁定表达的意图

// OgreMain/include/OgreHardwareBuffer.h:HardwareBuffer::LockOptions(v14.6.3 源码摘录,已删减)
            enum LockOptions : uint8
            {
                HBL_NORMAL,
                HBL_DISCARD,
                HBL_READ_ONLY,
                HBL_NO_OVERWRITE,
                HBL_WRITE_ONLY
            };

HBL_DISCARD 的注释值得记住:它告诉驱动「整个缓冲区内容你都扔掉」,驱动因此可以给你一块完全不同的内存而不用等当前帧渲染完——避免管线停顿。这是「环形双缓冲」思想的锁级表达。

shadow buffer:锁进 shadow,解锁同步

lock/unlock 实现了完整的 shadow 同步链:

// OgreMain/include/OgreHardwareBuffer.h:HardwareBuffer::lock/unlock(v14.6.3 源码摘录,已删减)
            virtual void* lock(size_t offset, size_t length, LockOptions options)
            {
                OgreAssert(!isLocked(), "Cannot lock this buffer: it is already locked");
                OgreAssert((length + offset) <= mSizeInBytes, "Lock request out of bounds");

                void* ret = NULL;
                if (mShadowBuffer)
                {
                    // we have to assume a read / write lock so we use the shadow buffer
                    // and tag for sync on unlock()
                    mShadowUpdated = (options != HBL_READ_ONLY);

                    ret = mShadowBuffer->lock(offset, length, options);
                }
                else
                {
                    mIsLocked = true;
                    // Lock the real buffer if there is no shadow buffer 
                    ret = lockImpl(offset, length, options);
                }
                mLockStart = offset;
                mLockSize = length;
                return ret;
            }

            void unlock(void)
            {
                OgreAssert(isLocked(), "Cannot unlock this buffer: it is not locked");

                // If we used the shadow buffer this time...
                if (mShadowBuffer && mShadowBuffer->isLocked())
                {
                    mShadowBuffer->unlock();
                    // Potentially update the 'real' buffer from the shadow buffer
                    _updateFromShadow();
                }
                else
                {
                    // Otherwise, unlock the real one
                    unlockImpl();
                    mIsLocked = false;
                }
            }

逻辑分两条路:

  • 有 shadow:lock 直接锁 shadow,且 mShadowUpdated = (options != HBL_READ_ONLY)——只有非只读锁才标记「需要同步」。unlock 解锁 shadow 后调 _updateFromShadow 把改动推回真缓冲。
  • 无 shadow:lockImpl 锁真缓冲、mIsLocked = true,unlock 直接释放。

_updateFromShadow 只同步锁过的区段(mLockStart/mLockSize),整缓冲锁定时用 HBL_DISCARD 避免读写停顿:

// OgreMain/include/OgreHardwareBuffer.h:HardwareBuffer::_updateFromShadow(v14.6.3 源码摘录,已删减)
            virtual void _updateFromShadow(void)
            {
                if (mShadowBuffer && mShadowUpdated && !mSuppressHardwareUpdate)
                {
                    // Do this manually to avoid locking problems
                    const void* srcData = mShadowBuffer->lockImpl(mLockStart, mLockSize, HBL_READ_ONLY);
                    // Lock with discard if the whole buffer was locked, otherwise w/o
                    bool discardWholeBuffer = mLockStart == 0 && mLockSize == mSizeInBytes;
                    LockOptions lockOpt = discardWholeBuffer ? HBL_DISCARD : HBL_WRITE_ONLY;
                    void* destData = this->lockImpl(mLockStart, mLockSize, lockOpt);
                    // Copy shadow to real
                    memcpy(destData, srcData, mLockSize);
                    this->unlockImpl();
                    mShadowBuffer->unlockImpl();
                    mShadowUpdated = false;
                }
            }

writeData 则是「显式同步」路径:有 shadow 先写 shadow,再写真缓冲,双写。readData 反过来:有 shadow 就读 shadow(避免读真缓冲的昂贵操作)。

构造时还有一个静默优化:

// OgreMain/include/OgreHardwareBuffer.h:HardwareBuffer 构造(v14.6.3 教学示意,参照上游同名实现,已删减)
            HardwareBuffer(Usage usage, bool useShadowBuffer)
                : ... mUsage(usage)
            {
                // If use shadow buffer, upgrade to WRITE_ONLY on hardware side
                if (useShadowBuffer && usage == HBU_CPU_ONLY)
                {
                    mUsage = HBU_CPU_TO_GPU;
                }
                else if (useShadowBuffer && usage == HBU_GPU_TO_CPU)
                {
                    mUsage = HBU_GPU_ONLY;
                }
            }

要 shadow 副本,硬件侧就升级为写专用——因为反正系统内存副本管读取,显存那边只需最快写入。这行代码是整个 shadow 策略的点睛之笔:逻辑需求(要读)与物理最优(写专用)由构造器调和。

源码定位

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

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

下面用纯 C++ 复现 shadow buffer 的同步链。它与 src/02-1-hardware-buffer.cpp 逐字节一致:

// file: src/02-1-hardware-buffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/02-1-hardware-buffer.cpp -o bin/02-1-hardware-buffer && ./bin/02-1-hardware-buffer
//
// 复现 HardwareBuffer 的 shadow buffer 机制(对应 OgreHardwareBuffer.h 109-373):
//   Usage 枚举(HBU_STATIC/DYNAMIC/STATIC_WRITE_ONLY/DYNAMIC_WRITE_ONLY 的别名映射);
//   lock():有 shadow 时锁 shadow(mShadowUpdated 标记),否则锁真缓冲并置 mIsLocked;
//   unlock():shadow 加锁则解锁并 _updateFromShadow 同步真缓冲;
//   writeData 双写 shadow 与真缓冲;readData 从 shadow 读;
//   构造时 useShadowBuffer 把 HBU_CPU_ONLY 升级为 HBU_CPU_TO_GPU(写专用优化)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <cstring>
#include <memory>
#include <vector>

namespace ogre_repro {

class HardwareBuffer {
 public:
  // 对应 UsageEnum:新命名别名映射到底层 Flag(简化映射)
  enum Usage : uint8_t {
    HBU_GPU_TO_CPU = 1,  // HBU_STATIC 的底层
    HBU_CPU_ONLY = 2,    // HBU_DYNAMIC 的底层
    HBU_GPU_ONLY = 3,    // HBU_STATIC_WRITE_ONLY 的底层
    HBU_CPU_TO_GPU = 4,  // HBU_DYNAMIC_WRITE_ONLY 的底层
  };
  // 对应 LockOptions
  enum LockOptions : uint8_t {
    HBL_NORMAL = 0,
    HBL_DISCARD = 1,
    HBL_READ_ONLY = 2,
    HBL_NO_OVERWRITE = 3,
    HBL_WRITE_ONLY = 4,
  };

  HardwareBuffer(Usage usage, bool useShadowBuffer, size_t sizeInBytes)
      : mSizeInBytes(sizeInBytes), mUsage(usage) {
    mRealData.assign(sizeInBytes, 0);
    // 对应构造里的 usage 升级
    if (useShadowBuffer && usage == HBU_CPU_ONLY) {
      mUsage = HBU_CPU_TO_GPU;  // shadow 缓冲在硬件侧升级为写专用
    } else if (useShadowBuffer && usage == HBU_GPU_TO_CPU) {
      mUsage = HBU_GPU_ONLY;
    }
    if (useShadowBuffer) mShadow.reset(new std::vector<uint8_t>(sizeInBytes, 0));
  }

  // 对应 lock():有 shadow 锁 shadow,否则锁真缓冲
  void* lock(size_t offset, size_t length, LockOptions options) {
    mLockStart = offset;
    mLockSize = length;
    if (mShadow) {
      mShadowLocked = true;
      mShadowUpdated = (options != HBL_READ_ONLY);  // 只读不触发同步
      return mShadow->data() + offset;
    }
    mIsLocked = true;
    return mRealData.data() + offset;
  }

  // 对应 unlock():shadow 加锁则同步回真缓冲
  void unlock() {
    if (mShadow && mShadowLocked) {
      _updateFromShadow();
      mShadowLocked = false;
      return;
    }
    mIsLocked = false;
  }

  // 对应 writeData():双写 shadow 与真缓冲
  void writeData(size_t offset, size_t length, const void* pSource) {
    if (mShadow) {
      std::memcpy(mShadow->data() + offset, pSource, length);
      mShadowUpdated = true;
    }
    std::memcpy(mRealData.data() + offset, pSource, length);
  }

  // 对应 readData():优先从 shadow 读
  void readData(size_t offset, size_t length, void* pDest) {
    const std::vector<uint8_t>* src = mShadow ? mShadow.get() : &mRealData;
    std::memcpy(pDest, src->data() + offset, length);
  }

  // 对应 _updateFromShadow():只同步锁定的区段
  void _updateFromShadow() {
    if (mShadow && mShadowUpdated) {
      std::memcpy(mRealData.data() + mLockStart, mShadow->data() + mLockStart, mLockSize);
      mShadowUpdated = false;
    }
  }

  bool isLocked() const { return mIsLocked || mShadowLocked; }
  bool hasShadowBuffer() const { return mShadow != nullptr; }
  Usage getUsage() const { return mUsage; }
  size_t getSizeInBytes() const { return mSizeInBytes; }
  uint8_t* realData() { return mRealData.data(); }

 private:
  size_t mSizeInBytes;
  size_t mLockStart = 0;
  size_t mLockSize = 0;
  Usage mUsage;
  bool mShadowUpdated = false;
  bool mIsLocked = false;
  bool mShadowLocked = false;
  std::vector<uint8_t> mRealData;                        // 模拟显存里的真缓冲
  std::unique_ptr<std::vector<uint8_t>> mShadow;         // 系统内存 shadow 副本
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 无 shadow:lock 写直接进真缓冲
  HardwareBuffer plain(HardwareBuffer::HBU_GPU_ONLY, false, 8);
  uint8_t v[] = {1, 2, 3, 4};
  void* p = plain.lock(0, 4, HardwareBuffer::HBL_WRITE_ONLY);
  std::memcpy(p, v, 4);
  plain.unlock();
  CHECK(plain.realData()[0] == 1 && plain.realData()[3] == 4);

  // 有 shadow:lock 写只进 shadow,unlock 自动同步
  HardwareBuffer shadowed(HardwareBuffer::HBU_CPU_ONLY, true, 8);
  CHECK(shadowed.hasShadowBuffer());
  CHECK(shadowed.getUsage() == HardwareBuffer::HBU_CPU_TO_GPU);  // usage 升级
  uint8_t w[] = {9, 8, 7, 6};
  p = shadowed.lock(4, 4, HardwareBuffer::HBL_WRITE_ONLY);
  std::memcpy(p, w, 4);
  CHECK(shadowed.realData()[4] == 0);  // unlock 前真缓冲未被写
  shadowed.unlock();
  CHECK(shadowed.realData()[4] == 9 && shadowed.realData()[7] == 6);  // 已同步

  // 只读锁:unlock 不触发同步
  HardwareBuffer ro(HardwareBuffer::HBU_GPU_TO_CPU, true, 8);
  ro.writeData(0, 2, v);
  p = ro.lock(0, 2, HardwareBuffer::HBL_READ_ONLY);
  ro.realData()[0] = 0xAA;  // 直接篡改真缓冲
  ro.unlock();
  CHECK(ro.realData()[0] == 0xAA);  // 未被 shadow 覆盖回写

  // writeData 双写
  HardwareBuffer dual(HardwareBuffer::HBU_CPU_TO_GPU, true, 4);
  dual.writeData(0, 4, v);
  CHECK(dual.realData()[0] == 1);

  return lab::report("02-1 硬件缓冲抽象");
}

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

小结

  • HardwareBuffer 用 Usage(数据流向)与 LockOptions(锁定意图)刻画缓冲的使用方式。
  • shadow buffer:系统内存副本管「任意读写」,显存侧升级为写专用,unlock 时把锁定区段同步回真缓冲。
  • HBL_DISCARD 允许驱动整体换缓冲,规避渲染中的管线停顿。
  • writeData 双写、readData 读 shadow、_updateFromShadow 只同步 mLockStart/mLockSize 区段。

阅读导航:上一节:1.3 创建渲染目标 · 下一节:2.2 顶点声明 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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