Get information about the Vulkan driver. More...

#include <driver_info_vk.h>

Public Member Functions
	DriverInfoVK (const vk::PhysicalDevice &device)

	~DriverInfoVK ()

	DriverInfoVK (const DriverInfoVK &)=delete

DriverInfoVK &	operator= (const DriverInfoVK &)=delete

const Version &	GetAPIVersion () const
	Gets the Vulkan API version. Should be at or above Vulkan 1.1 which is the Impeller baseline. More...

const VendorVK &	GetVendor () const
	Get the vendor of the Vulkan implementation. This is a broad check and includes multiple drivers and platforms. More...

const DeviceTypeVK &	GetDeviceType () const
	Get the device type. Typical use might be to check if the device is a CPU implementation. More...

const std::string &	GetDriverName () const
	Get the self-reported name of the graphics driver. More...

void	DumpToLog () const
	Dumps the current driver info to the log. More...

bool	IsEmulator () const
	Determines if the driver represents an emulator. There is no definitive way to tell if a driver is an emulator and drivers don't self identify as emulators. So take this information with a pinch of salt. More...

bool	IsKnownBadDriver () const
	Determines if the driver has been tested and determined to be non-functional. More...

std::optional< MaliGPU >	GetMaliGPUInfo () const
	Returns Mali GPU info if this is a Mali GPU, otherwise std::nullopt. More...

std::optional< AdrenoGPU >	GetAdrenoGPUInfo () const
	Returns Adreno GPU info if this is a Adreno GPU, otherwise std::nullopt. More...

std::optional< PowerVRGPU >	GetPowerVRGPUInfo () const
	Returns PowerVR GPU info if this is a PowerVR GPU, otherwise std::nullopt. More...

Detailed Description

Get information about the Vulkan driver.

Warning: Be extremely cautious about the information reported here. This is self-reported information (by the driver) and may be inaccurate and or inconsistent.

Before gating features behind any of the information reported by the driver, consider alternatives (extensions checks perhaps) and try to get a reviewer buddy to convince you to avoid using this.

Definition at line 195 of file driver_info_vk.h.

Constructor & Destructor Documentation

◆ DriverInfoVK() [1/2]

impeller::DriverInfoVK::DriverInfoVK ( const vk::PhysicalDevice & device )

explicit

Definition at line 267 of file driver_info_vk.cc.

                                                          {
   auto props = device.getProperties();
   api_version_ = Version{VK_API_VERSION_MAJOR(props.apiVersion),
                          VK_API_VERSION_MINOR(props.apiVersion),
                          VK_API_VERSION_PATCH(props.apiVersion)};
   vendor_ = IdentifyVendor(props.vendorID);
   if (vendor_ == VendorVK::kUnknown) {
     FML_LOG(WARNING) << "Unknown GPU Driver Vendor: " << props.vendorID
                      << ". This is not an error.";
   }
   type_ = ToDeviceType(props.deviceType);
   if (props.deviceName.data() != nullptr) {
     driver_name_ = props.deviceName.data();
   }
  
   switch (vendor_) {
     case VendorVK::kQualcomm:
       adreno_gpu_ = GetAdrenoVersion(driver_name_);
       break;
     case VendorVK::kARM:
       mali_gpu_ = GetMaliVersion(driver_name_);
       break;
     case VendorVK::kPowerVR:
       powervr_gpu_ = GetPowerVRVersion(driver_name_);
       break;
     default:
       break;
   }
 }

References impeller::GetAdrenoVersion(), impeller::GetMaliVersion(), impeller::GetPowerVRVersion(), impeller::IdentifyVendor(), impeller::kARM, impeller::kPowerVR, impeller::kQualcomm, impeller::kUnknown, and impeller::ToDeviceType().

◆ ~DriverInfoVK()

impeller::DriverInfoVK::~DriverInfoVK ( )

default

◆ DriverInfoVK() [2/2]

impeller::DriverInfoVK::DriverInfoVK ( const DriverInfoVK & )

delete

Member Function Documentation

◆ DumpToLog()

void impeller::DriverInfoVK::DumpToLog ( ) const

Dumps the current driver info to the log.

Definition at line 315 of file driver_info_vk.cc.

                                    {
   std::vector<std::pair<std::string, std::string>> items;
   items.emplace_back("Name", driver_name_);
   items.emplace_back("API Version", api_version_.ToString());
   items.emplace_back("Vendor", VendorToString(vendor_));
   items.emplace_back("Device Type", DeviceTypeToString(type_));
   items.emplace_back("Is Emulator", std::to_string(IsEmulator()));
  
   size_t padding = 0;
  
   for (const auto& item : items) {
     padding = std::max(padding, item.first.size());
   }
  
   padding += 1;
  
   std::stringstream stream;
  
   stream << std::endl;
  
   stream << "--- Driver Information ------------------------------------------";
  
   stream << std::endl;
  
   for (const auto& item : items) {
     stream << "| " << std::setw(static_cast<int>(padding)) << item.first
            << std::setw(0) << ": " << item.second << std::endl;
   }
  
   stream << "-----------------------------------------------------------------";
  
   FML_LOG(IMPORTANT) << stream.str();
 }

