pick_physical_device()

bool MayaFlux::Core::VKDevice::pick_physical_device ( vk::Instance  instance, const GraphicsBackendInfo &  backend_info  )

private

Select a physical device by config selector or score.

Parameters

instance	Vulkan instance
backend_info	Graphics backend configuration

Returns

true if a suitable device was found

Definition at line 265 of file VKDevice.cpp.

{
    auto devices = instance.enumeratePhysicalDevices();
 
    if (devices.empty()) {
        error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "Failed to find GPUs with Vulkan support!");
    }
 
    const PresentationProbe probe(instance);
 
    if (backend_info.require_presentation && !probe.available) {
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "Presentation support cannot be verified on this platform; "
            "device selection will not filter on it");
    }
 
    std::vector<DeviceCandidate> candidates;
    candidates.reserve(devices.size());
 
    for (uint32_t i = 0; i < devices.size(); ++i) {
        const auto& device = devices[i];
 
        DeviceCandidate cand;
        cand.device = device;
        cand.index = i;
 
        auto available_extensions = device.enumerateDeviceExtensionProperties();
        bool has_pci_ext = false;
 
        for (const auto& ext : available_extensions) {
            if (strcmp(ext.extensionName, VK_KHR_SWAPCHAIN_EXTENSION_NAME) == 0)
                cand.has_swapchain = true;
            if (strcmp(ext.extensionName, VK_EXT_MESH_SHADER_EXTENSION_NAME) == 0)
                cand.has_mesh_shader = true;
            if (strcmp(ext.extensionName, VK_EXT_PCI_BUS_INFO_EXTENSION_NAME) == 0)
                has_pci_ext = true;
        }
 
        auto prop_chain = vk::StructureChain {
            vk::PhysicalDeviceProperties2 {},
            vk::PhysicalDeviceVulkan11Properties {},
            vk::PhysicalDeviceVulkan12Properties {},
            vk::PhysicalDevicePCIBusInfoPropertiesEXT {}
        };
 
        if (!has_pci_ext) {
            prop_chain.unlink<vk::PhysicalDevicePCIBusInfoPropertiesEXT>();
        }
 
        device.getProperties2(&prop_chain.get<vk::PhysicalDeviceProperties2>());
 
        const auto& props = prop_chain.get<vk::PhysicalDeviceProperties2>().properties;
        const auto& props11 = prop_chain.get<vk::PhysicalDeviceVulkan11Properties>();
        const auto& props12 = prop_chain.get<vk::PhysicalDeviceVulkan12Properties>();
 
        cand.name = props.deviceName.data();
        cand.type = props.deviceType;
        cand.api_version = props.apiVersion;
        cand.driver_id = props12.driverID;
        cand.driver_name = props12.driverName.data();
        std::copy_n(props11.deviceUUID.data(), VK_UUID_SIZE, cand.uuid.begin());
        cand.uuid_hex = uuid_to_hex(cand.uuid.data());
 
        if (has_pci_ext) {
            cand.has_pci_info = true;
            cand.pci_bus = prop_chain.get<vk::PhysicalDevicePCIBusInfoPropertiesEXT>().pciBus;
        }
 
        auto memory_props = device.getMemoryProperties();
        for (uint32_t h = 0; h < memory_props.memoryHeapCount; ++h) {
            if (memory_props.memoryHeaps[h].flags & vk::MemoryHeapFlagBits::eDeviceLocal) {
                cand.device_local_bytes = std::max(cand.device_local_bytes,
                    static_cast<uint64_t>(memory_props.memoryHeaps[h].size));
            }
        }
 
        cand.families = find_queue_families(device);
 
        if (cand.has_mesh_shader) {
            vk::PhysicalDeviceMeshShaderFeaturesEXT mesh_features;
            vk::PhysicalDeviceFeatures2 features;
            features.pNext = &mesh_features;
            device.getFeatures2(&features);
 
            cand.has_mesh_shader = mesh_features.meshShader == VK_TRUE
                && mesh_features.taskShader == VK_TRUE;
        }
 
        {
            auto family_props = device.getQueueFamilyProperties();
            const uint32_t probe_count = std::min<uint32_t>(static_cast<uint32_t>(family_props.size()), QueueFamilyIndices::MAX_TRACKED_FAMILIES);
 
            for (uint32_t f = 0; f < probe_count; ++f) {
                if (probe.supports(device, f))
                    cand.present_family_mask |= (1U << f);
            }
 
            cand.families.present_family_mask = cand.present_family_mask;
 
            if (cand.families.graphics_family.has_value())
                cand.graphics_presents = cand.families.can_present(cand.families.graphics_family.value());
        }
 
        if (!cand.families.graphics_family.has_value()) {
            cand.reject_reason = "no graphics queue family";
        } else if (cand.api_version < VK_API_VERSION_1_3) {
            cand.reject_reason = "device API version below 1.3";
        } else if (!cand.has_swapchain) {
            cand.reject_reason = "no VK_KHR_swapchain";
        } else if (backend_info.require_presentation && !cand.graphics_presents) {
            cand.reject_reason = "graphics family cannot present";
        }
 
        cand.score = type_base_score(cand.type);
 
        switch (backend_info.device_preference) {
        case GraphicsBackendInfo::DevicePreference::DISCRETE:
            if (cand.type == vk::PhysicalDeviceType::eDiscreteGpu)
                cand.score += 10000;
            break;
        case GraphicsBackendInfo::DevicePreference::INTEGRATED:
            if (cand.type == vk::PhysicalDeviceType::eIntegratedGpu)
                cand.score += 10000;
            break;
        case GraphicsBackendInfo::DevicePreference::VIRTUAL:
            if (cand.type == vk::PhysicalDeviceType::eVirtualGpu)
                cand.score += 10000;
            break;
        case GraphicsBackendInfo::DevicePreference::EXTERNAL:
            if (cand.type == vk::PhysicalDeviceType::eDiscreteGpu) {
                cand.score += 10000;
                if (cand.has_pci_info)
                    cand.score += static_cast<int64_t>(cand.pci_bus) * 4;
            }
            break;
        case GraphicsBackendInfo::DevicePreference::AUTO:
        default:
            break;
        }
 
        if (cand.graphics_presents)
            cand.score += 500;
        if (cand.has_mesh_shader)
            cand.score += 100;
 
        cand.score += static_cast<int64_t>(cand.device_local_bytes >> 30U);
 
        candidates.push_back(std::move(cand));
    }
 
    for (const auto& cand : candidates) {
        MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "GPU [{}] {} | type={} driver={} ({}) api={}.{}.{} | uuid={} | "
            "gfx={} compute={} transfer={} | present=gfx:{} mask:{:#x} mesh={} vram={}MB pci_bus={} | score={}{}{}",
            cand.index, cand.name, vk::to_string(cand.type),
            vk::to_string(cand.driver_id), cand.driver_name,
            VK_API_VERSION_MAJOR(cand.api_version),
            VK_API_VERSION_MINOR(cand.api_version),
            VK_API_VERSION_PATCH(cand.api_version),
            cand.uuid_hex,
            cand.families.graphics_family.has_value() ? std::to_string(cand.families.graphics_family.value()) : "none",
            cand.families.compute_family.has_value() ? std::to_string(cand.families.compute_family.value()) : "none",
            cand.families.transfer_family.has_value() ? std::to_string(cand.families.transfer_family.value()) : "none",
            cand.graphics_presents ? "yes" : "no",
            cand.present_family_mask,
            cand.has_mesh_shader ? "yes" : "no",
            cand.device_local_bytes >> 20U,
            cand.has_pci_info ? std::to_string(cand.pci_bus) : "n/a",
            cand.score,
            cand.viable() ? "" : " | REJECTED: ",
            cand.reject_reason ? cand.reject_reason : "");
    }
 
    MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Presentation probe mechanism: {}, require_presentation={}, device_preference={}",
        probe.mechanism, backend_info.require_presentation ? "true" : "false",
        Reflect::enum_to_string(backend_info.device_preference));
 
    int32_t want_index = backend_info.device_index;
    std::string want_name = backend_info.device_name;
    std::string want_uuid = backend_info.device_uuid;
 
    if (int32_t env_index = -1; read_gpu_env(env_index, want_name)) {
        want_index = env_index;
        want_uuid.clear();
        MF_INFO(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "MAYAFLUX_GPU override active (index={}, name='{}')", want_index, want_name);
    }
 
    const DeviceCandidate* selected = nullptr;
    const char* selection_basis = "score";
 
    if (want_index >= 0) {
        for (const auto& cand : candidates) {
            if (static_cast<int32_t>(cand.index) == want_index && cand.viable()) {
                selected = &cand;
                selection_basis = "device_index";
                break;
            }
        }
    }
 
    if (!selected && !want_uuid.empty()) {
        for (const auto& cand : candidates) {
            if (cand.uuid_hex == want_uuid && cand.viable()) {
                selected = &cand;
                selection_basis = "device_uuid";
                break;
            }
        }
    }
 
    if (!selected && !want_name.empty()) {
        for (const auto& cand : candidates) {
            if (!cand.viable() || !contains_nocase(cand.name, want_name))
                continue;
            if (!selected || cand.score > selected->score) {
                selected = &cand;
                selection_basis = "device_name";
            }
        }
    }
 
    const bool selector_requested = want_index >= 0 || !want_uuid.empty() || !want_name.empty();
 
    if (selector_requested && !selected) {
        if (backend_info.strict_device_selection) {
            error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
                std::source_location::current(),
                "No viable physical device matched the requested selector "
                "(index={}, uuid='{}', name='{}') and strict_device_selection is set",
                want_index, want_uuid, want_name);
        }
 
        MF_WARN(Journal::Component::Core, Journal::Context::GraphicsBackend,
            "No viable physical device matched the requested selector "
            "(index={}, uuid='{}', name='{}'); falling back to score",
            want_index, want_uuid, want_name);
    }
 
    if (!selected) {
        for (const auto& cand : candidates) {
            if (!cand.viable())
                continue;
            if (!selected || cand.score > selected->score)
                selected = &cand;
        }
    }
 
    if (!selected) {
        error<std::runtime_error>(Journal::Component::Core, Journal::Context::GraphicsBackend,
            std::source_location::current(),
            "No suitable GPU found among {} enumerated device(s); "
            "see the candidate list above for rejection reasons",
            candidates.size());
    }
 
    m_physical_device = selected->device;
    m_queue_families = selected->families;
    m_supports_mesh_shaders = selected->has_mesh_shader;
    m_graphics_presents = selected->graphics_presents;
    m_device_name = selected->name;
    m_device_uuid = selected->uuid;
 
    MF_LOG(Journal::Component::Core, Journal::Context::GraphicsBackend,
        "Selected GPU [{}] {} by {} (uuid={}, score={})",
        selected->index, selected->name, selection_basis, selected->uuid_hex, selected->score);
 
    return true;
}

