8.3 Vulkan 管线与同步
vkCreateGraphicsPipelines 是出了名的贵——驱动要编译着色器状态组合。OGRE 的策略是把「决定管线形态的每个状态」哈希起来查缓存,命中就复用句柄。同步则分两层:内存屏障里的 deriveStageFromBufferAccessFlags 把访问位推导成管线阶段位,fence 负责帧与帧之间的 GPU 完成信号。
getPipeline:整状态哈希 + mPipelineCache
管线由 renderPass、混合状态、光栅状态、输入装配、多采样、顶点属性/绑定、着色器阶段共同决定。OGRE 把这些逐一 HashCombine 进一个 hash,查 mPipelineCache:
// RenderSystems/Vulkan/src/OgreVulkanRenderSystem.cpp:VulkanRenderSystem::getPipeline(v14.6.3 源码摘录,已删减)
VkPipeline VulkanRenderSystem::getPipeline()
{
pipelineCi.renderPass = mCurrentRenderPassDescriptor->getRenderPass();
pipelineCi.layout = mLayout;
mssCi.rasterizationSamples = VkSampleCountFlagBits(std::max(mActiveRenderTarget->getFSAA(), 1u));
auto hash = HashCombine(0, pipelineCi.renderPass);
hash = HashCombine(hash, blendStates[0]);
hash = HashCombine(hash, rasterState);
hash = HashCombine(hash, inputAssemblyCi);
hash = HashCombine(hash, mssCi);
for(uint32 i = 0; i <vertexFormatCi.vertexAttributeDescriptionCount; i++)
{
hash = HashCombine(hash, vertexFormatCi.pVertexAttributeDescriptions[i]);
}
for(uint32 i = 0; i < vertexFormatCi.vertexBindingDescriptionCount; i++)
{
hash = HashCombine(hash, vertexFormatCi.pVertexBindingDescriptions[i]);
}
for(uint32 i= 0; i < pipelineCi.stageCount; i++)
{
hash = HashCombine(hash, mBoundGpuPrograms[i]);
}
VkPipeline retVal = mPipelineCache[hash];
if(retVal != VK_NULL_HANDLE)
return retVal;
...
OGRE_VK_CHECK(vkCreateGraphicsPipelines(mActiveDevice->mDevice, 0, 1, &pipelineCi, 0, &retVal));
mPipelineCache[hash] = retVal;
return retVal;
}
哈希输入包括实际列出的结构体、句柄和程序引用。调整窗口可能导致 render pass 改变,从而查到不同的键。该查找函数不会驱逐旧条目,缓存清理由渲染系统销毁路径负责。动态状态则由记录命令时的设置决定。
_render 与顶点缓冲
_render 里拿到管线句柄后,绑定顶点缓冲、索引缓冲、描述集,再按下发参数绘制。这是 7.1 GL3Plus _render 的 VK 对称实现。
deriveStageFromBufferAccessFlags:访问位 → 阶段位
内存屏障需要声明「在哪个管线阶段生效」。OGRE 提供一套纯位运算推导,把缓冲访问位映射成阶段位:
// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::deriveStageFromBufferAccessFlags(v14.6.3 源码摘录,已删减)
VkPipelineStageFlags VulkanQueue::deriveStageFromBufferAccessFlags( VkAccessFlags accessFlags )
{
VkPipelineStageFlags stage = 0;
if( accessFlags & VK_ACCESS_INDIRECT_COMMAND_READ_BIT )
stage |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
if( accessFlags & ( VK_ACCESS_INDEX_READ_BIT | VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT ) )
{
stage |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
}
if( accessFlags &
( VK_ACCESS_UNIFORM_READ_BIT | VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT ) )
{
stage |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT |
VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT |
VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT |
VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT |
VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
}
if( accessFlags & ( VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT ) )
{
stage |= VK_PIPELINE_STAGE_TRANSFER_BIT;
}
return stage;
}
四个映射组:indirect 读 → draw indirect 阶段;索引/属性读 → vertex input 阶段;uniform/shader 读 → 全部可编程着色阶段;transfer 读/写 → transfer 阶段。lab 里我们验证单组与组合的位推导。
fence 同步:阻塞与非阻塞
帧间同步用 fence,8.2 里 _waitOnFrame 已经见过阻塞版本(UINT64_MAX 无限等)。非阻塞版用 0 超时探测——GPU 已完成返回 true,否则 false:
// RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:VulkanQueue::_isFrameFinished(v14.6.3 源码摘录,已删减)
bool VulkanQueue::_isFrameFinished( uint8 frameIdx )
{
VkFence fence = mPerFrameData[frameIdx].mProtectingFence;
VkResult ret = vkWaitForFences( mDevice, 1, &fence, VK_TRUE, 0u );
if( ret != VK_TIMEOUT )
{
OGRE_VK_CHECK(ret);
return true;
}
return false;
}
lab 里我们用一个简化 FakeFence 复现「已 signal 即完成」的语义。
源码定位
RenderSystems/Vulkan/src/OgreVulkanRenderSystem.cpp:getPipeline(927-971)、_render(973-1056)RenderSystems/Vulkan/src/OgreVulkanQueue.cpp:deriveStageFromBufferAccessFlags(186-210)、_isFrameFinished(845-857)、_waitOnFrame(831-843)
上游引用固定到 OGRE v14.6.3 源码 。
可运行产物:C++ 最小验证
下面用纯 C++ 复现 Vulkan 管线的哈希缓存与阶段位推导。它与 src/08-3-vulkan-pipeline.cpp 逐字节一致:
// file: src/08-3-vulkan-pipeline.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/08-3-vulkan-pipeline.cpp -o bin/08-3-vulkan-pipeline && ./bin/08-3-vulkan-pipeline
//
// 复现 Vulkan 管线与同步(对应 OgreVulkanRenderSystem.cpp 927-1056、
// OgreVulkanQueue.cpp 186-210、831-857):
// getPipeline:把 renderPass/blend/光栅化/输入装配/多采样/顶点格式/着色器阶段哈希,
// 命中 mPipelineCache 直接复用,否则 vkCreateGraphicsPipelines 并回填缓存;
// _render:绑定顶点缓冲、索引缓冲、描述集、管线后按索引/实例数量下发绘制;
// deriveStageFromBufferAccessFlags:访问位 -> 管线阶段位;
// fence 同步:阻塞(UINT64_MAX)与非阻塞(0 超时)查询 GPU 完成状态。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"
#include <cstdint>
#include <unordered_map>
#include <vector>
namespace ogre_repro {
// VK 访问/阶段位(volk.h 中的实际值)
constexpr uint32_t VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001;
constexpr uint32_t VK_ACCESS_UNIFORM_READ_BIT = 0x00000020;
constexpr uint32_t VK_ACCESS_TRANSFER_READ_BIT = 0x00020000;
constexpr uint32_t VK_ACCESS_TRANSFER_WRITE_BIT = 0x00040000;
constexpr uint32_t VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002;
constexpr uint32_t VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000040;
constexpr uint32_t VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00000800;
uint32_t hashCombine(uint32_t seed, uint32_t v) {
seed ^= v + 0x9e3779b9u + (seed << 6) + (seed >> 2);
return seed;
}
// 对应 deriveStageFromBufferAccessFlags
uint32_t deriveStageFromBufferAccessFlags(uint32_t accessFlags) {
uint32_t stage = 0;
if (accessFlags & VK_ACCESS_INDIRECT_COMMAND_READ_BIT)
stage |= VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT;
if (accessFlags & (VK_ACCESS_UNIFORM_READ_BIT | 0x00000002u)) // INDEX/ATTR read
stage |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT;
if (accessFlags & (VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT))
stage |= VK_PIPELINE_STAGE_TRANSFER_BIT;
return stage;
}
struct PipelineState {
uint32_t renderPass = 1;
uint32_t blendState = 2;
uint32_t rasterState = 3;
uint32_t inputAssembly = 4;
uint32_t mss = 5;
std::vector<uint32_t> attribs;
std::vector<uint32_t> bindings;
std::vector<uint32_t> shaderStages;
};
class VulkanRenderSystem {
public:
// 对应 getPipeline
uint32_t getPipeline(const PipelineState& s) {
uint32_t hash = hashCombine(0, s.renderPass);
hash = hashCombine(hash, s.blendState);
hash = hashCombine(hash, s.rasterState);
hash = hashCombine(hash, s.inputAssembly);
hash = hashCombine(hash, s.mss);
for (auto a : s.attribs) hash = hashCombine(hash, a);
for (auto b : s.bindings) hash = hashCombine(hash, b);
for (auto g : s.shaderStages) hash = hashCombine(hash, g);
auto it = mPipelineCache.find(hash);
if (it != mPipelineCache.end()) return it->second;
uint32_t pipeline = ++mNextPipeline; // 模拟 vkCreateGraphicsPipelines
mPipelineCache[hash] = pipeline;
return pipeline;
}
std::unordered_map<uint32_t, uint32_t> mPipelineCache;
uint32_t mNextPipeline = 0;
};
class FakeFence {
public:
bool isFinished() const { return mSignaled; }
void signal() { mSignaled = true; }
private:
bool mSignaled = true;
};
} // namespace ogre_repro
int main() {
using namespace ogre_repro;
// deriveStageFromBufferAccessFlags
CHECK(deriveStageFromBufferAccessFlags(VK_ACCESS_UNIFORM_READ_BIT) ==
VK_PIPELINE_STAGE_VERTEX_SHADER_BIT);
CHECK(deriveStageFromBufferAccessFlags(VK_ACCESS_INDIRECT_COMMAND_READ_BIT) ==
VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT);
CHECK(deriveStageFromBufferAccessFlags(VK_ACCESS_TRANSFER_WRITE_BIT) ==
VK_PIPELINE_STAGE_TRANSFER_BIT);
CHECK(deriveStageFromBufferAccessFlags(VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_UNIFORM_READ_BIT) ==
(VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_VERTEX_SHADER_BIT));
// 管线哈希缓存:同状态命中,不同状态新建
VulkanRenderSystem rs;
PipelineState a, b;
a.attribs = {0, 2};
b.attribs = {0, 3};
uint32_t p1 = rs.getPipeline(a);
CHECK_EQ(p1, uint32_t(1));
CHECK_EQ(rs.getPipeline(a), p1); // 命中缓存
CHECK_EQ(rs.getPipeline(b), uint32_t(2)); // 不同状态新建
CHECK_EQ(rs.mPipelineCache.size(), size_t(2));
// fence 同步:完成即返回,未完成需等待
FakeFence fence;
CHECK(fence.isFinished());
fence.signal();
CHECK(fence.isFinished());
return lab::report("08-3 Vulkan 管线与同步");
}
本机实测(Apple clang 16,clang++ -std=c++20):编译通过(-Wall 零警告),断言 10/10 通过。
小结
getPipeline把 renderPass/混合/光栅/装配/多采样/顶点格式/着色器阶段逐一哈希,mPipelineCache命中即复用,省去vkCreateGraphicsPipelines的昂贵编译。deriveStageFromBufferAccessFlags用纯位运算把缓冲访问位映射成管线阶段位,服务内存屏障的 src/dstStage。- fence 同步提供阻塞(
_waitOnFrame)与非阻塞(_isFrameFinished)两种查询,配合 buffer graveyard 保证 GPU 用完才释放。
阅读导航:上一节:8.2 Vulkan 命令缓冲 · 下一节:9.1 Metal 渲染系统 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。