《OGRE 3D 渲染引擎原理与架构》8.2 Vulkan 后端

VulkanRenderSystem 用 VulkanDevice 封装实例与队列:队列族选择遍历 mQueueProps,graphics 必须存在、compute 按需、transfer 只要独立队列族,fillQueueCreationInfo 共享 used 计数生成 VkDeviceQueueCreateInfo。lab 复现队列族选择与失败路径。

8.2 Vulkan 后端

OGRE 的 Vulkan 后端把一个 VulkanRenderSystem 拆成两层:渲染系统本身负责实例、管线与绘制状态;VulkanDevice 封装 Vulkan 设备对象,其中队列族选择是最能体现 Vulkan 心智模型的部分——一个物理设备有若干队列族,每个族若干条队列,能力由 VkQueueFlags 位掩码描述。

本章与站内既有内容的分工

8.1 的 GLES2 后端用 GL 字符串探测能力;Vulkan 不同——能力分布信息来自显式的队列族属性与物理设备特性,OGRE 用 VulkanDevice 集中管理。8.3 的 Metal/D3D11 又是另外两套 API 风格。lab 聚焦队列族选择的纯逻辑(位掩码 + 计数分配),不调用 Vulkan API。

设备封装:VulkanDevice 的成员

VulkanDevice 是一个结构体风格的对象:mInstance/mPhysicalDevice/mDevice 是 Vulkan 句柄,mGraphicsQueue/mComputeQueues/mTransferQueues 保存选中的队列,mQueueProps 是从 vkGetPhysicalDeviceQueueFamilyProperties 取得的族属性数组:

// RenderSystems/Vulkan/include/OgreVulkanDevice.h:VulkanDevice(v14.6.3 源码摘录,已删减)
    struct _OgreVulkanExport VulkanDevice
    {
        struct SelectedQueue
        {
            VulkanQueue::QueueFamily usage;
            uint32 familyIdx;
            uint32 queueIdx;
            SelectedQueue();
        };

        // clang-format off
        VkInstance          mInstance;
        VkPhysicalDevice    mPhysicalDevice;
        VkDevice            mDevice;

        VmaAllocator        mVmaAllocator;

        VkQueue             mPresentQueue;
        /// Graphics queue is *guaranteed by spec* to also be able to run compute and transfer
        /// A GPU may not have a graphics queue though (Ogre can't run there)
        VulkanQueue             mGraphicsQueue;
        /// Additional compute queues to run async compute (besides the main graphics one)
        FastArray<VulkanQueue>  mComputeQueues;
        /// Additional transfer queues to run async transfers (besides the main graphics one)
        FastArray<VulkanQueue>  mTransferQueues;
        // clang-format on

        VkPhysicalDeviceProperties mDeviceProperties;
        VkPhysicalDeviceMemoryProperties mDeviceMemoryProperties;
        VkPhysicalDeviceFeatures mDeviceFeatures;
        FastArray<VkQueueFamilyProperties> mQueueProps;

        VulkanRenderSystem *mRenderSystem;

        uint32 mSupportedStages;

        static void destroyQueues( FastArray<VulkanQueue> &queueArray );

        void findGraphicsQueue( FastArray<uint32> &inOutUsedQueueCount );
        void findComputeQueue( FastArray<uint32> &inOutUsedQueueCount, uint32 maxNumQueues );
        void findTransferQueue( FastArray<uint32> &inOutUsedQueueCount, uint32 maxNumQueues );
...
    };

注释点明了三条队列的语义:graphics 队列按 Vulkan 规范必然也能跑 compute 与 transfer;一个 GPU 可能没有 graphics 队列,那样的设备 OGRE 用不了;compute/transfer 队列是「额外」的异步加速队列。

队列族选择:位掩码与 used 计数

fillQueueCreationInfo 先按族数初始化 usedQueueCount 全 0,再依次调三个 find 函数。usedQueueCount[i] 记录族 i 已被取走的队列数,保证同一族不会重复分配同一队列索引:

// RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:VulkanDevice::fillQueueCreationInfo(v14.6.3 源码摘录,已删减)
    void VulkanDevice::fillQueueCreationInfo( uint32 maxComputeQueues, uint32 maxTransferQueues,
                                              FastArray<VkDeviceQueueCreateInfo> &outQueueCiArray )
    {
        const size_t numQueueFamilies = mQueueProps.size();

        FastArray<uint32> usedQueueCount;
        usedQueueCount.resize( numQueueFamilies, 0u );

        findGraphicsQueue( usedQueueCount );
        findComputeQueue( usedQueueCount, maxComputeQueues );
        findTransferQueue( usedQueueCount, maxTransferQueues );

        VkDeviceQueueCreateInfo queueCi = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO};
        for( size_t i = 0u; i < numQueueFamilies; ++i )
        {
            queueCi.queueFamilyIndex = static_cast<uint32>( i );
            queueCi.queueCount = usedQueueCount[i];
            if( queueCi.queueCount > 0u )
                outQueueCiArray.push_back( queueCi );
        }
    }

findGraphicsQueue 是「必须成功」的一步:遍历所有族,遇到带 VK_QUEUE_GRAPHICS_BIT 且尚未用满(usedQueueCount[i] < queueCount)的族就占用它当前可用的队列索引,然后返回;如果全部族都不提供 graphics,直接抛 ERR_RENDERINGAPI_ERROR:

// RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:VulkanDevice::findGraphicsQueue(v14.6.3 源码摘录,已删减)
    void VulkanDevice::findGraphicsQueue( FastArray<uint32> &inOutUsedQueueCount )
    {
        const size_t numQueues = mQueueProps.size();
        for( size_t i = 0u; i < numQueues; ++i )
        {
            if( mQueueProps[i].queueFlags & VK_QUEUE_GRAPHICS_BIT &&
                inOutUsedQueueCount[i] < mQueueProps[i].queueCount )
            {
                mGraphicsQueue.setQueueData( this, VulkanQueue::Graphics, static_cast<uint32>( i ),
                                             inOutUsedQueueCount[i] );
                ++inOutUsedQueueCount[i];
                return;
            }
        }

        OGRE_EXCEPT( Exception::ERR_RENDERINGAPI_ERROR,
                     "GPU does not expose Graphics queue. Cannot be used for rendering",
                     "VulkanQueue::findGraphicsQueue" );
    }

compute 与 transfer:可选但克制

findComputeQueue 与 findTransferQueue 是「有多少取多少」但受两个上限约束:maxNumQueues 限制总数,queueCount 限制单族。注意两个关键差异——compute 队列可以落在同时带 graphics 的族上(graphics 队列已能跑 compute,额外要的只是并行性),而 transfer 队列要求独立的族:!(flags & (GRAPHICS|COMPUTE)):

// RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:VulkanDevice::findComputeQueue / findTransferQueue(v14.6.3 源码摘录,已删减)
    void VulkanDevice::findComputeQueue( FastArray<uint32> &inOutUsedQueueCount, uint32 maxNumQueues )
    {
        const size_t numQueues = mQueueProps.size();
        for( size_t i = 0u; i < numQueues && mComputeQueues.size() < maxNumQueues; ++i )
        {
            if( mQueueProps[i].queueFlags & VK_QUEUE_COMPUTE_BIT &&
                inOutUsedQueueCount[i] < mQueueProps[i].queueCount )
            {
                mComputeQueues.push_back( VulkanQueue() );
                mComputeQueues.back().setQueueData( this, VulkanQueue::Compute, static_cast<uint32>( i ),
                                                    inOutUsedQueueCount[i] );
                ++inOutUsedQueueCount[i];
            }
        }
    }
    //-------------------------------------------------------------------------
    void VulkanDevice::findTransferQueue( FastArray<uint32> &inOutUsedQueueCount, uint32 maxNumQueues )
    {
        const size_t numQueues = mQueueProps.size();
        for( size_t i = 0u; i < numQueues && mTransferQueues.size() < maxNumQueues; ++i )
        {
            if( mQueueProps[i].queueFlags & VK_QUEUE_TRANSFER_BIT &&
                !( mQueueProps[i].queueFlags & ( VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT ) ) &&
                inOutUsedQueueCount[i] < mQueueProps[i].queueCount )
            {
                mTransferQueues.push_back( VulkanQueue() );
                mTransferQueues.back().setQueueData( this, VulkanQueue::Transfer,
                                                     static_cast<uint32>( i ), inOutUsedQueueCount[i] );
                ++inOutUsedQueueCount[i];
            }
        }
    }

循环条件 i < numQueues && mComputeQueues.size() < maxNumQueues 意味着每个队列族至多贡献一条队列(同一族即使 queueCount 很大也只 push 一次)。usedQueueCount 让 graphics 与 compute 落在同一族时队列索引错开:graphics 占 0,compute 占 1。

渲染系统:实例、设备与管线缓存

VulkanRenderSystem 持有 VkInstance mVkInstance、VulkanDevice* mDevice,以及一系列管线/描述符缓存表。管线创建信息(pipelineCi、blendStateCi、rasterState 等)作为成员被复用,避免每帧重复构造:

