Added initial Vulkan build files as well as a basic implementation file.

gpu/vulkan/vulkan_implementation.cc

Index: gpu/vulkan/vulkan_implementation.cc
diff --git a/gpu/vulkan/vulkan_implementation.cc b/gpu/vulkan/vulkan_implementation.cc
new file mode 100644
index 0000000000000000000000000000000000000000..60b67df76417716e6b007e5fafaad72db7c5352f
--- /dev/null
+++ b/gpu/vulkan/vulkan_implementation.cc
@@ -0,0 +1,220 @@
+// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "gpu/vulkan/vulkan_implementation.h"
+
+#include <string>
+#include <vector>
+#include <vulkan/vulkan.h>
+
+#include "base/macros.h"
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+#include "ui/gfx/x/x11_types.h"
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+
+// The following code is not going to be necessary once the loader handles
+// the VK_KHR_XLIB_SURFACE_EXTENSION_NAME extension.
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+struct VulkanProcs {
+  PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
+      vkGetPhysicalDeviceXlibPresentationSupportKHRFn = nullptr;
+
+  PFN_vkCreateXlibSurfaceKHR vkCreateXlibSurfaceKHRFn = nullptr;
+
+  bool InitializeFunctions(VkInstance vk_instance) {
+    vkGetPhysicalDeviceXlibPresentationSupportKHRFn =
+        reinterpret_cast<PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR>(
+            vkGetInstanceProcAddr(
+                vk_instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR"));
+
+    vkCreateXlibSurfaceKHRFn = reinterpret_cast<PFN_vkCreateXlibSurfaceKHR>(
+        vkGetInstanceProcAddr(vk_instance, "vkCreateXlibSurfaceKHR"));
+
+    return true;
+  }
+};
+
+static VulkanProcs vulkan_procs;

[piman, 2016/03/04 21:07:09]

non-POD globals are not allowed (causes global initializers).
You can use LazyInstance, for example, or make this a pointer that would be set
up by InitializeVulkan or something.

Or, since the functions are instance-specific, they could be part of
VulkanInstance.

[David Yen, 2016/03/04 22:12:28]

I thought I would be able to get around the loader by using
vkGetInstanceProcAddr() thinking that these functions would be part of the
driver, but it sounds these functions are suppose to be implemented by the
loader itself? Does that mean this section is pointless?

[piman, 2016/03/05 00:11:25]

vkGetInstanceProcAddr /could/ give you a more specific function (e.g. skips
some dispatch code wrt layers), but I think that's right, this function is
implemented by the loader anyway.

[David Yen, 2016/03/07 23:33:31]

So after building the loader locally, there are 2 functions associated with the
xlib extension. The other function (surface creation) is implemented in the
loader but this one is implemented in the driver which is still broken as of
355.00.29. I have just disabled the function call and put it behind an ifdef for
now.

+
+VKAPI_ATTR VkResult VKAPI_CALL
+vkCreateXlibSurfaceKHR(VkInstance instance,
+                       const VkXlibSurfaceCreateInfoKHR* pCreateInfo,
+                       const VkAllocationCallbacks* pAllocator,
+                       VkSurfaceKHR* pSurface) {
+  return vulkan_procs.vkCreateXlibSurfaceKHRFn(instance, pCreateInfo,
+                                               pAllocator, pSurface);
+}
+
+VKAPI_ATTR VkBool32 VKAPI_CALL
+vkGetPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice,
+                                              uint32_t queueFamilyIndex,
+                                              Display* dpy,
+                                              VisualID visualID) {
+  // TODO(dyen): Re-enable this function once drivers properly support this.
+  return true;
+  return vulkan_procs.vkGetPhysicalDeviceXlibPresentationSupportKHRFn(
+      physicalDevice, queueFamilyIndex, dpy, visualID);
+}
+
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+// End of temporary VK_KHR_XLIB_SURFACE_EXTENSION_NAME loader code.
+
+namespace gfx {
+
+struct VulkanInstance {
+  VulkanInstance() : valid(false) {}
+
+  void Initialize() {
+    valid = InitializeVulkanInstance() && InitializeVulkanDevice();
+  }
+
+  bool InitializeVulkanInstance() {
+    VkResult status = VK_SUCCESS;
+
+    VkApplicationInfo app_info = {};
+    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+    app_info.pApplicationName = "Chromium";
+    app_info.apiVersion = VK_MAKE_VERSION(1, 0, 2);
+
+    const char* instance_extensions[] = {
+      VK_KHR_SURFACE_EXTENSION_NAME,
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+      VK_KHR_XLIB_SURFACE_EXTENSION_NAME,
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+    };
+
+    VkInstanceCreateInfo instance_create_info = {};
+    instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+    instance_create_info.pApplicationInfo = &app_info;
+    instance_create_info.ppEnabledExtensionNames = instance_extensions;
+    instance_create_info.enabledExtensionCount = arraysize(instance_extensions);
+
+    status = vkCreateInstance(&instance_create_info, nullptr, &vk_instance);
+    DCHECK_EQ(VK_SUCCESS, status);
+    if (VK_SUCCESS != status)
+      return false;
+
+    // TODO(dyen): Remove once loader properly supports xlib functions.
+    if (!vulkan_procs.InitializeFunctions(vk_instance))
+      return false;
+
+    return true;
+  }
+
+  bool InitializeVulkanDevice() {
+    VkResult status = VK_SUCCESS;
+
+    uint32_t device_count = 0;
+    status = vkEnumeratePhysicalDevices(vk_instance, &device_count, nullptr);
+    if (VK_SUCCESS != status || device_count == 0)
+      return false;
+
+    std::vector<VkPhysicalDevice> devices(device_count);
+    status =
+        vkEnumeratePhysicalDevices(vk_instance, &device_count, devices.data());
+    if (VK_SUCCESS != status) {
+      LOG(ERROR) << "vkEnumeratePhysicalDevices failed: " << status;
+      return false;
+    }
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+    Display* xdisplay = gfx::GetXDisplay();
+    VisualID visual_id =
+        XVisualIDFromVisual(DefaultVisual(xdisplay, DefaultScreen(xdisplay)));
+#endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
+
+    int device_index = -1;
+    int queue_index = -1;
+    for (size_t i = 0; i < devices.size(); ++i) {
+      const VkPhysicalDevice& device = devices[i];
+      uint32_t queue_count = 0;
+      vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count, nullptr);
+      if (queue_count) {
+        std::vector<VkQueueFamilyProperties> queue_properties(queue_count);
+        vkGetPhysicalDeviceQueueFamilyProperties(device, &queue_count,
+                                                 queue_properties.data());
+        for (size_t n = 0; n < queue_properties.size(); ++n) {
+          if ((queue_properties[n].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)
+            continue;
+
+#if defined(VK_USE_PLATFORM_XLIB_KHR)
+          if (!vkGetPhysicalDeviceXlibPresentationSupportKHR(
+                  device, n, xdisplay, visual_id)) {
+            continue;
+          }
+#else
+#error Non-Supported Vulkan implementation.
+#endif
+
+          queue_index = static_cast<int>(n);
+          break;
+        }
+
+        if (-1 != queue_index) {
+          device_index = static_cast<int>(i);
+          break;
+        }
+      }
+    }
+
+    if (queue_index == -1)
+      return false;
+
+    float queue_priority = 0.0f;
+    VkDeviceQueueCreateInfo queue_create_info = {};
+    queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+    queue_create_info.queueFamilyIndex = queue_index;
+    queue_create_info.queueCount = 1;
+    queue_create_info.pQueuePriorities = &queue_priority;
+
+    const char* device_extensions[] = {VK_KHR_SWAPCHAIN_EXTENSION_NAME};
+
+    VkDeviceCreateInfo device_create_info = {};
+    device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
+    device_create_info.queueCreateInfoCount = 1;
+    device_create_info.pQueueCreateInfos = &queue_create_info;
+    device_create_info.enabledExtensionCount = arraysize(device_extensions);
+    device_create_info.ppEnabledExtensionNames = device_extensions;
+
+    status = vkCreateDevice(devices[device_index], &device_create_info, nullptr,
+                            &vk_device);
+    if (VK_SUCCESS != status)
+      return false;
+
+    vkGetDeviceQueue(vk_device, queue_index, 0, &vk_queue);
+
+    return true;
+  }
+
+  bool valid;
+  VkInstance vk_instance;
+  VkDevice vk_device;
+  VkQueue vk_queue;
+};
+
+static VulkanInstance vulkan_instance;

[piman, 2016/03/04 21:07:09]

Same here wrt non-POD globals.

LazyInstance seems appropriate.

[David Yen, 2016/03/04 22:12:28]

Done.

+
+bool InitializeVulkan() {
+  vulkan_instance.Initialize();
+  return vulkan_instance.valid;
+}
+
+VkInstance GetVulkanInstance() {
+  DCHECK(vulkan_instance.valid);
+  return vulkan_instance.vk_instance;
+}
+
+VkDevice GetVulkanDevice() {
+  DCHECK(vulkan_instance.valid);
+  return vulkan_instance.vk_device;
+}
+
+VkQueue GetVulkanQueue() {
+  DCHECK(vulkan_instance.valid);
+  return vulkan_instance.vk_queue;
+}
+
+}  // namespace gfx