References impeller::DeviceTypeToString(), IsEmulator(), padding, impeller::Version::ToString(), and impeller::VendorToString().

◆ GetAdrenoGPUInfo()

std::optional< AdrenoGPU > impeller::DriverInfoVK::GetAdrenoGPUInfo ( ) const

Returns Adreno GPU info if this is a Adreno GPU, otherwise std::nullopt.

Definition at line 394 of file driver_info_vk.cc.

                                                             {
   return adreno_gpu_;
 }

Referenced by impeller::GetWorkaroundsFromDriverInfo().

◆ GetAPIVersion()

const Version & impeller::DriverInfoVK::GetAPIVersion ( ) const

Gets the Vulkan API version. Should be at or above Vulkan 1.1 which is the Impeller baseline.

Returns: The Vulkan API version.

Definition at line 299 of file driver_info_vk.cc.

                                                  {
   return api_version_;
 }

◆ GetDeviceType()

const DeviceTypeVK & impeller::DriverInfoVK::GetDeviceType ( ) const

Get the device type. Typical use might be to check if the device is a CPU implementation.

Returns: The device type.

Definition at line 307 of file driver_info_vk.cc.

                                                       {
   return type_;
 }

◆ GetDriverName()

const std::string & impeller::DriverInfoVK::GetDriverName ( ) const

Get the self-reported name of the graphics driver.

Returns: The driver name.

Definition at line 311 of file driver_info_vk.cc.

                                                    {
   return driver_name_;
 }

◆ GetMaliGPUInfo()

std::optional< MaliGPU > impeller::DriverInfoVK::GetMaliGPUInfo ( ) const

Returns Mali GPU info if this is a Mali GPU, otherwise std::nullopt.

Definition at line 390 of file driver_info_vk.cc.

                                                         {
   return mali_gpu_;
 }

◆ GetPowerVRGPUInfo()

std::optional< PowerVRGPU > impeller::DriverInfoVK::GetPowerVRGPUInfo ( ) const

Returns PowerVR GPU info if this is a PowerVR GPU, otherwise std::nullopt.

Definition at line 398 of file driver_info_vk.cc.

                                                               {
   return powervr_gpu_;
 }

Referenced by impeller::GetWorkaroundsFromDriverInfo().

◆ GetVendor()

const VendorVK & impeller::DriverInfoVK::GetVendor ( ) const

Get the vendor of the Vulkan implementation. This is a broad check and includes multiple drivers and platforms.

Returns: The vendor.

Definition at line 303 of file driver_info_vk.cc.

                                               {
   return vendor_;
 }

◆ IsEmulator()

bool impeller::DriverInfoVK::IsEmulator ( ) const

Determines if the driver represents an emulator. There is no definitive way to tell if a driver is an emulator and drivers don't self identify as emulators. So take this information with a pinch of salt.

Returns: True if emulator, False otherwise.

Definition at line 349 of file driver_info_vk.cc.

                                     {
 #if FML_OS_ANDROID
   // Google SwiftShader on Android.
   if (type_ == DeviceTypeVK::kCPU && vendor_ == VendorVK::kGoogle &&
       driver_name_.find("SwiftShader") != std::string::npos) {
     return true;
   }
 #endif  // FML_OS_ANDROID
   return false;
 }

References impeller::kCPU, and impeller::kGoogle.

Referenced by DumpToLog().

◆ IsKnownBadDriver()

bool impeller::DriverInfoVK::IsKnownBadDriver ( ) const

Determines if the driver has been tested and determined to be non-functional.

If true, context setup should fail such that the device falls back to OpenGLES.

Returns: True if non-functional device, False otherwise.

Definition at line 360 of file driver_info_vk.cc.

                                           {
   // Disable Maleoon series GPUs, see:
   // https://github.com/flutter/flutter/issues/156623
   if (vendor_ == VendorVK::kHuawei) {
     return true;
   }
  
   if (vendor_ == VendorVK::kSamsung) {
     // The first version of the Xclipse series GPU has reported
     // bugs, unfortunately all versions of this GPU report the
     // same driver version. Instead we use the Vulkan version
     // as a proxy, assuming that any newer devices would not
     // lower the supported Vulkan API level.
     // See
     // https://vulkan.gpuinfo.org/listreports.php?devicename=samsung+SM-S906B&platform=android
     // https://github.com/flutter/flutter/issues/161334
     return !api_version_.IsAtLeast(Version{1, 3, 0});
   }
  
   // https://github.com/flutter/flutter/issues/161122
   // https://github.com/flutter/flutter/issues/160960
   // https://github.com/flutter/flutter/issues/160866
   // https://github.com/flutter/flutter/issues/160804
   // https://github.com/flutter/flutter/issues/160406
   if (powervr_gpu_.has_value() && powervr_gpu_.value() < PowerVRGPU::kBXE) {
     return true;
   }
   return false;
 }

References impeller::Version::IsAtLeast(), impeller::kBXE, impeller::kHuawei, and impeller::kSamsung.

◆ operator=()

DriverInfoVK& impeller::DriverInfoVK::operator= ( const DriverInfoVK & )