《OGRE 3D 渲染引擎原理与架构》8.2 Vulkan 命令缓冲

VulkanQueue 管理每帧的命令缓冲与保护 fence:newCommandBuffer 等 fence 后 reset 命令池并以 ONE_TIME_SUBMIT 开始记录,编码器 Graphics/Compute/Copy 互斥切换,commitAndNextCommandBuffer 填 VkSubmitInfo 提交并轮转帧索引,_waitOnFrame 阻塞等待后回收该帧 buffer graveyard。lab 复现命令缓冲轮转、编码器状态机与延迟销毁。

8.2 Vulkan 命令缓冲

Vulkan 没有 GL 那样的全局状态;一切命令都记录进命令缓冲,再整体提交到队列。OGRE 的 VulkanQueue 封装了这套流程:每帧一个命令缓冲 + 一把「保护 fence」,用 EncoderState 状态机互斥管理 Graphics/Compute/Copy 三种编码器,提交类型达到 NewFrameIdx 时才轮转帧索引。

newCommandBuffer:等 fence、reset 池、开始记录

每帧开始必须先确认上一轮用这帧资源的 GPU 工作已完成。newCommandBuffer 的顺序是:等保护 fence → reset 命令池 → 取本帧命令缓冲/信号量 → 以 ONE_TIME_SUBMIT 开始记录:

// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::newCommandBuffer(v14.6.3 源码摘录,已删减)
void VulkanQueue::newCommandBuffer( void )
{
    _waitOnFrame(mCurrentFrameIdx);

    vkResetCommandPool(mDevice, mPerFrameData[mCurrentFrameIdx].mCommandPool, 0);
    mCurrentCmdBuffer = mPerFrameData[mCurrentFrameIdx].mCommandBuffer;
    mCurrentFence = mPerFrameData[mCurrentFrameIdx].mProtectingFence;

    VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
    vkBeginCommandBuffer( mCurrentCmdBuffer, &beginInfo );
}

VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT 告诉驱动这个命令缓冲只提交一次——同一个帧槽的命令缓冲会重复使用。每轮等待保护 fence 后重置命令池,再开始新的单次提交录制。

编码器状态机:互斥切换

VK 的命令缓冲里,RenderPass(graphics)、compute、copy 三种「编码器」不能交错打开。getGraphicsEncoder 在切换前先结束另外两种编码器:

// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::getGraphicsEncoder(v14.6.3 源码摘录,已删减)
void VulkanQueue::getGraphicsEncoder( void )
{
    if( mEncoderState != EncoderGraphicsOpen )
    {
        endCopyEncoder();
        endComputeEncoder();

        mEncoderState = EncoderGraphicsOpen;
    }
}

对称地,getComputeEncoder 切走 graphics 和 copy;copy 编码器同理。endCommandBuffer 结束所有编码器后再 vkEndCommandBuffer:

// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::endCommandBuffer(v14.6.3 源码摘录,已删减)
void VulkanQueue::endCommandBuffer( void )
{
    if( mCurrentCmdBuffer )
    {
        endAllEncoders();

        OGRE_VK_CHECK(vkEndCommandBuffer( mCurrentCmdBuffer ));
    }
}

_waitOnFrame:阻塞等待与 graveyard 回收

帧保护 fence 保证「该帧的命令缓冲占用的资源不会被提前销毁」。_waitOnFrame 阻塞等到 GPU 完成,然后把这一帧的延迟销毁队列(staging buffer、描述符池)真正释放:

// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::_waitOnFrame(v14.6.3 源码摘录,已删减)
void VulkanQueue::_waitOnFrame( uint8 frameIdx )
{
    VkFence fence = mPerFrameData[frameIdx].mProtectingFence;
    vkWaitForFences( mDevice, 1, &fence, VK_TRUE, UINT64_MAX );

    // it is safe to free staging buffers now
    for(auto bm : mPerFrameData[frameIdx].mBufferGraveyard)
    {
        vmaDestroyBuffer(mOwnerDevice->getAllocator(), bm.first, bm.second);
    }
    mPerFrameData[frameIdx].mBufferGraveyard.clear();
    mPerFrameData[frameIdx].mDescriptorPoolGraveyard.clear();
}

