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
源码定位
RenderSystems/Vulkan/include/OgreVulkanQueue.h:EncoderState(46-61)、newCommandBuffer(141)RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:newCommandBuffer(141-152)、endCommandBuffer(154-162)、getGraphicsEncoder(164-173)、_waitOnFrame(831-843)、_isFrameFinished(845-857)、commitAndNextCommandBuffer(859-927)
上游引用固定到 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 管线与同步 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。