《OGRE 3D 渲染引擎原理与架构》8.3 Vulkan 管线与同步

Vulkan 图形管线的构建成本高,OGRE 用 getPipeline 把 renderPass/混合/光栅化/输入装配/多采样/顶点格式/着色器阶段哈希后查 mPipelineCache,命中直接复用;VulkanQueue::deriveStageFromBufferAccessFlags 把缓冲访问位推导成管线阶段位;fence 用阻塞与非阻塞两种方式查询 GPU 完成状态。lab 复现管线哈希缓存与阶段推导。

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 即完成」的语义。

源码定位

上游引用固定到 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 渲染系统 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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