Added initial implementation of Vulkan Render Passes.

gpu/vulkan/vulkan_implementation.cc

 // 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"
+#include "gpu/vulkan/vulkan_command_buffer.h"
 
 #if defined(VK_USE_PLATFORM_XLIB_KHR)
 #include "ui/gfx/x/x11_types.h"
 #endif  // defined(VK_USE_PLATFORM_XLIB_KHR)
 
 namespace gfx {
 
 struct VulkanInstance {
-  VulkanInstance() : valid(false) {}
+  VulkanInstance() {}
 
   void Initialize() {
-    valid = InitializeVulkanInstance() && InitializeVulkanDevice();
+    valid = InitializeVulkanInstance() && InitializeVulkanDevice() &&
+            CreateCommandPool();
   }
 
   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);
 
@@ skipping 76 matching lines @@
         if (-1 != queue_index) {
           device_index = static_cast<int>(i);
           break;
         }
       }
     }
 
     if (queue_index == -1)
       return false;
 
+    vk_physical_device = devices[device_index];
+    vk_queue_index = queue_index;
+
     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,
+    status = vkCreateDevice(vk_physical_device, &device_create_info, nullptr,
                             &vk_device);
     if (VK_SUCCESS != status)
       return false;
 
     vkGetDeviceQueue(vk_device, queue_index, 0, &vk_queue);
 
     return true;
   }
 
-  bool valid;
+  bool CreateCommandPool() {
+    VkCommandPoolCreateInfo command_pool_create_info = {};
+    command_pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+    command_pool_create_info.queueFamilyIndex = vk_queue_index;

[piman, 2016/03/09 01:25:34]

If we reset command buffers individually, we need to set the
VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT flag.

[David Yen, 2016/03/10 01:39:48]

Interesting, I missed this. Done.

+
+    VkResult result = vkCreateCommandPool(vk_device, &command_pool_create_info,
+                                          nullptr, &vk_command_pool);
+    if (VK_SUCCESS != result) {
+      LOG(ERROR) << "vkCreateCommandPool() failed: " << result;

[piman, 2016/03/09 01:25:33]

nit: DLOG

[David Yen, 2016/03/10 01:39:48]

Done.

+      return false;
+    }
+
+    return true;
+  }
+
+  bool valid = false;
   VkInstance vk_instance;
+  VkPhysicalDevice vk_physical_device;
   VkDevice vk_device;
   VkQueue vk_queue;
+  uint32_t vk_queue_index = 0;
+  VkCommandPool vk_command_pool;

[piman, 2016/03/09 01:25:33]

We'll definitely need more than one pool - typically one per thread, otherwise
the mutual exclusion requirement mean command buffer recording needs to be
serialized... So I think the pool usage should not be implicit, and instead
explicitly created and managed by the higher levels.

[David Yen, 2016/03/10 01:39:48]

Done. Separated out into a separate class. I now have the SwapChain own the
command pool for the swap change images command buffers.

 };
 
 static VulkanInstance* vulkan_instance = nullptr;
 
 bool InitializeVulkan() {
   DCHECK(!vulkan_instance);
   vulkan_instance = new VulkanInstance;
   vulkan_instance->Initialize();
   return vulkan_instance->valid;
 }
 
 VkInstance GetVulkanInstance() {
   DCHECK(vulkan_instance);
   DCHECK(vulkan_instance->valid);
   return vulkan_instance->vk_instance;
 }
 
+VkPhysicalDevice GetVulkanPhysicalDevice() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+  return vulkan_instance->vk_physical_device;
+}
+
 VkDevice GetVulkanDevice() {
   DCHECK(vulkan_instance);
   DCHECK(vulkan_instance->valid);
   return vulkan_instance->vk_device;
 }
 
 VkQueue GetVulkanQueue() {
   DCHECK(vulkan_instance);
   DCHECK(vulkan_instance->valid);
   return vulkan_instance->vk_queue;
 }
 
