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 完成实例与设备枚举。
源码定位
RenderSystems/Vulkan/include/OgreVulkanDevice.h:VulkanDevice(42-109)、findGraphicsQueue/findComputeQueue/findTransferQueue(80-82)、createInstance(91-93)RenderSystems/Vulkan/src/OgreVulkanDevice.cpp:findGraphicsQueue(161-179)、findComputeQueue(181-195)、findTransferQueue(197-212)、fillQueueCreationInfo(214-234)RenderSystems/Vulkan/include/OgreVulkanRenderSystem.h:VulkanRenderSystem(53-220)、管线缓存成员(96-128)RenderSystems/Vulkan/src/OgreVulkanRenderSystem.cpp:initializeVkInstance、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 后端 。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。