这是 GL3Plus _destroyVao 延迟队列的 VK 版:GPU 还在用的对象不能释放,等对应 fence 通过后才安全销毁。_isFrameFinished 则用 0 超时做非阻塞探测。

commitAndNextCommandBuffer:提交并轮转

命令缓冲记完后填 VkSubmitInfo 提交,需要时附加等待/信号信号量(如「等 swapchain 呈现完成」),按提交类型决定是否推进帧槽,并打开下一次记录:

// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::commitAndNextCommandBuffer(v14.6.3 源码摘录,已删减)
void VulkanQueue::commitAndNextCommandBuffer( SubmissionType::SubmissionType submissionType )
{
    endCommandBuffer();

    VkSubmitInfo submitInfo = {VK_STRUCTURE_TYPE_SUBMIT_INFO};
    submitInfo.commandBufferCount   = 1;
    submitInfo.pCommandBuffers      = &mCurrentCmdBuffer;

    if( !mGpuWaitSemaphForCurrCmdBuff.empty() )
    {
        // We need to wait on these semaphores so that rendering can
        // only happen start the swapchain is done presenting
        submitInfo.waitSemaphoreCount = mGpuWaitSemaphForCurrCmdBuff.size();
        submitInfo.pWaitSemaphores = mGpuWaitSemaphForCurrCmdBuff.data();
        submitInfo.pWaitDstStageMask = mGpuWaitFlags.data();
    }

    if( submissionType >= SubmissionType::NewFrameIdx )
    {
        if( submissionType >= SubmissionType::EndFrameAndSwap )
        {
            // Get semaphores so that presentation can wait for this job to finish rendering
            // (one for each window that will be swapped)
            for (auto w : mWindowsPendingSwap)
            {
                mGpuSignalSemaphForCurrCmdBuff.push_back(w->getRenderFinishedSemaphore());
                w->setImageFence(mCurrentFence);
            }
            ...
        }
        ...
    }
    ...
}

lab 里我们复现这条链:首帧拿缓冲、切换编码器、提交并轮转到下一帧、回到帧 0 时触发 graveyard 回收。

Vulkan 帧槽复用与交换链

sequenceDiagram
  participant W as VulkanWindow 与交换链
  participant Q as VulkanQueue
  participant S as 帧槽与保护 fence
  participant G as GPU 队列
  W->>W: acquire 图像并准备可用信号量
  break acquire 返回 OUT_OF_DATE 或 SUBOPTIMAL
    W->>W: 等待设备,销毁并重建交换链
  end
  break acquire 返回其他错误
    W->>W: 记录错误并结束这次 acquire
  end
  W->>W: 已绑定 image fence 时等待该图像完成
  W->>Q: 绑定窗口目标时登记图像可用等待条件
  Q->>S: 记录命令并结束活动编码器
  Q->>S: 重置保护 fence
  Q->>G: submit,附上 acquire 等待条件、fence 与所需信号量
  par GPU 消费提交
    G->>G: 等待 acquire,执行渲染命令
    G-->>S: 提交完成后 signal 对应 fence
  and CPU 继续调度
    opt 提交类型达到 EndFrameAndSwap
      Q->>W: 排队 present,由 render-finished 信号量保护
    end
    opt 提交类型达到 NewFrameIdx
      Q->>Q: 推进并环绕帧槽索引
    end
    Q->>S: 等待即将复用帧槽的 fence
    Q->>S: 回收延迟释放对象并重置命令池
    Q->>S: begin 命令缓冲,单次提交标志
    opt 窗口呈现提交
      Q->>W: acquire 下一张图像
    end
  end

独立标记帧槽与交换链图像

frame slot 控制命令池和 fence 的复用,交换链图像索引由 acquire 返回。提交等待图像可用,呈现等待渲染完成。CPU 等保护 fence 才复用帧槽,不必要求图像索引与帧槽同号。

采集时分别记录 frameIdx、imageIdx 和提交类型,区分只提交、推进帧槽和含呈现的路径。resize 测试还需记录图像获取返回值和重建后的首个有效帧。

帧槽与交换链的资源关系