+scoped_ptr<VulkanCommandBuffer> CreatePrimaryCommandBuffer() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+
+  scoped_ptr<VulkanCommandBuffer> command_buffer(
+      new VulkanCommandBuffer(vulkan_instance->vk_command_pool, true));
+  command_buffer->Initialize();

[piman, 2016/03/09 01:25:33]

don't we need to handle the return value?

At a high level we will need to handle errors one way or another, and I don't
think this is something that we'll want to wait until the last minute, I think
we want to develop patterns early on.

There's a few errors that will be fairly common (as in, many calls may return
them, even though they shouldn't be common in practice):

- VK_ERROR_OUT_OF_HOST_MEMORY, we can probably ignore, because we should abort
even before we get there, because malloc itself will abort.
- VK_ERROR_OUT_OF_DEVICE_MEMORY, we will need to handle somehow. It's not
acceptable to crash the browser in this condition, but we may be able to handle
similarly to lost device as a first step, but we may need finer grain management
(e.g. if it happens when allocating resource memory for buffers/images, maybe we
can free speculative resources instead).
(those 2 are pretty much always allowed in any call that returns a VkResult)
- VK_ERROR_DEVICE_LOST, we need to handle by aborting the current frame,
destroying everything, and recreating everything (similar to GL), and if it
fails then, fall back to software. We can punt the whole retry logic for now,
but at least we need to surface the error so that we can handle this correctly.


There's a few more topical errors:
- VK_ERROR_MEMORY_MAP_FAILED, we can probably handle like
VK_ERROR_OUT_OF_HOST_MEMORY, i.e. terminate, though we'll have to do that
explicitly.
- VK_ERROR_TOO_MANY_OBJECTS, depends on context (e.g. if on device creation,
this is fatal and must fallback to software (or GL), if on device memory
allocation we should handle like VK_ERROR_OUT_OF_DEVICE_MEMORY). There's some
places where it could happen in theory (e.g. vkCreateSampler), but we should
make sure we don't run into it in the first place (i.e. pooling samplers to stay
below the limit).
- VK_ERROR_INITIALIZATION_FAILED, on instance/device creation, this is fatal and
we must fallback to software
- VK_ERROR_FORMAT_NOT_SUPPORTED is only on
vkGetPhysicalDeviceImageFormatProperties, which I don't know if we'll actually
need
-
VK_ERROR_LAYER_NOT_PRESENT/VK_ERROR_EXTENSION_NOT_PRESENT/VK_ERROR_FEATURE_NOT_PRESENT
we should avoid in the first place
- VK_ERROR_INCOMPATIBLE_DISPLAY_KHR shouldn't happen (only for
vkCreateSharedSwapchains which we shouldn't use)
- VK_ERROR_NATIVE_WINDOW_IN_USE_KHR shouldn't happen
- VK_ERROR_SURFACE_LOST_KHR and VK_ERROR_OUT_OF_DATE_KHR have to do with WSI
presentation and will need special handling (depending on conditions, from
ignore to recreate swapchain, or possibly lost device).

[David Yen, 2016/03/10 01:39:48]

I'll have this function return nullptr on errors. Currently all these functions
are just called on initialization so I'm planning on having them just fallback
to GL in those cases, and GL will fallback to software.

I'm not sure how to handle the whole reinitialization on at this point, punt
until how we have drawing tasks?

+  return command_buffer;
+}
+
+scoped_ptr<VulkanCommandBuffer> CreateSecondaryCommandBuffer() {
+  DCHECK(vulkan_instance);
+  DCHECK(vulkan_instance->valid);
+
+  scoped_ptr<VulkanCommandBuffer> command_buffer(
+      new VulkanCommandBuffer(vulkan_instance->vk_command_pool, false));
+  command_buffer->Initialize();
+  return command_buffer;
+}
+
 }  // namespace gfx