// RenderSystems/Vulkan/include/OgreVulkanRenderSystem.h:VulkanRenderSystem(v14.6.3 源码摘录,已删减)
    class _OgreVulkanExport VulkanRenderSystem : public RenderSystem
    {
        friend class VulkanSampler;
        bool mInitialized;
        VulkanHardwareBufferManager *mHardwareBufferManager;

        VkBuffer mIndirectBuffer;
        unsigned char *mSwIndirectBufferPtr;

        VulkanProgramFactory *mSPIRVProgramFactory;

        VkInstance mVkInstance;

        std::vector<String> mDevices;

        HardwareBufferPtr mAutoParamsBuffer;
        uint32 mAutoParamsBufferPos;
        std::vector<uint32> mAutoParamsBufferUsage;

        void resizeAutoParamsBuffer(size_t size);

        VulkanDevice *mActiveDevice;

        VulkanDevice *mDevice;
...
        void addInstanceDebugCallback( void );

        void flushRootLayout( void );

        // Pipeline State Infos
        VkGraphicsPipelineCreateInfo pipelineCi;
        VkPipelineLayoutCreateInfo pipelineLayoutCi;
        VkPipelineVertexInputStateCreateInfo vertexFormatCi;
        VkPipelineInputAssemblyStateCreateInfo inputAssemblyCi;
        VkPipelineMultisampleStateCreateInfo mssCi;
        VkPipelineRasterizationStateCreateInfo rasterState;
        VkPipelineColorBlendStateCreateInfo blendStateCi;
...
        std::unordered_map<uint32, VkDescriptorSet> mDescriptorSetCache;
        std::unordered_map<uint32, VkRenderPass> mRenderPassCache;
        std::unordered_map<uint32, VkPipeline> mPipelineCache;
...
        void initializeVkInstance( void );
        void enumerateDevices();
        uint32 getSelectedDeviceIdx() const;

mDevice 是主设备,mActiveDevice 支持多设备切换(如跨 GPU 渲染);mPipelineCache 按 hash 缓存 VkPipeline,避免状态组合重复创建管线。createInstance/enumerateDevices 完成实例与设备枚举。

源码定位

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

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

下面复现 VulkanDevice 的队列族选择:位掩码匹配、usedQueueCount 共享计数、每族至多一条、无 graphics 族失败路径、fillQueueCreationInfo 只生成使用中族的 VkDeviceQueueCreateInfo。它与 src/ogre-ext-08-2-vulkan-backend.cpp 逐字节一致:

// file: src/ogre-ext-08-2-vulkan-backend.cpp
// tier: L1
// verify: clang++ -std=c++20 -I. src/ogre-ext-08-2-vulkan-backend.cpp -o bin/ogre-ext-08-2-vulkan-backend && ./bin/ogre-ext-08-2-vulkan-backend
//
// 复现 VulkanDevice 的队列族选择
// (对应 OgreVulkanDevice.cpp 161-234、OgreVulkanDevice.h 42-109):
//   findGraphicsQueue 找带 VK_QUEUE_GRAPHICS_BIT 且未用完的队列族(没有则失败);
//   findComputeQueue 找 VK_QUEUE_COMPUTE_BIT,受 maxNumQueues 与 queueCount 双重限制;
//   findTransferQueue 只要 VK_QUEUE_TRANSFER_BIT 且不带 GRAPHICS/COMPUTE 的独立队列;
//   fillQueueCreationInfo 共享 usedQueueCount 计数,只为使用中的队列族生成 VkDeviceQueueCreateInfo。
// 独立最小验证,非 OGRE 源码。
#include "verify.h"

#include <cstdint>
#include <vector>

namespace ogre_repro {

// VkQueueFlagBits(Vulkan 标准位掩码)
enum QueueFlag : uint32_t {
  VK_QUEUE_GRAPHICS_BIT = 0x1,
  VK_QUEUE_COMPUTE_BIT = 0x2,
  VK_QUEUE_TRANSFER_BIT = 0x4,
  VK_QUEUE_SPARSE_BINDING_BIT = 0x8
};

// 对应 VkQueueFamilyProperties 的队列族属性
struct QueueFamilyProps {
  uint32_t flags;      // queueFlags
  uint32_t queueCount; // queueCount
};

// 对应 VkDeviceQueueCreateInfo(仅记录 family 与数量)
struct QueueCi {
  uint32_t familyIdx;
  uint32_t queueCount;
};

// 对应 VulkanQueue(OgreVulkanQueue.h 简化)
class VulkanQueue {
 public:
  void setQueueData(uint32_t familyIdx, uint32_t queueIdx) {
    mFamily = familyIdx;
    mQueue = queueIdx;
  }
  uint32_t family() const { return mFamily; }
  uint32_t queue() const { return mQueue; }
  bool valid() const { return mFamily != kInvalid; }

 private:
  static constexpr uint32_t kInvalid = 0xFFFFFFFFu;
  uint32_t mFamily = kInvalid;
  uint32_t mQueue = 0;
};

// 对应 VulkanDevice(OgreVulkanDevice.h 42-109)
class VulkanDevice {
 public:
  explicit VulkanDevice(const std::vector<QueueFamilyProps>& props) : mQueueProps(props) {}

  // findGraphicsQueue(OgreVulkanDevice.cpp 161-179)
  void findGraphicsQueue(std::vector<uint32_t>& usedQueueCount) {
    const size_t numQueues = mQueueProps.size();
    for (size_t i = 0; i < numQueues; ++i) {
      if (mQueueProps[i].flags & VK_QUEUE_GRAPHICS_BIT &&
          usedQueueCount[i] < mQueueProps[i].queueCount) {
        mGraphicsQueue.setQueueData(static_cast<uint32_t>(i), usedQueueCount[i]);
        ++usedQueueCount[i];
        return;
      }
    }
    mGraphicsFailed = true;  // 对应 OGRE_EXCEPT "GPU does not expose Graphics queue"
  }
  // findComputeQueue(OgreVulkanDevice.cpp 181-195)
  void findComputeQueue(std::vector<uint32_t>& usedQueueCount, uint32_t maxNumQueues) {
    const size_t numQueues = mQueueProps.size();
    for (size_t i = 0; i < numQueues && mComputeQueues.size() < maxNumQueues; ++i) {
      if (mQueueProps[i].flags & VK_QUEUE_COMPUTE_BIT &&
          usedQueueCount[i] < mQueueProps[i].queueCount) {
        mComputeQueues.emplace_back();
        mComputeQueues.back().setQueueData(static_cast<uint32_t>(i), usedQueueCount[i]);
        ++usedQueueCount[i];
      }
    }
  }
  // findTransferQueue(OgreVulkanDevice.cpp 197-212)
  void findTransferQueue(std::vector<uint32_t>& usedQueueCount, uint32_t maxNumQueues) {
    const size_t numQueues = mQueueProps.size();
    for (size_t i = 0; i < numQueues && mTransferQueues.size() < maxNumQueues; ++i) {
      if (mQueueProps[i].flags & VK_QUEUE_TRANSFER_BIT &&
          !(mQueueProps[i].flags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT)) &&
          usedQueueCount[i] < mQueueProps[i].queueCount) {
        mTransferQueues.emplace_back();
        mTransferQueues.back().setQueueData(static_cast<uint32_t>(i), usedQueueCount[i]);
        ++usedQueueCount[i];
      }
    }
  }
  // fillQueueCreationInfo(OgreVulkanDevice.cpp 214-234)
  std::vector<QueueCi> fillQueueCreationInfo(uint32_t maxComputeQueues, uint32_t maxTransferQueues) {
    std::vector<uint32_t> usedQueueCount(mQueueProps.size(), 0u);
    findGraphicsQueue(usedQueueCount);
    findComputeQueue(usedQueueCount, maxComputeQueues);
    findTransferQueue(usedQueueCount, maxTransferQueues);

    std::vector<QueueCi> out;
    for (size_t i = 0; i < mQueueProps.size(); ++i) {
      if (usedQueueCount[i] > 0u) out.push_back(QueueCi{static_cast<uint32_t>(i), usedQueueCount[i]});
    }
    return out;
  }

  const VulkanQueue& graphicsQueue() const { return mGraphicsQueue; }
  const std::vector<VulkanQueue>& computeQueues() const { return mComputeQueues; }
  const std::vector<VulkanQueue>& transferQueues() const { return mTransferQueues; }
  bool graphicsFailed() const { return mGraphicsFailed; }

 private:
  std::vector<QueueFamilyProps> mQueueProps;  // 对应 FastArray<VkQueueFamilyProperties> mQueueProps
  VulkanQueue mGraphicsQueue;
  std::vector<VulkanQueue> mComputeQueues;   // 对应 FastArray<VulkanQueue> mComputeQueues
  std::vector<VulkanQueue> mTransferQueues;  // 对应 FastArray<VulkanQueue> mTransferQueues
  bool mGraphicsFailed = false;
};

}  // namespace ogre_repro

int main() {
  using namespace ogre_repro;

  // 单队列族同时具备 graphics+compute+transfer:graphics 选中它,queue idx 从 0 起
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT, 2}});
    auto ci = dev.fillQueueCreationInfo(1, 1);
    CHECK(!dev.graphicsFailed());
    CHECK(dev.graphicsQueue().family() == 0);
    CHECK(dev.graphicsQueue().queue() == 0);
    CHECK(ci.size() == 1);
    CHECK(ci[0].familyIdx == 0);
    CHECK(ci[0].queueCount == 2);  // graphics + compute 各占 1
  }

  // 独立 transfer 队列族:transfer 不选 graphics 族,落到纯 transfer 族
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, 1},
                      {VK_QUEUE_TRANSFER_BIT, 1}});
    dev.fillQueueCreationInfo(1, 1);
    CHECK(!dev.graphicsFailed());
    CHECK(dev.graphicsQueue().family() == 0);
    CHECK(dev.transferQueues().size() == 1);
    CHECK(dev.transferQueues()[0].family() == 1);  // 独立 transfer 族
  }

  // 没有 graphics 队列族:启动失败(OGRE_EXCEPT)
  {
    VulkanDevice dev({{VK_QUEUE_COMPUTE_BIT, 1}});
    dev.fillQueueCreationInfo(0, 0);
    CHECK(dev.graphicsFailed());
  }

  // compute 队列:每个队列族至多取 1 条,maxNumQueues 限制总条数
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT, 1},
                      {VK_QUEUE_COMPUTE_BIT, 3},
                      {VK_QUEUE_COMPUTE_BIT, 3}});
    auto ci = dev.fillQueueCreationInfo(2, 0);
    CHECK(dev.computeQueues().size() == 2);  // family1 + family2 各 1 条
    CHECK(dev.computeQueues()[0].family() == 1);
    CHECK(dev.computeQueues()[0].queue() == 0);
    CHECK(dev.computeQueues()[1].family() == 2);
    CHECK(dev.computeQueues()[1].queue() == 0);
    CHECK(ci.size() == 3);  // family0(graphics) + 两个 compute 族
  }

  // maxNumQueues = 0:不创建 compute 队列
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT, 1}, {VK_QUEUE_COMPUTE_BIT, 3}});
    dev.fillQueueCreationInfo(0, 0);
    CHECK(dev.computeQueues().empty());
  }

  // queueCount 是硬上限:compute 族只有 1 条队列时最多取 1
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT, 1}, {VK_QUEUE_COMPUTE_BIT, 1}});
    dev.fillQueueCreationInfo(4, 0);
    CHECK(dev.computeQueues().size() == 1);
  }

  // graphics 与 compute 同族复用 used 计数:graphics 取 idx0,compute 取 idx1
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT, 2}});
    dev.fillQueueCreationInfo(1, 0);
    CHECK(dev.graphicsQueue().queue() == 0);
    CHECK(dev.computeQueues()[0].family() == 0);
    CHECK(dev.computeQueues()[0].queue() == 1);
  }

  // 三族齐全:graphics/compute/transfer 各自归属不同 family
  {
    VulkanDevice dev({{VK_QUEUE_GRAPHICS_BIT, 1},
                      {VK_QUEUE_COMPUTE_BIT, 1},
                      {VK_QUEUE_TRANSFER_BIT, 1}});
    auto ci = dev.fillQueueCreationInfo(1, 1);
    CHECK(dev.graphicsQueue().family() == 0);
    CHECK(dev.computeQueues().size() == 1);
    CHECK(dev.computeQueues()[0].family() == 1);
    CHECK(dev.transferQueues().size() == 1);
    CHECK(dev.transferQueues()[0].family() == 2);
    CHECK(ci.size() == 3);
    CHECK(ci[0].queueCount == 1);
    CHECK(ci[2].queueCount == 1);
  }

  return lab::report("08-2 Vulkan 后端");
}

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

小结

  • VulkanDevice 封装实例/物理设备/设备句柄与三类队列;mQueueProps 保存队列族属性。
  • findGraphicsQueue 必须成功:带 graphics 位的族任选一个,无 graphics 族则抛异常。
  • findComputeQueue 受 maxNumQueues 与 queueCount 双重限制,每族至多取一条。
  • findTransferQueue 只接受独立队列族(不带 graphics/compute 位)。
  • fillQueueCreationInfo 用共享 usedQueueCount 保证同一族内队列索引错开,只为使用中的族生成 VkDeviceQueueCreateInfo。
  • VulkanRenderSystem 复用 VkGraphicsPipelineCreateInfo 等状态结构并缓存 VkPipeline。

阅读导航:上一节:8.1 GLES2 后端 · 下一节:8.3 Metal 与 D3D11 后端 。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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