Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 91fc3dc9 authored by Yiwei Zhang's avatar Yiwei Zhang
Browse files

vkjson: refactor based on 1.1 assumptions 

Bug: 160276146
Test: adb shell cmd gpu vkjson
Change-Id: Ieb55dfecb417d8bc49459621a06555bd7544cf5a
parent e1f35011

vulkan/vkjson/vkjson.h

+2 −5
Original line number Diff line number Diff line
@@ -158,10 +158,7 @@ bool VkJsonInstanceFromJson(const std::string& json, 
                            VkJsonInstance* instance,

                            std::string* errors);



VkJsonDevice VkJsonGetDevice(VkInstance instance,

                             VkPhysicalDevice device,

                             uint32_t instanceExtensionCount,

                             const char* const* instanceExtensions);

VkJsonDevice VkJsonGetDevice(VkPhysicalDevice device);

std::string VkJsonDeviceToJson(const VkJsonDevice& device);

bool VkJsonDeviceFromJson(const std::string& json,

                          VkJsonDevice* device,
@@ -177,7 +174,7 @@ bool VkJsonImageFormatPropertiesFromJson(const std::string& json, 
typedef VkJsonDevice VkJsonAllProperties;

inline VkJsonAllProperties VkJsonGetAllProperties(

    VkPhysicalDevice physicalDevice) {

  return VkJsonGetDevice(VK_NULL_HANDLE, physicalDevice, 0, nullptr);

  return VkJsonGetDevice(physicalDevice);

}

inline std::string VkJsonAllPropertiesToJson(

    const VkJsonAllProperties& properties) {

vulkan/vkjson/vkjson_instance.cc

+185 −256
Original line number Diff line number Diff line
@@ -28,8 +28,6 @@ 
#include <utility>



namespace {

const char* kSupportedInstanceExtensions[] = {

    "VK_KHR_get_physical_device_properties2"};



bool EnumerateExtensions(const char* layer_name,

                         std::vector<VkExtensionProperties>* extensions) {
@@ -46,15 +44,6 @@ bool EnumerateExtensions(const char* layer_name, 
  return true;

}



bool HasExtension(const char* extension_name,

                  uint32_t count,

                  const char* const* extensions) {

  return std::find_if(extensions, extensions + count,

                      [extension_name](const char* extension) {

                        return strcmp(extension, extension_name) == 0;

                      }) != extensions + count;

}



bool HasExtension(const char* extension_name,

                  const std::vector<VkExtensionProperties>& extensions) {

  return std::find_if(extensions.cbegin(), extensions.cend(),
@@ -65,27 +54,9 @@ bool HasExtension(const char* extension_name, 
}

}  // anonymous namespace



VkJsonDevice VkJsonGetDevice(VkInstance instance,

                             VkPhysicalDevice physical_device,

                             uint32_t instance_extension_count,

                             const char* const* instance_extensions) {

VkJsonDevice VkJsonGetDevice(VkPhysicalDevice physical_device) {

  VkJsonDevice device;



  PFN_vkGetPhysicalDeviceProperties2KHR vkpGetPhysicalDeviceProperties2KHR =

      nullptr;

  PFN_vkGetPhysicalDeviceFeatures2KHR vkpGetPhysicalDeviceFeatures2KHR =

      nullptr;

  if (instance != VK_NULL_HANDLE &&

      HasExtension("VK_KHR_get_physical_device_properties2",

                   instance_extension_count, instance_extensions)) {

    vkpGetPhysicalDeviceProperties2KHR =

        reinterpret_cast<PFN_vkGetPhysicalDeviceProperties2KHR>(

            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2KHR"));

    vkpGetPhysicalDeviceFeatures2KHR =

        reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2KHR>(

            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2KHR"));

  }



  uint32_t extension_count = 0;

  vkEnumerateDeviceExtensionProperties(physical_device, nullptr,

                                       &extension_count, nullptr);
@@ -103,29 +74,25 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
                                     device.layers.data());

  }



  if (HasExtension("VK_KHR_get_physical_device_properties2",

                   instance_extension_count, instance_extensions)) {

    VkPhysicalDeviceProperties2KHR properties = {

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR,

  VkPhysicalDeviceProperties2 properties = {

      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,

      nullptr,

        {} // properties

      {},

  };

  if (HasExtension("VK_KHR_driver_properties", device.extensions)) {

    device.ext_driver_properties.reported = true;

    device.ext_driver_properties.driver_properties_khr.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR;

      device.ext_driver_properties.driver_properties_khr.pNext =

          properties.pNext;

      properties.pNext =

          &device.ext_driver_properties.driver_properties_khr;

    device.ext_driver_properties.driver_properties_khr.pNext = properties.pNext;

    properties.pNext = &device.ext_driver_properties.driver_properties_khr;

  }

    vkpGetPhysicalDeviceProperties2KHR(physical_device, &properties);

  vkGetPhysicalDeviceProperties2(physical_device, &properties);

  device.properties = properties.properties;



    VkPhysicalDeviceFeatures2KHR features = {

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR,

  VkPhysicalDeviceFeatures2 features = {

      VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,

      nullptr,

        {}  // features

      {},

  };

  if (HasExtension("VK_KHR_variable_pointers", device.extensions)) {

    device.ext_variable_pointer_features.reported = true;
@@ -146,12 +113,9 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
    features.pNext = &device.ext_shader_float16_int8_features

                          .shader_float16_int8_features_khr;

  }

    vkpGetPhysicalDeviceFeatures2KHR(physical_device, &features);

  vkGetPhysicalDeviceFeatures2(physical_device, &features);

  device.features = features.features;

  } else {

    vkGetPhysicalDeviceProperties(physical_device, &device.properties);

    vkGetPhysicalDeviceFeatures(physical_device, &device.features);

  }



  vkGetPhysicalDeviceMemoryProperties(physical_device, &device.memory);



  uint32_t queue_family_count = 0;
@@ -189,12 +153,11 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
      }

    }



    PFN_vkGetPhysicalDeviceProperties2 vkpGetPhysicalDeviceProperties2 =

        reinterpret_cast<PFN_vkGetPhysicalDeviceProperties2>(

            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceProperties2"));

    if (vkpGetPhysicalDeviceProperties2) {

    VkPhysicalDeviceProperties2 properties2 = {

          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, nullptr, {}};

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,

        nullptr,

        {},

    };



    device.subgroup_properties.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
@@ -221,15 +184,13 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
    device.maintenance3_properties.pNext = properties2.pNext;

    properties2.pNext = &device.maintenance3_properties;



      (*vkpGetPhysicalDeviceProperties2)(physical_device, &properties2);

    }

    vkGetPhysicalDeviceProperties2(physical_device, &properties2);



    PFN_vkGetPhysicalDeviceFeatures2 vkpGetPhysicalDeviceFeatures2 =

        reinterpret_cast<PFN_vkGetPhysicalDeviceFeatures2>(

            vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceFeatures2"));

    if (vkpGetPhysicalDeviceFeatures2) {

    VkPhysicalDeviceFeatures2 features2 = {

          VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, nullptr, {}};

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,

        nullptr,

        {},

    };



    device.bit16_storage_features.sType =

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
@@ -261,15 +222,8 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
    device.shader_draw_parameter_features.pNext = features2.pNext;

    features2.pNext = &device.shader_draw_parameter_features;



      (*vkpGetPhysicalDeviceFeatures2)(physical_device, &features2);

    }

    vkGetPhysicalDeviceFeatures2(physical_device, &features2);



    PFN_vkGetPhysicalDeviceExternalFenceProperties

        vkpGetPhysicalDeviceExternalFenceProperties =

            reinterpret_cast<PFN_vkGetPhysicalDeviceExternalFenceProperties>(

                vkGetInstanceProcAddr(

                    instance, "vkGetPhysicalDeviceExternalFenceProperties"));

    if (vkpGetPhysicalDeviceExternalFenceProperties) {

    VkPhysicalDeviceExternalFenceInfo external_fence_info = {

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, nullptr,

        VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT};
@@ -278,10 +232,10 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
    for (VkExternalFenceHandleTypeFlagBits handle_type =

             VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;

         handle_type <= VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;

           handle_type = static_cast<VkExternalFenceHandleTypeFlagBits>(

               handle_type << 1)) {

         handle_type =

             static_cast<VkExternalFenceHandleTypeFlagBits>(handle_type << 1)) {

      external_fence_info.handleType = handle_type;

        (*vkpGetPhysicalDeviceExternalFenceProperties)(

      vkGetPhysicalDeviceExternalFenceProperties(

          physical_device, &external_fence_info, &external_fence_properties);

      if (external_fence_properties.exportFromImportedHandleTypes ||

          external_fence_properties.compatibleHandleTypes ||
@@ -290,14 +244,7 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
            std::make_pair(handle_type, external_fence_properties));

      }

    }

    }



    PFN_vkGetPhysicalDeviceExternalSemaphoreProperties

        vkpGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast<

            PFN_vkGetPhysicalDeviceExternalSemaphoreProperties>(

            vkGetInstanceProcAddr(

                instance, "vkGetPhysicalDeviceExternalSemaphoreProperties"));

    if (vkpGetPhysicalDeviceExternalSemaphoreProperties) {

    VkPhysicalDeviceExternalSemaphoreInfo external_semaphore_info = {

        VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, nullptr,

        VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT};
@@ -309,7 +256,7 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
         handle_type = static_cast<VkExternalSemaphoreHandleTypeFlagBits>(

             handle_type << 1)) {

      external_semaphore_info.handleType = handle_type;

        (*vkpGetPhysicalDeviceExternalSemaphoreProperties)(

      vkGetPhysicalDeviceExternalSemaphoreProperties(

          physical_device, &external_semaphore_info,

          &external_semaphore_properties);

      if (external_semaphore_properties.exportFromImportedHandleTypes ||
@@ -320,7 +267,6 @@ VkJsonDevice VkJsonGetDevice(VkInstance instance, 
      }

    }

  }

  }



  return device;

}
@@ -351,19 +297,15 @@ VkJsonInstance VkJsonGetInstance() { 
  if (!EnumerateExtensions(nullptr, &instance.extensions))

    return VkJsonInstance();



  std::vector<const char*> instance_extensions;

  for (const auto extension : kSupportedInstanceExtensions) {

    if (HasExtension(extension, instance.extensions))

      instance_extensions.push_back(extension);

  }



  const VkApplicationInfo app_info = {VK_STRUCTURE_TYPE_APPLICATION_INFO,

  const VkApplicationInfo app_info = {

      VK_STRUCTURE_TYPE_APPLICATION_INFO,

      nullptr,

      "vkjson_info",

      1,

      "",

      0,

                                      VK_API_VERSION_1_1};

      VK_API_VERSION_1_1,

  };

  VkInstanceCreateInfo instance_info = {

      VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,

      nullptr,
@@ -371,8 +313,9 @@ VkJsonInstance VkJsonGetInstance() { 
      &app_info,

      0,

      nullptr,

      static_cast<uint32_t>(instance_extensions.size()),

      instance_extensions.data()};

      0,

      nullptr,

  };

  VkInstance vkinstance;

  result = vkCreateInstance(&instance_info, nullptr, &vkinstance);

  if (result != VK_SUCCESS)
@@ -397,30 +340,17 @@ VkJsonInstance VkJsonGetInstance() { 
  instance.devices.reserve(sz);

  for (uint32_t i = 0; i < sz; ++i) {

    device_map.insert(std::make_pair(devices[i], i));

    instance.devices.emplace_back(VkJsonGetDevice(vkinstance, devices[i],

                                                  instance_extensions.size(),

                                                  instance_extensions.data()));

    instance.devices.emplace_back(VkJsonGetDevice(devices[i]));

  }



  PFN_vkEnumerateInstanceVersion vkpEnumerateInstanceVersion =

      reinterpret_cast<PFN_vkEnumerateInstanceVersion>(

          vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceVersion"));

  if (!vkpEnumerateInstanceVersion) {

    instance.api_version = VK_API_VERSION_1_0;

  } else {

    result = (*vkpEnumerateInstanceVersion)(&instance.api_version);

  result = vkEnumerateInstanceVersion(&instance.api_version);

  if (result != VK_SUCCESS) {

    vkDestroyInstance(vkinstance, nullptr);

    return VkJsonInstance();

  }

  }



  PFN_vkEnumeratePhysicalDeviceGroups vkpEnumeratePhysicalDeviceGroups =

      reinterpret_cast<PFN_vkEnumeratePhysicalDeviceGroups>(

          vkGetInstanceProcAddr(vkinstance, "vkEnumeratePhysicalDeviceGroups"));

  if (vkpEnumeratePhysicalDeviceGroups) {

  count = 0;

    result = (*vkpEnumeratePhysicalDeviceGroups)(vkinstance, &count, nullptr);

  result = vkEnumeratePhysicalDeviceGroups(vkinstance, &count, nullptr);

  if (result != VK_SUCCESS) {

    vkDestroyInstance(vkinstance, nullptr);

    return VkJsonInstance();
@@ -429,7 +359,7 @@ VkJsonInstance VkJsonGetInstance() { 
  VkJsonDeviceGroup device_group;

  std::vector<VkPhysicalDeviceGroupProperties> group_properties;

  group_properties.resize(count);

    result = (*vkpEnumeratePhysicalDeviceGroups)(vkinstance, &count,

  result = vkEnumeratePhysicalDeviceGroups(vkinstance, &count,

                                           group_properties.data());

  if (result != VK_SUCCESS) {

    vkDestroyInstance(vkinstance, nullptr);
@@ -443,7 +373,6 @@ VkJsonInstance VkJsonGetInstance() { 
    }

    instance.device_groups.push_back(device_group);

  }

  }



  vkDestroyInstance(vkinstance, nullptr);

  return instance;