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

Commit deee0d4d authored by Courtney Goeltzenleuchter's avatar Courtney Goeltzenleuchter Committed by Android (Google) Code Review
Browse files

Merge changes Id64bb14c,I47fb1475,Iefd17b62,Ib0e963e8,I236183d5 into nyc-dev 

* changes:
  loader: Add extension before CreateInstance chain
  vkinfo: Add debug command line option
  vkinfo: Add validation layers
  loader: Fix enumerate device extension properties
  loader: Fix enumerate device layer properties
parents 6fe9db67 1208622f

vulkan/libvulkan/dispatch.tmpl

+3 −1
Original line number Diff line number Diff line
@@ -465,7 +465,7 @@ bool LoadDriverDispatchTable(VkInstance instance, 
{{define "IsInstanceDispatched"}}

  {{AssertType $ "Function"}}

  {{if and (Macro "IsFunctionSupported" $) (eq (Macro "Vtbl" $) "Instance")}}

    {{if (ne $.Name "vkGetInstanceProcAddr")}}true{{end}}

    {{if and (ne $.Name "vkEnumerateDeviceLayerProperties") (ne $.Name "vkGetInstanceProcAddr")}}true{{end}}

  {{end}}

{{end}}
@@ -561,6 +561,8 @@ bool LoadDriverDispatchTable(VkInstance instance, 
  {{else if eq $.Name "vkGetDeviceQueue"}}true

  {{else if eq $.Name "vkAllocateCommandBuffers"}}true

  {{else if eq $.Name "vkCreateDevice"}}true

  {{else if eq $.Name "vkEnumerateDeviceLayerProperties"}}true

  {{else if eq $.Name "vkEnumerateDeviceExtensionProperties"}}true



  {{/* vkDestroy for dispatchable objects needs to handle VK_NULL_HANDLE;

       trying to dispatch through that would crash. */}}

vulkan/libvulkan/dispatch_gen.cpp

+4 −13
Original line number Diff line number Diff line
@@ -215,6 +215,8 @@ const NameProc kLoaderTopProcs[] = { 
    {"vkCreateInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkCreateInstance>(CreateInstance_Top))},

    {"vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyDevice>(DestroyDevice_Top))},

    {"vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkDestroyInstance>(DestroyInstance_Top))},

    {"vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceExtensionProperties>(EnumerateDeviceExtensionProperties_Top))},

    {"vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateDeviceLayerProperties>(EnumerateDeviceLayerProperties_Top))},

    {"vkEnumerateInstanceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceExtensionProperties>(EnumerateInstanceExtensionProperties_Top))},

    {"vkEnumerateInstanceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkEnumerateInstanceLayerProperties>(EnumerateInstanceLayerProperties_Top))},

    {"vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkGetDeviceProcAddr>(GetDeviceProcAddr_Top))},
@@ -296,7 +298,6 @@ const NameOffset kInstanceDispatchOffsets[] = { 
    {"vkDestroyInstance", offsetof(InstanceDispatchTable, DestroyInstance)},

    {"vkDestroySurfaceKHR", offsetof(InstanceDispatchTable, DestroySurfaceKHR)},

    {"vkEnumerateDeviceExtensionProperties", offsetof(InstanceDispatchTable, EnumerateDeviceExtensionProperties)},

    {"vkEnumerateDeviceLayerProperties", offsetof(InstanceDispatchTable, EnumerateDeviceLayerProperties)},

    {"vkEnumeratePhysicalDevices", offsetof(InstanceDispatchTable, EnumeratePhysicalDevices)},

    {"vkGetPhysicalDeviceFeatures", offsetof(InstanceDispatchTable, GetPhysicalDeviceFeatures)},

    {"vkGetPhysicalDeviceFormatProperties", offsetof(InstanceDispatchTable, GetPhysicalDeviceFormatProperties)},
@@ -522,11 +523,6 @@ bool LoadInstanceDispatchTable(VkInstance instance, 
        ALOGE("missing instance proc: %s", "vkCreateDevice");

        success = false;

    }

    dispatch.EnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(get_proc_addr(instance, "vkEnumerateDeviceLayerProperties"));

    if (UNLIKELY(!dispatch.EnumerateDeviceLayerProperties)) {

        ALOGE("missing instance proc: %s", "vkEnumerateDeviceLayerProperties");

        success = false;

    }

    dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));

    if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {

        ALOGE("missing instance proc: %s", "vkEnumerateDeviceExtensionProperties");
@@ -1271,11 +1267,6 @@ bool LoadDriverDispatchTable(VkInstance instance, 
        ALOGE("missing driver proc: %s", "vkCreateDevice");

        success = false;

    }

    dispatch.EnumerateDeviceLayerProperties = reinterpret_cast<PFN_vkEnumerateDeviceLayerProperties>(get_proc_addr(instance, "vkEnumerateDeviceLayerProperties"));

    if (UNLIKELY(!dispatch.EnumerateDeviceLayerProperties)) {

        ALOGE("missing driver proc: %s", "vkEnumerateDeviceLayerProperties");

        success = false;

    }

    dispatch.EnumerateDeviceExtensionProperties = reinterpret_cast<PFN_vkEnumerateDeviceExtensionProperties>(get_proc_addr(instance, "vkEnumerateDeviceExtensionProperties"));

    if (UNLIKELY(!dispatch.EnumerateDeviceExtensionProperties)) {

        ALOGE("missing driver proc: %s", "vkEnumerateDeviceExtensionProperties");
@@ -1422,12 +1413,12 @@ VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerNam 


__attribute__((visibility("default")))

VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) {

    return GetDispatchTable(physicalDevice).EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);

    return EnumerateDeviceLayerProperties_Top(physicalDevice, pPropertyCount, pProperties);

}



__attribute__((visibility("default")))

VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) {

    return GetDispatchTable(physicalDevice).EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);

    return EnumerateDeviceExtensionProperties_Top(physicalDevice, pLayerName, pPropertyCount, pProperties);

}



__attribute__((visibility("default")))

vulkan/libvulkan/dispatch_gen.h

+0 −2
Original line number Diff line number Diff line
@@ -34,7 +34,6 @@ struct InstanceDispatchTable { 
    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;

    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;

    PFN_vkCreateDevice CreateDevice;

    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;

    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;

    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;

    PFN_vkDestroySurfaceKHR DestroySurfaceKHR;
@@ -190,7 +189,6 @@ struct DriverDispatchTable { 
    PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;

    PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;

    PFN_vkCreateDevice CreateDevice;

    PFN_vkEnumerateDeviceLayerProperties EnumerateDeviceLayerProperties;

    PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;

    PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;

    PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;

vulkan/libvulkan/loader.cpp

+86 −64
Original line number Diff line number Diff line
@@ -454,12 +454,6 @@ template <class TCreateInfo> 
bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,

                              const char* extension_name,

                              const VkAllocationCallbacks* alloc) {

    for (uint32_t i = 0; i < local_create_info.enabledExtensionCount; ++i) {

        if (!strcmp(extension_name,

                    local_create_info.ppEnabledExtensionNames[i])) {

            return false;

        }

    }

    uint32_t extension_count = local_create_info.enabledExtensionCount;

    local_create_info.enabledExtensionCount++;

    void* mem = alloc->pfnAllocation(
@@ -821,55 +815,25 @@ void GetPhysicalDeviceSparseImageFormatProperties_Bottom( 
            properties);

}



// This is a no-op, the Top function returns the aggregate layer property

// data. This is to keep the dispatch generator happy.

VKAPI_ATTR

VkResult EnumerateDeviceExtensionProperties_Bottom(

    VkPhysicalDevice gpu,

    const char* layer_name,

    uint32_t* properties_count,

    VkExtensionProperties* properties) {

    const VkExtensionProperties* extensions = nullptr;

    uint32_t num_extensions = 0;

    if (layer_name) {

        GetDeviceLayerExtensions(layer_name, &extensions, &num_extensions);

    } else {

        Instance& instance = GetDispatchParent(gpu);

        size_t gpu_idx = 0;

        while (instance.physical_devices[gpu_idx] != gpu)

            gpu_idx++;

        const DeviceExtensionSet driver_extensions =

            instance.physical_device_driver_extensions[gpu_idx];



        // We only support VK_KHR_swapchain if the GPU supports

        // VK_ANDROID_native_buffer

        VkExtensionProperties* available = static_cast<VkExtensionProperties*>(

            alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));

        if (driver_extensions[kANDROID_native_buffer]) {

            available[num_extensions++] = VkExtensionProperties{

                VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};

        }



        // TODO(jessehall): We need to also enumerate extensions supported by

        // implicitly-enabled layers. Currently we don't have that list of

        // layers until instance creation.

        extensions = available;

    }



    if (!properties || *properties_count > num_extensions)

        *properties_count = num_extensions;

    if (properties)

        std::copy(extensions, extensions + *properties_count, properties);

    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;

    VkPhysicalDevice /*pdev*/,

    const char* /*layer_name*/,

    uint32_t* /*properties_count*/,

    VkExtensionProperties* /*properties*/) {

    return VK_SUCCESS;

}



// This is a no-op, the Top function returns the aggregate layer property

// data. This is to keep the dispatch generator happy.

VKAPI_ATTR

VkResult EnumerateDeviceLayerProperties_Bottom(VkPhysicalDevice /*pdev*/,

                                               uint32_t* properties_count,

                                               VkLayerProperties* properties) {

    uint32_t layer_count =

        EnumerateDeviceLayers(properties ? *properties_count : 0, properties);

    if (!properties || *properties_count > layer_count)

        *properties_count = layer_count;

    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;

VkResult EnumerateDeviceLayerProperties_Bottom(

    VkPhysicalDevice /*pdev*/,

    uint32_t* /*properties_count*/,

    VkLayerProperties* /*properties*/) {

    return VK_SUCCESS;

}



VKAPI_ATTR
@@ -1061,6 +1025,51 @@ VkResult EnumerateInstanceLayerProperties_Top(uint32_t* properties_count, 
    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;

}



VKAPI_ATTR

VkResult EnumerateDeviceExtensionProperties_Top(

    VkPhysicalDevice gpu,

    const char* layer_name,

    uint32_t* properties_count,

    VkExtensionProperties* properties) {

    const VkExtensionProperties* extensions = nullptr;

    uint32_t num_extensions = 0;



    ALOGV("EnumerateDeviceExtensionProperties_Top:");

    if (layer_name) {

        ALOGV("  layer %s", layer_name);

        GetDeviceLayerExtensions(layer_name, &extensions, &num_extensions);

    } else {

        ALOGV("  no layer");

        Instance& instance = GetDispatchParent(gpu);

        size_t gpu_idx = 0;

        while (instance.physical_devices[gpu_idx] != gpu)

            gpu_idx++;

        const DeviceExtensionSet driver_extensions =

            instance.physical_device_driver_extensions[gpu_idx];



        // We only support VK_KHR_swapchain if the GPU supports

        // VK_ANDROID_native_buffer

        VkExtensionProperties* available = static_cast<VkExtensionProperties*>(

            alloca(kDeviceExtensionCount * sizeof(VkExtensionProperties)));

        if (driver_extensions[kANDROID_native_buffer]) {

            available[num_extensions++] = VkExtensionProperties{

                VK_KHR_SWAPCHAIN_EXTENSION_NAME, VK_KHR_SWAPCHAIN_SPEC_VERSION};

        }



        // TODO(jessehall): We need to also enumerate extensions supported by

        // implicitly-enabled layers. Currently we don't have that list of

        // layers until instance creation.

        extensions = available;

    }



    ALOGV("  num: %d, extensions: %p", num_extensions, extensions);

    if (!properties || *properties_count > num_extensions)

        *properties_count = num_extensions;

    if (properties)

        std::copy(extensions, extensions + *properties_count, properties);

    return *properties_count < num_extensions ? VK_INCOMPLETE : VK_SUCCESS;

}



VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info,

                            const VkAllocationCallbacks* allocator,

                            VkInstance* instance_out) {
@@ -1149,8 +1158,23 @@ VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info, 
    instance_create_info.pNext = local_create_info.pNext;

    local_create_info.pNext = &instance_create_info;



    // Force enable callback extension if required

    bool enable_callback = false;

    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {

        enable_callback =

            property_get_bool("debug.vulkan.enable_callback", false);

        if (enable_callback) {

            enable_callback = AddExtensionToCreateInfo(

                local_create_info, "VK_EXT_debug_report", instance->alloc);

        }

    }



    result = create_instance(&local_create_info, allocator, &local_instance);



    if (enable_callback) {

        FreeAllocatedCreateInfo(local_create_info, allocator);

    }



    if (result != VK_SUCCESS) {

        DestroyInstance_Bottom(instance->handle, allocator);

        TeardownInstance(instance->handle, allocator);
@@ -1177,20 +1201,7 @@ VkResult CreateInstance_Top(const VkInstanceCreateInfo* create_info, 
    }

    *instance_out = local_instance;



    // Force enable callback extension if required

    bool enable_callback = false;

    bool enable_logging = false;

    if (prctl(PR_GET_DUMPABLE, 0, 0, 0, 0)) {

        enable_callback =

            property_get_bool("debug.vulkan.enable_callback", false);

        enable_logging = enable_callback;

    if (enable_callback) {

            enable_callback = AddExtensionToCreateInfo(

                local_create_info, "VK_EXT_debug_report", instance->alloc);

        }

    }



    if (enable_logging) {

        const VkDebugReportCallbackCreateInfoEXT callback_create_info = {

            .sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT,

            .flags =
@@ -1238,6 +1249,17 @@ void DestroyInstance_Top(VkInstance vkinstance, 
    TeardownInstance(vkinstance, allocator);

}



VKAPI_ATTR

VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice /*pdev*/,

                                               uint32_t* properties_count,

                                               VkLayerProperties* properties) {

    uint32_t layer_count =

        EnumerateDeviceLayers(properties ? *properties_count : 0, properties);

    if (!properties || *properties_count > layer_count)

        *properties_count = layer_count;

    return *properties_count < layer_count ? VK_INCOMPLETE : VK_SUCCESS;

}



VKAPI_ATTR

VkResult CreateDevice_Top(VkPhysicalDevice gpu,

                          const VkDeviceCreateInfo* create_info,

vulkan/libvulkan/loader.h

+2 −0
Original line number Diff line number Diff line
@@ -94,6 +94,8 @@ VKAPI_ATTR void DestroyInstance_Top(VkInstance instance, const VkAllocationCallb 
VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr_Top(VkDevice drv_device, const char* name);

VKAPI_ATTR void GetDeviceQueue_Top(VkDevice drv_device, uint32_t family, uint32_t index, VkQueue* out_queue);

VKAPI_ATTR VkResult AllocateCommandBuffers_Top(VkDevice device, const VkCommandBufferAllocateInfo* alloc_info, VkCommandBuffer* cmdbufs);

VKAPI_ATTR VkResult EnumerateDeviceLayerProperties_Top(VkPhysicalDevice pdev, uint32_t* properties_count, VkLayerProperties* properties);

VKAPI_ATTR VkResult EnumerateDeviceExtensionProperties_Top(VkPhysicalDevice pdev, const char * layer_name, uint32_t* properties_count, VkExtensionProperties* properties);

VKAPI_ATTR VkResult CreateDevice_Top(VkPhysicalDevice pdev, const VkDeviceCreateInfo* create_info, const VkAllocationCallbacks* allocator, VkDevice* device_out);

VKAPI_ATTR void DestroyDevice_Top(VkDevice drv_device, const VkAllocationCallbacks* allocator);