flowchart LR
  CPU["CPU 提交调度"] --> Q["VulkanQueue"]
  Q --> S["按 frameIdx 管理帧槽"]
  S --> CP["命令池和命令缓冲"]
  S --> F["保护 fence 与延迟回收"]
  W["VulkanWindow"] --> SW["交换链及 imageIdx"]
  SW --> A["图像可用信号量"]
  A -.->|"提交等待"| Q
  Q -.->|"呈现等待的信号"| P["render finished"]
  P -.-> W

源码定位

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

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

下面用纯 C++ 复现 VulkanQueue 的命令缓冲管理。它与 src/08-2-vulkan-command-buffer.cpp 逐字节一致:

// file: src/08-2-vulkan-command-buffer.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/08-2-vulkan-command-buffer.cpp -o bin/08-2-vulkan-command-buffer && ./bin/08-2-vulkan-command-buffer
//
// 复现 VulkanQueue 的命令缓冲管理(对应 OgreVulkanQueue.h 46-243 与
// OgreVulkanQueue.cpp 141-173、831-927):
//   newCommandBuffer:等待当前帧 fence 后 reset 命令池并以 ONE_TIME_SUBMIT 开始记录;
//   编码器状态机:Graphics/Compute/Copy 互斥切换,切走前结束其他编码器;
//   commitAndNextCommandBuffer:填 VkSubmitInfo 提交、轮转帧索引、再 newCommandBuffer;
//   帧保护 fence 保证 GPU 完成前不回收该帧资源(buffer graveyard 延迟销毁)。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <utility>
#include <vector>

namespace ogre_repro {

enum class EncoderState : uint8_t {
  EncoderGraphicsOpen,
  EncoderComputeOpen,
  EncoderCopyOpen,
  EncoderClosed
};

struct PerFrameData {
  uint32_t mCommandPool = 0;
  uint32_t mCommandBuffer = 0;
  bool mFenceSignaled = true;  // 初始已完成,模拟首帧 fence 就绪
  std::vector<std::pair<uint32_t, uint32_t>> mBufferGraveyard;
};

class VulkanQueue {
 public:
  explicit VulkanQueue(uint8_t numFramesInFlight)
      : mNumFramesInFlight(numFramesInFlight),
        mCurrentFrameIdx(0),
        mEncoderState(EncoderState::EncoderClosed),
        mCurrentCmdBuffer(0),
        mCurrentFence(0) {
    mPerFrameData.resize(numFramesInFlight);
    for (uint8_t i = 0; i < numFramesInFlight; ++i) {
      mPerFrameData[i].mCommandPool = 100 + i;
      mPerFrameData[i].mCommandBuffer = 200 + i;
    }
  }

  // 对应 newCommandBuffer:等 fence -> reset 命令池 -> 开始记录
  void newCommandBuffer() {
    if (!mPerFrameData[mCurrentFrameIdx].mFenceSignaled) {
      _waitOnFrame(mCurrentFrameIdx);  // 帧尚未完成,先等待
    }
    mPerFrameData[mCurrentFrameIdx].mFenceSignaled = false;
    mCurrentCmdBuffer = mPerFrameData[mCurrentFrameIdx].mCommandBuffer;
    mCurrentFence = 1000 + mCurrentFrameIdx;
    mEncoderState = EncoderState::EncoderClosed;
  }

  void getGraphicsEncoder() {
    if (mEncoderState != EncoderState::EncoderGraphicsOpen) {
      // 切走前先结束 copy/compute 编码器(简化计数)
      mEndedEncoders++;
      mEncoderState = EncoderState::EncoderGraphicsOpen;
    }
  }

  void endCommandBuffer() {
    if (mCurrentCmdBuffer != 0) {
      mCommandBuffersEnded++;  // vkEndCommandBuffer
    }
  }

  // 对应 _waitOnFrame:vkWaitForFences 阻塞后回收该帧的 buffer graveyard
  void _waitOnFrame(uint8_t frameIdx) {
    mPerFrameData[frameIdx].mFenceSignaled = true;
    for (auto bm : mPerFrameData[frameIdx].mBufferGraveyard) {
      mFreedBuffers.push_back(bm.first);
    }
    mPerFrameData[frameIdx].mBufferGraveyard.clear();
  }

