encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Enable Vulkan for Chromium Fuchsia build. 

Enable the Vulkan backend when building Dawn with
the Chromium build system for Fuchsia. To make this
work properly the following is required:

- Modify VulkanInfo.cpp and BackendVk.cpp to correctly probe
  the Fuchsia swapchain layer and its layer extension, as well
  as enabling them when creating a new VkInstance.

- Modify VulkanFunctions.cpp to load the Fuchsia swapchain
  related extension for this platform only.

- Provide a small mock GLFW library for Fuchsia under
  src/utils/Glfw3Fuchsia.cpp, since the upstream project
  does not support this platform at all. Its purpose is
  only to allow the creation of the right VulkanBinding
  instance, which depends on the creation of a display
  surface for latter swapchain creation.

- Add //third_party/fuchsia-sdk:vulkan_base and
  //third_party/fuchsia-sdk:vulkan_validation as
  data_deps of the libdawn_native_sources target in
  order to ensure that the Fuchsia package created by
  the build system will include the correct Vulkan
  libraries (loader and validation layers).

This builds correctly, and both dawn_unittests and
dawn_end2end_tests will run on a real Fuchsia device
or inside the Fuchsia emulator, using either GPU
virtualization or a software-based renderer.

Note: dawn_unittests will also run inside QEMU, but
not dawn_end2end_tests, since the latter requires
proper GPU emulation which is not available in this
environment.

NOTE: All end2end tests pass using a device with
      an "Intel HD Graphics 615 (Kaby Lake GT2)"
      adapter. However:

       - For some reason, a single test takes up
         to 129 seconds to pass
	 (BufferSetSubDataTests.ManySetSubData/Vulkan).

       - The test process crashes inside VkDestroyInstance(),
         apparently inside the Fuchsia-specific imagepipe
	 layer (which implements swapchain support).
	 This is likely a bug in the layer itself, and
	 not Dawn.

    Also, may end2end tests will crash when run inside
    the Fuchsia emulator (which uses GPU virtualization
    to talk to the host GPU). The crashes happen inside
    libvulkan-goldfish.so, the emulator-specific Vulkan
    ICD on this sytem. Not a Dawn bug either.

Bug=dawn:221
Change-Id: Id3598b673e8c6393f24db728b8da49fdde3cac76
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/8963
Commit-Queue: David Turner <digit@google.com>
Reviewed-by: Austin Eng <enga@chromium.org>
This commit is contained in:
David 'Digit' Turner 2019-09-09 10:52:08 +00:00 committed by Commit Bot service account
parent abec145b04
commit b749d07ac9
9 changed files with 232 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
BUILD.gn
View File

@ -452,6 +452,16 @@ source_set("libdawn_native_sources") {
"src/dawn_native/vulkan/external_semaphore/SemaphoreServiceNull.cpp",
]
}
if (build_with_chromium && is_fuchsia) {
# Necessary to ensure that the Vulkan libraries will be in the
# final Fuchsia package.
data_deps = [
# NOTE: The line below is a work around for http://crbug.com/1001081
"//third_party/fuchsia-sdk/sdk:trace_engine",
"//third_party/fuchsia-sdk:vulkan_base",
"//third_party/fuchsia-sdk:vulkan_validation",
]
}
}
}
@ -559,6 +569,47 @@ dawn_component("libdawn_wire") {
]
}
###############################################################################
# GLFW wrapping target
###############################################################################
# GLFW does not support Android or Fuchsia, so provide a small mock library
# that can be linked into the Dawn tests on these platforms. Otherwise, use
# the real library from third_party/.
if (is_fuchsia) {
config("dawn_glfw_public_config") {
# Allow inclusion of <GLFW/glfw3.h>
configs = [ "third_party:glfw_public" ]
# The GLFW/glfw3.h header includes <GL/gl.h> by default, but the latter
# does not exist on Fuchsia. Defining GLFW_INCLUDE_NONE helps work around
# the issue, but it needs to be defined for any file that includes the
# header.
defines = [
"GLFW_INCLUDE_NONE",
"GLFW_INCLUDE_VULKAN",
]
}
static_library("dawn_glfw") {
sources = [
# NOTE: The header below is required to pass "gn check".
"${dawn_glfw_dir}/include/GLFW/glfw3.h",
"src/utils/Glfw3Fuchsia.cpp",
]
public_configs = [ ":dawn_glfw_public_config" ]
deps = [
"${dawn_root}/src/common",
]
}
} else {
group("dawn_glfw") {
public_deps = [
"third_party:glfw",
]
}
}
###############################################################################
# Utils for tests and samples
###############################################################################
@ -613,9 +664,9 @@ static_library("dawn_bindings") {
]
deps = [
":dawn_glfw",
":libdawn_native",
"${dawn_root}/src/common",
"third_party:glfw",
]
libs = []
@ -756,6 +807,7 @@ source_set("dawn_end2end_tests_sources") {
testonly = true
deps = [
":dawn_glfw",
":dawn_utils",
":libdawn_native",
":libdawn_wire",
@ -823,7 +875,7 @@ source_set("dawn_end2end_tests_sources") {
}
if (dawn_enable_opengl) {
deps += [ "third_party:glfw" ]
deps += [ ":dawn_glfw" ]
}
}
@ -854,7 +906,7 @@ source_set("dawn_white_box_tests_sources") {
}
if (dawn_enable_opengl) {
deps += [ "third_party:glfw" ]
deps += [ ":dawn_glfw" ]
}
libs = []
@ -890,7 +942,7 @@ test("dawn_end2end_tests") {
}
if (dawn_enable_opengl) {
deps += [ "third_party:glfw" ]
deps += [ ":dawn_glfw" ]
}
}
@ -930,7 +982,7 @@ test("dawn_perf_tests") {
}
if (dawn_enable_opengl) {
deps += [ "third_party:glfw" ]
deps += [ ":dawn_glfw" ]
}
}
@ -974,12 +1026,12 @@ if (dawn_standalone) {
# Export all of these as public deps so that `gn check` allows includes
public_deps = [
":dawn_bindings",
":dawn_glfw",
":dawn_utils",
":libdawn_native",
":libdawn_wire",
"${dawn_root}/src/common",
"${dawn_root}/src/dawn:libdawn",
"third_party:glfw",
]
public_configs = [ "${dawn_root}/src/common:dawn_internal" ]
}

