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 策略的点睛之笔:逻辑需求(要读)与物理最优(写专用)由构造器调和。
源码定位
OgreMain/include/OgreHardwareBuffer.h:UsageEnum(115-131)、LockOptions(133-167)、lock(211-234)、unlock(253-271)、_updateFromShadow(344-360)、writeData(297-307)、readData(279-288)、构造 upgrade(190-203)OgreMain/include/OgreHardwareBufferManager.h:创建缓冲的入口(createVertexBuffer/createIndexBuffer带useShadowBuffer参数)
上游引用固定到 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 顶点声明 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。