  // 对应 commitAndNextCommandBuffer
  void commitAndNextCommandBuffer() {
    endCommandBuffer();
    if (!mGpuWaitSemaphForCurrCmdBuff.empty()) {
      mSubmittedWaitSemaphores += mGpuWaitSemaphForCurrCmdBuff.size();
    }
    mGpuWaitSemaphForCurrCmdBuff.clear();
    mCurrentCmdBuffer = 0;
    mCurrentFrameIdx = static_cast<uint8_t>((mCurrentFrameIdx + 1) % mPerFrameData.size());
    newCommandBuffer();
  }

  uint8_t getCurrentFrameIdx() const { return mCurrentFrameIdx; }
  size_t getEndedEncoders() const { return mEndedEncoders; }
  size_t getCommandBuffersEnded() const { return mCommandBuffersEnded; }
  size_t getSubmittedWaitSemaphores() const { return mSubmittedWaitSemaphores; }
  size_t getFreedBuffers() const { return mFreedBuffers.size(); }

  std::vector<PerFrameData> mPerFrameData;
  uint8_t mNumFramesInFlight;
  uint8_t mCurrentFrameIdx;
  EncoderState mEncoderState;
  uint32_t mCurrentCmdBuffer;
  uint32_t mCurrentFence;
  std::vector<uint32_t> mGpuWaitSemaphForCurrCmdBuff;
  size_t mEndedEncoders = 0;
  size_t mCommandBuffersEnded = 0;
  size_t mSubmittedWaitSemaphores = 0;
  std::vector<uint32_t> mFreedBuffers;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  VulkanQueue q(2);
  CHECK_EQ(q.getCurrentFrameIdx(), uint8_t(0));
  CHECK_EQ(q.mCurrentCmdBuffer, uint32_t(0));

  // 首帧 newCommandBuffer:用帧 0 的命令缓冲与 fence
  q.newCommandBuffer();
  CHECK_EQ(q.mCurrentCmdBuffer, uint32_t(200));
  CHECK_EQ(q.mCurrentFence, uint32_t(1000));

  // 编码器状态机:切到 graphics 前会结束其他编码器
  q.getGraphicsEncoder();
  CHECK(q.mEncoderState == EncoderState::EncoderGraphicsOpen);
  CHECK_EQ(q.mEndedEncoders, size_t(1));

  // 提交并切下一帧:等待信号量并入提交,帧索引轮转到 1
  q.mGpuWaitSemaphForCurrCmdBuff.push_back(42);
  q.commitAndNextCommandBuffer();
  CHECK_EQ(q.getCurrentFrameIdx(), uint8_t(1));
  CHECK_EQ(q.mSubmittedWaitSemaphores, size_t(1));
  CHECK_EQ(q.mCurrentCmdBuffer, uint32_t(201));  // 新帧命令缓冲
  CHECK_EQ(q.mCurrentFence, uint32_t(1001));

  // 提交回帧 0:等待其 fence 就绪并回收 graveyard
  q.mPerFrameData[0].mBufferGraveyard.push_back({7, 7});
  q._waitOnFrame(0);
  CHECK_EQ(q.getFreedBuffers(), size_t(1));
  q.mPerFrameData[0].mFenceSignaled = true;
  q.commitAndNextCommandBuffer();
  CHECK_EQ(q.getCurrentFrameIdx(), uint8_t(0));

  return lab::report("08-2 Vulkan 命令缓冲");
}

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

小结

  • newCommandBuffer 按「等 fence → reset 命令池 → ONE_TIME_SUBMIT 开始记录」的顺序准备每帧命令缓冲。
  • 编码器状态机让 Graphics/Compute/Copy 三种编码器互斥,切走前必须先结束旧的。
  • _waitOnFrame 阻塞等 GPU 完成后才回收该帧的 buffer graveyard / descriptor pool graveyard。
  • commitAndNextCommandBuffer 填 VkSubmitInfo(含等待/信号信号量)提交,再轮转帧索引开下一帧。

阅读导航:上一节:8.1 Vulkan 渲染系统 · 下一节:8.3 Vulkan 管线与同步 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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