2
scripts/dawn_features.gni
View File

@ -36,5 +36,5 @@ declare_args() {
dawn_enable_opengl = is_linux && !is_chromeos
# Enables the compilation of Dawn's Vulkan backend
dawn_enable_vulkan = is_linux || is_win
dawn_enable_vulkan = is_linux || is_win || is_fuchsia
}

2
src/common/BUILD.gn
View File

@ -76,7 +76,7 @@ config("dawn_internal") {
# This GN file is discovered by all Chromium builds, but common doesn't support
# all of Chromium's OSes so we explicitly make the target visible only on
# systems we know Dawn is able to compile on.
if (is_win || is_linux || is_mac) {
if (is_win || is_linux || is_mac || is_fuchsia) {
static_library("common") {
sources = [
"Assert.cpp",

11
src/dawn_native/vulkan/BackendVk.cpp
View File

@ -25,6 +25,8 @@
const char kVulkanLibName[] = "libvulkan.so.1";
#elif DAWN_PLATFORM_WINDOWS
const char kVulkanLibName[] = "vulkan-1.dll";
#elif DAWN_PLATFORM_FUCHSIA
const char kVulkanLibName[] = "libvulkan.so";
#else
# error "Unimplemented Vulkan backend platform"
#endif
@ -136,6 +138,11 @@ namespace dawn_native { namespace vulkan {
}
}
if (mGlobalInfo.fuchsiaImagePipeSwapchain) {
layersToRequest.push_back(kLayerNameFuchsiaImagePipeSwapchain);
usedKnobs.fuchsiaImagePipeSwapchain = true;
}
// Always request all extensions used to create VkSurfaceKHR objects so that they are
// always available for embedders looking to create VkSurfaceKHR on our VkInstance.
if (mGlobalInfo.macosSurface) {
@ -174,6 +181,10 @@ namespace dawn_native { namespace vulkan {
extensionsToRequest.push_back(kExtensionNameKhrXlibSurface);
usedKnobs.xlibSurface = true;
}
if (mGlobalInfo.fuchsiaImagePipeSurface) {
extensionsToRequest.push_back(kExtensionNameFuchsiaImagePipeSurface);
usedKnobs.fuchsiaImagePipeSurface = true;
}
VkApplicationInfo appInfo;
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;

6
src/dawn_native/vulkan/VulkanFunctions.cpp
View File

@ -103,6 +103,12 @@ namespace dawn_native { namespace vulkan {
GET_INSTANCE_PROC(GetPhysicalDeviceSurfacePresentModesKHR);
}
#ifdef VK_USE_PLATFORM_FUCHSIA
if (globalInfo.fuchsiaImagePipeSurface) {
GET_INSTANCE_PROC(CreateImagePipeSurfaceFUCHSIA);
}
#endif
return {};
}

5
src/dawn_native/vulkan/VulkanFunctions.h
View File

@ -106,6 +106,11 @@ namespace dawn_native { namespace vulkan {
PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR
GetPhysicalDeviceSparseImageFormatProperties2KHR = nullptr;
#ifdef VK_USE_PLATFORM_FUCHSIA
// FUCHSIA_image_pipe_surface
PFN_vkCreateImagePipeSurfaceFUCHSIA CreateImagePipeSurfaceFUCHSIA = nullptr;
#endif
// ---------- Device procs
// Core Vulkan 1.0

57
src/dawn_native/vulkan/VulkanInfo.cpp
View File

@ -27,6 +27,22 @@ namespace {
bool IsExtensionName(const VkExtensionProperties& extension, const char* name) {
return strncmp(extension.extensionName, name, VK_MAX_EXTENSION_NAME_SIZE) == 0;
}
bool EnumerateInstanceExtensions(const char* layerName,
const dawn_native::vulkan::VulkanFunctions& vkFunctions,
std::vector<VkExtensionProperties>* extensions) {
uint32_t count = 0;
VkResult result =
vkFunctions.EnumerateInstanceExtensionProperties(layerName, &count, nullptr);
if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
return false;
}
extensions->resize(count);
result =
vkFunctions.EnumerateInstanceExtensionProperties(layerName, &count, extensions->data());
return (result == VK_SUCCESS);
}
} // namespace
namespace dawn_native { namespace vulkan {
@ -34,6 +50,7 @@ namespace dawn_native { namespace vulkan {
const char kLayerNameLunargStandardValidation[] = "VK_LAYER_LUNARG_standard_validation";
const char kLayerNameLunargVKTrace[] = "VK_LAYER_LUNARG_vktrace";
const char kLayerNameRenderDocCapture[] = "VK_LAYER_RENDERDOC_Capture";
const char kLayerNameFuchsiaImagePipeSwapchain[] = "VK_LAYER_FUCHSIA_imagepipe_swapchain";
const char kExtensionNameExtDebugMarker[] = "VK_EXT_debug_marker";
const char kExtensionNameExtDebugReport[] = "VK_EXT_debug_report";
@ -54,6 +71,7 @@ namespace dawn_native { namespace vulkan {
const char kExtensionNameKhrWin32Surface[] = "VK_KHR_win32_surface";
const char kExtensionNameKhrXcbSurface[] = "VK_KHR_xcb_surface";
const char kExtensionNameKhrXlibSurface[] = "VK_KHR_xlib_surface";
const char kExtensionNameFuchsiaImagePipeSurface[] = "VK_FUCHSIA_imagepipe_surface";
ResultOrError<VulkanGlobalInfo> GatherGlobalInfo(const Backend& backend) {
VulkanGlobalInfo info = {};
@ -86,22 +104,18 @@ namespace dawn_native { namespace vulkan {
if (IsLayerName(layer, kLayerNameRenderDocCapture)) {
info.renderDocCapture = true;
}
// Technical note: Fuchsia implements the swapchain through
// a layer (VK_LAYER_FUCHSIA_image_pipe_swapchain), which adds
// an instance extensions (VK_FUCHSIA_image_surface) to all ICDs.
if (IsLayerName(layer, kLayerNameFuchsiaImagePipeSwapchain)) {
info.fuchsiaImagePipeSwapchain = true;
}
}
}
// Gather the info about the instance extensions
{
uint32_t count = 0;
VkResult result =
vkFunctions.EnumerateInstanceExtensionProperties(nullptr, &count, nullptr);
if (result != VK_SUCCESS && result != VK_INCOMPLETE) {
return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
}
info.extensions.resize(count);
result = vkFunctions.EnumerateInstanceExtensionProperties(nullptr, &count,
info.extensions.data());
if (result != VK_SUCCESS) {
if (!EnumerateInstanceExtensions(nullptr, vkFunctions, &info.extensions)) {
return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
}
@ -136,6 +150,27 @@ namespace dawn_native { namespace vulkan {
if (IsExtensionName(extension, kExtensionNameKhrXlibSurface)) {
info.xlibSurface = true;
}
if (IsExtensionName(extension, kExtensionNameFuchsiaImagePipeSurface)) {
info.fuchsiaImagePipeSurface = true;
}
}
}
// Specific handling for the Fuchsia swapchain surface creation extension
// which is normally part of the Fuchsia-specific swapchain layer.
if (info.fuchsiaImagePipeSwapchain && !info.fuchsiaImagePipeSurface) {
std::vector<VkExtensionProperties> layer_extensions;
if (!EnumerateInstanceExtensions(kLayerNameFuchsiaImagePipeSwapchain, vkFunctions,
&layer_extensions)) {
return DAWN_DEVICE_LOST_ERROR("vkEnumerateInstanceExtensionProperties");
}
for (const auto& extension : layer_extensions) {
if (IsExtensionName(extension, kExtensionNameFuchsiaImagePipeSurface)) {
info.fuchsiaImagePipeSurface = true;
// For now, copy this to the global extension list.
info.extensions.push_back(extension);
}
}
}

4
src/dawn_native/vulkan/VulkanInfo.h
View File

@ -28,6 +28,7 @@ namespace dawn_native { namespace vulkan {
extern const char kLayerNameLunargStandardValidation[];
extern const char kLayerNameLunargVKTrace[];
extern const char kLayerNameRenderDocCapture[];
extern const char kLayerNameFuchsiaImagePipeSwapchain[];
extern const char kExtensionNameExtDebugMarker[];
extern const char kExtensionNameExtDebugReport[];
@ -45,6 +46,7 @@ namespace dawn_native { namespace vulkan {
extern const char kExtensionNameKhrWin32Surface[];
extern const char kExtensionNameKhrXcbSurface[];
extern const char kExtensionNameKhrXlibSurface[];
extern const char kExtensionNameFuchsiaImagePipeSurface[];
// Global information - gathered before the instance is created
struct VulkanGlobalKnobs {
@ -52,6 +54,7 @@ namespace dawn_native { namespace vulkan {
bool standardValidation = false;
bool vktrace = false;
bool renderDocCapture = false;
bool fuchsiaImagePipeSwapchain = false;
// Extensions
bool debugReport = false;
@ -64,6 +67,7 @@ namespace dawn_native { namespace vulkan {
bool win32Surface = false;
bool xcbSurface = false;
bool xlibSurface = false;
bool fuchsiaImagePipeSurface = false;
};
struct VulkanGlobalInfo : VulkanGlobalKnobs {

100
src/utils/Glfw3Fuchsia.cpp Normal file
View File

@ -0,0 +1,100 @@
// Copyright 2019 The Dawn Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// A mock GLFW implementation that supports Fuchsia, but only implements
// the functions called from Dawn.
// NOTE: This must be included before GLFW/glfw3.h because the latter will
// include <vulkan/vulkan.h> and "common/vulkan_platform.h" wants to be
// the first header to do so for sanity reasons (e.g. undefining weird
// macros on Windows and Linux).
// clang-format off
#include "common/vulkan_platform.h"
#include "common/Assert.h"
#include <GLFW/glfw3.h>
// clang-format on
#include <dlfcn.h>
int glfwInit(void) {
return GLFW_TRUE;
}
void glfwDefaultWindowHints(void) {
}
void glfwWindowHint(int hint, int value) {
DAWN_UNUSED(hint);
DAWN_UNUSED(value);
}
struct GLFWwindow {
PFN_vkGetInstanceProcAddr GetInstanceProcAddress = nullptr;
void* vulkan_loader = nullptr;
GLFWwindow() {
vulkan_loader = ::dlopen("libvulkan.so", RTLD_NOW);
ASSERT(vulkan_loader != nullptr);
GetInstanceProcAddress = reinterpret_cast<PFN_vkGetInstanceProcAddr>(
dlsym(vulkan_loader, "vkGetInstanceProcAddr"));
ASSERT(GetInstanceProcAddress != nullptr);
}
~GLFWwindow() {
if (vulkan_loader) {
::dlclose(vulkan_loader);
}
vulkan_loader = nullptr;
}
};
GLFWwindow* glfwCreateWindow(int width,
int height,
const char* title,
GLFWmonitor* monitor,
GLFWwindow* share) {
ASSERT(monitor == nullptr);
ASSERT(share == nullptr);
DAWN_UNUSED(width);
DAWN_UNUSED(height);
DAWN_UNUSED(title);
return new GLFWwindow();
}
VkResult glfwCreateWindowSurface(VkInstance instance,
GLFWwindow* window,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface) {
// IMPORTANT: This assumes that the VkInstance was created with a Fuchsia
// swapchain layer enabled, as well as the corresponding extension that
// is queried here to perform the surface creation. Dawn should do all
// required steps in VulkanInfo.cpp, VulkanFunctions.cpp and BackendVk.cpp.
auto vkCreateImagePipeSurfaceFUCHSIA = reinterpret_cast<PFN_vkCreateImagePipeSurfaceFUCHSIA>(
window->GetInstanceProcAddress(instance, "vkCreateImagePipeSurfaceFUCHSIA"));
ASSERT(vkCreateImagePipeSurfaceFUCHSIA != nullptr);
if (!vkCreateImagePipeSurfaceFUCHSIA) {
*surface = VK_NULL_HANDLE;
return VK_ERROR_FEATURE_NOT_PRESENT;
}
const struct VkImagePipeSurfaceCreateInfoFUCHSIA create_info = {
VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
nullptr, // pNext
0, // flags, ignored for now
ZX_HANDLE_INVALID, // imagePipeHandle, a null handle matches the framebuffer.
};
return vkCreateImagePipeSurfaceFUCHSIA(instance, &create_info, nullptr, surface);
}