References MayaFlux::Core::GraphicsBackendInfo::AUTO, MayaFlux::Journal::Core, device, MayaFlux::Core::GraphicsBackendInfo::device_index, MayaFlux::Core::GraphicsBackendInfo::device_name, MayaFlux::Core::GraphicsBackendInfo::device_preference, MayaFlux::Core::GraphicsBackendInfo::device_uuid, MayaFlux::Core::GraphicsBackendInfo::DISCRETE, MayaFlux::Reflect::enum_to_string(), MayaFlux::Core::GraphicsBackendInfo::EXTERNAL, find_queue_families(), MayaFlux::Journal::GraphicsBackend, h, instance, MayaFlux::Core::GraphicsBackendInfo::INTEGRATED, m_device_name, m_device_uuid, m_graphics_presents, m_physical_device, m_queue_families, m_supports_mesh_shaders, MayaFlux::Core::QueueFamilyIndices::MAX_TRACKED_FAMILIES, MF_INFO, MF_LOG, MF_WARN, MayaFlux::Core::GraphicsBackendInfo::require_presentation, MayaFlux::Core::GraphicsBackendInfo::strict_device_selection, and MayaFlux::Core::GraphicsBackendInfo::VIRTUAL.

Referenced by initialize().

Here is the call graph for this function:

Here is the caller graph for this function: