aboutsummaryrefslogtreecommitdiffhomepage
path: root/tools
diff options
context:
space:
mode:
Diffstat (limited to 'tools')
-rw-r--r--tools/gpu/vk/VkTestContext.cpp89
-rw-r--r--tools/gpu/vk/VkTestContext.h2
-rw-r--r--tools/gpu/vk/VkTestUtils.cpp17
-rw-r--r--tools/sk_app/VulkanWindowContext.cpp3
-rw-r--r--tools/sk_app/VulkanWindowContext.h48
5 files changed, 94 insertions, 65 deletions
diff --git a/tools/gpu/vk/VkTestContext.cpp b/tools/gpu/vk/VkTestContext.cpp
index 32a1205107..97508b2de4 100644
--- a/tools/gpu/vk/VkTestContext.cpp
+++ b/tools/gpu/vk/VkTestContext.cpp
@@ -15,6 +15,11 @@
#include "vk/GrVkUtil.h"
namespace {
+
+#define ACQUIRE_VK_PROC(name, device) \
+ f##name = reinterpret_cast<PFN_vk##name>(getProc("vk" #name, nullptr, device)); \
+ SkASSERT(f##name);
+
/**
* Implements sk_gpu_test::FenceSync for Vulkan. It creates a single command
* buffer with USAGE_SIMULTANEOUS with no content . On every insertFence request
@@ -22,18 +27,30 @@ namespace {
*/
class VkFenceSync : public sk_gpu_test::FenceSync {
public:
- VkFenceSync(sk_sp<const GrVkInterface> vk, VkDevice device, VkQueue queue,
+ VkFenceSync(GrVkGetProc getProc, VkDevice device, VkQueue queue,
uint32_t queueFamilyIndex)
- : fVk(std::move(vk))
- , fDevice(device)
+ : fDevice(device)
, fQueue(queue) {
+ ACQUIRE_VK_PROC(CreateCommandPool, device);
+ ACQUIRE_VK_PROC(DestroyCommandPool, device);
+ ACQUIRE_VK_PROC(AllocateCommandBuffers, device);
+ ACQUIRE_VK_PROC(FreeCommandBuffers, device);
+ ACQUIRE_VK_PROC(BeginCommandBuffer, device);
+ ACQUIRE_VK_PROC(EndCommandBuffer, device);
+ ACQUIRE_VK_PROC(CreateFence, device);
+ ACQUIRE_VK_PROC(DestroyFence, device);
+ ACQUIRE_VK_PROC(WaitForFences, device);
+ ACQUIRE_VK_PROC(QueueSubmit, device);
+
+ VkResult result;
SkDEBUGCODE(fUnfinishedSyncs = 0;)
VkCommandPoolCreateInfo createInfo;
createInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
createInfo.pNext = nullptr;
createInfo.flags = 0;
createInfo.queueFamilyIndex = queueFamilyIndex;
- GR_VK_CALL_ERRCHECK(fVk, CreateCommandPool(fDevice, &createInfo, nullptr, &fCommandPool));
+ result = fCreateCommandPool(fDevice, &createInfo, nullptr, &fCommandPool);
+ SkASSERT(VK_SUCCESS == result);
VkCommandBufferAllocateInfo allocateInfo;
allocateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@@ -41,31 +58,39 @@ public:
allocateInfo.commandBufferCount = 1;
allocateInfo.commandPool = fCommandPool;
allocateInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
- GR_VK_CALL_ERRCHECK(fVk, AllocateCommandBuffers(fDevice, &allocateInfo, &fCommandBuffer));
+ result = fAllocateCommandBuffers(fDevice, &allocateInfo, &fCommandBuffer);
+ SkASSERT(VK_SUCCESS == result);
VkCommandBufferBeginInfo beginInfo;
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
beginInfo.pNext = nullptr;
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT;
beginInfo.pInheritanceInfo = nullptr;
- GR_VK_CALL_ERRCHECK(fVk, BeginCommandBuffer(fCommandBuffer, &beginInfo));
- GR_VK_CALL_ERRCHECK(fVk, EndCommandBuffer(fCommandBuffer));
+ result = fBeginCommandBuffer(fCommandBuffer, &beginInfo);
+ SkASSERT(VK_SUCCESS == result);
+ result = fEndCommandBuffer(fCommandBuffer);
+ SkASSERT(VK_SUCCESS == result);
+
}
~VkFenceSync() override {
SkASSERT(!fUnfinishedSyncs);
// If the above assertion is true then the command buffer should not be in flight.
- GR_VK_CALL(fVk, FreeCommandBuffers(fDevice, fCommandPool, 1, &fCommandBuffer));
- GR_VK_CALL(fVk, DestroyCommandPool(fDevice, fCommandPool, nullptr));
+ fFreeCommandBuffers(fDevice, fCommandPool, 1, &fCommandBuffer);
+ fDestroyCommandPool(fDevice, fCommandPool, nullptr);
}
sk_gpu_test::PlatformFence SK_WARN_UNUSED_RESULT insertFence() const override {
+ VkResult result;
+
VkFence fence;
VkFenceCreateInfo info;
info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
info.pNext = nullptr;
info.flags = 0;
- GR_VK_CALL_ERRCHECK(fVk, CreateFence(fDevice, &info, nullptr, &fence));
+ result = fCreateFence(fDevice, &info, nullptr, &fence);
+ SkASSERT(VK_SUCCESS == result);
+
VkSubmitInfo submitInfo;
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
submitInfo.pNext = nullptr;
@@ -76,7 +101,9 @@ public:
submitInfo.pCommandBuffers = &fCommandBuffer;
submitInfo.signalSemaphoreCount = 0;
submitInfo.pSignalSemaphores = nullptr;
- GR_VK_CALL_ERRCHECK(fVk, QueueSubmit(fQueue, 1, &submitInfo, fence));
+ result = fQueueSubmit(fQueue, 1, &submitInfo, fence);
+ SkASSERT(VK_SUCCESS == result);
+
SkDEBUGCODE(++fUnfinishedSyncs;)
return (sk_gpu_test::PlatformFence)fence;
}
@@ -84,22 +111,33 @@ public:
bool waitFence(sk_gpu_test::PlatformFence opaqueFence) const override {
VkFence fence = (VkFence)opaqueFence;
static constexpr uint64_t kForever = ~((uint64_t)0);
- auto result = GR_VK_CALL(fVk, WaitForFences(fDevice, 1, &fence, true, kForever));
+ auto result = fWaitForFences(fDevice, 1, &fence, true, kForever);
return result != VK_TIMEOUT;
}
void deleteFence(sk_gpu_test::PlatformFence opaqueFence) const override {
VkFence fence = (VkFence)opaqueFence;
- GR_VK_CALL(fVk, DestroyFence(fDevice, fence, nullptr));
+ fDestroyFence(fDevice, fence, nullptr);
SkDEBUGCODE(--fUnfinishedSyncs;)
}
private:
- sk_sp<const GrVkInterface> fVk;
VkDevice fDevice;
VkQueue fQueue;
VkCommandPool fCommandPool;
VkCommandBuffer fCommandBuffer;
+
+ PFN_vkCreateCommandPool fCreateCommandPool = nullptr;
+ PFN_vkDestroyCommandPool fDestroyCommandPool = nullptr;
+ PFN_vkAllocateCommandBuffers fAllocateCommandBuffers = nullptr;
+ PFN_vkFreeCommandBuffers fFreeCommandBuffers = nullptr;
+ PFN_vkBeginCommandBuffer fBeginCommandBuffer = nullptr;
+ PFN_vkEndCommandBuffer fEndCommandBuffer = nullptr;
+ PFN_vkCreateFence fCreateFence = nullptr;
+ PFN_vkDestroyFence fDestroyFence = nullptr;
+ PFN_vkWaitForFences fWaitForFences = nullptr;
+ PFN_vkQueueSubmit fQueueSubmit = nullptr;
+
SkDEBUGCODE(mutable int fUnfinishedSyncs;)
typedef sk_gpu_test::FenceSync INHERITED;
};
@@ -146,19 +184,30 @@ public:
}
protected:
+#define ACQUIRE_VK_PROC_LOCAL(name, inst) \
+ PFN_vk##name grVk##name = \
+ reinterpret_cast<PFN_vk##name>(fVk.fGetProc("vk" #name, inst, nullptr)); \
+ if (grVk##name == nullptr) { \
+ SkDebugf("Function ptr for vk%s could not be acquired\n", #name); \
+ return; \
+ }
+
void teardown() override {
INHERITED::teardown();
fVk.fMemoryAllocator.reset();
if (fOwnsContext) {
- GR_VK_CALL(this->vk(), DeviceWaitIdle(fVk.fDevice));
- GR_VK_CALL(this->vk(), DestroyDevice(fVk.fDevice, nullptr));
+ ACQUIRE_VK_PROC_LOCAL(DeviceWaitIdle, fVk.fInstance);
+ ACQUIRE_VK_PROC_LOCAL(DestroyDevice, fVk.fInstance);
+ ACQUIRE_VK_PROC_LOCAL(DestroyInstance, fVk.fInstance);
+ grVkDeviceWaitIdle(fVk.fDevice);
+ grVkDestroyDevice(fVk.fDevice, nullptr);
#ifdef SK_ENABLE_VK_LAYERS
if (fDebugCallback != VK_NULL_HANDLE) {
- GR_VK_CALL(this->vk(), DestroyDebugReportCallbackEXT(fVk.fInstance, fDebugCallback,
- nullptr));
+ ACQUIRE_VK_PROC_LOCAL(DestroyDebugReportCallbackEXT, fVk.fInstance);
+ grVkDestroyDebugReportCallbackEXT(fVk.fInstance, fDebugCallback, nullptr);
}
#endif
- GR_VK_CALL(this->vk(), DestroyInstance(fVk.fInstance, nullptr));
+ grVkDestroyInstance(fVk.fInstance, nullptr);
}
}
@@ -166,7 +215,7 @@ private:
VkTestContextImpl(const GrVkBackendContext& backendContext, bool ownsContext,
VkDebugReportCallbackEXT debugCallback)
: VkTestContext(backendContext, ownsContext, debugCallback) {
- fFenceSync.reset(new VkFenceSync(fVk.fInterface, fVk.fDevice, fVk.fQueue,
+ fFenceSync.reset(new VkFenceSync(fVk.fGetProc, fVk.fDevice, fVk.fQueue,
fVk.fGraphicsQueueIndex));
}
diff --git a/tools/gpu/vk/VkTestContext.h b/tools/gpu/vk/VkTestContext.h
index 920f53534e..f3274c55cf 100644
--- a/tools/gpu/vk/VkTestContext.h
+++ b/tools/gpu/vk/VkTestContext.h
@@ -23,8 +23,6 @@ public:
return fVk;
}
- const GrVkInterface* vk() const { return fVk.fInterface.get(); }
-
protected:
VkTestContext(const GrVkBackendContext& vk, bool ownsContext,
VkDebugReportCallbackEXT debugCallback)
diff --git a/tools/gpu/vk/VkTestUtils.cpp b/tools/gpu/vk/VkTestUtils.cpp
index e6ddda2fce..017d767dc5 100644
--- a/tools/gpu/vk/VkTestUtils.cpp
+++ b/tools/gpu/vk/VkTestUtils.cpp
@@ -138,8 +138,8 @@ bool CreateVkBackendContext(const GrVkInterface::GetInstanceProc& getInstancePro
VkDebugReportCallbackEXT* debugCallback,
uint32_t* presentQueueIndexPtr,
CanPresentFn canPresent) {
- auto getProc = [&getInstanceProc, &getDeviceProc](const char* proc_name,
- VkInstance instance, VkDevice device) {
+ auto getProc = [getInstanceProc, getDeviceProc](const char* proc_name,
+ VkInstance instance, VkDevice device) {
if (device != VK_NULL_HANDLE) {
return getDeviceProc(device, proc_name);
}
@@ -406,16 +406,6 @@ bool CreateVkBackendContext(const GrVkInterface::GetInstanceProc& getInstancePro
return false;
}
- auto interface =
- sk_make_sp<GrVkInterface>(getProc, inst, device, extensionFlags);
- if (!interface->validate(extensionFlags)) {
- SkDebugf("Vulkan interface validation failed\n");
- grVkDeviceWaitIdle(device);
- grVkDestroyDevice(device, nullptr);
- destroy_instance(getProc, inst, debugCallback, hasDebugExtension);
- return false;
- }
-
VkQueue queue;
grVkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
@@ -427,7 +417,8 @@ bool CreateVkBackendContext(const GrVkInterface::GetInstanceProc& getInstancePro
ctx->fMinAPIVersion = kGrVkMinimumVersion;
ctx->fExtensions = extensionFlags;
ctx->fFeatures = featureFlags;
- ctx->fInterface.reset(interface.release());
+ ctx->fInterface = nullptr;
+ ctx->fGetProc = getProc;
ctx->fOwnsInstanceAndDevice = false;
return true;
diff --git a/tools/sk_app/VulkanWindowContext.cpp b/tools/sk_app/VulkanWindowContext.cpp
index 0d1b268d8c..6d39890dff 100644
--- a/tools/sk_app/VulkanWindowContext.cpp
+++ b/tools/sk_app/VulkanWindowContext.cpp
@@ -66,7 +66,8 @@ void VulkanWindowContext::initializeContext() {
fDevice = backendContext.fDevice;
fGraphicsQueueIndex = backendContext.fGraphicsQueueIndex;
fGraphicsQueue = backendContext.fQueue;
- fInterface = backendContext.fInterface;
+ fInterface.reset(new GrVkInterface(backendContext.fGetProc, fInstance, fDevice,
+ backendContext.fExtensions));
GET_PROC(DestroyInstance);
GET_PROC(DestroySurfaceKHR);
diff --git a/tools/sk_app/VulkanWindowContext.h b/tools/sk_app/VulkanWindowContext.h
index 3d9687b674..2e01e291b7 100644
--- a/tools/sk_app/VulkanWindowContext.h
+++ b/tools/sk_app/VulkanWindowContext.h
@@ -70,42 +70,32 @@ private:
VkDevice fDevice = VK_NULL_HANDLE;
VkDebugReportCallbackEXT fDebugCallback = VK_NULL_HANDLE;
- // simple wrapper class that exists only to initialize a pointer to NULL
- template <typename FNPTR_TYPE> class VkPtr {
- public:
- VkPtr() : fPtr(NULL) {}
- VkPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
- operator FNPTR_TYPE() const { return fPtr; }
- private:
- FNPTR_TYPE fPtr;
- };
-
// Create functions
CreateVkSurfaceFn fCreateVkSurfaceFn;
CanPresentFn fCanPresentFn;
// Vulkan GetProcAddr functions
- VkPtr<PFN_vkGetInstanceProcAddr> fGetInstanceProcAddr;
- VkPtr<PFN_vkGetDeviceProcAddr> fGetDeviceProcAddr;
+ PFN_vkGetInstanceProcAddr fGetInstanceProcAddr = nullptr;
+ PFN_vkGetDeviceProcAddr fGetDeviceProcAddr = nullptr;
// WSI interface functions
- VkPtr<PFN_vkDestroySurfaceKHR> fDestroySurfaceKHR;
- VkPtr<PFN_vkGetPhysicalDeviceSurfaceSupportKHR> fGetPhysicalDeviceSurfaceSupportKHR;
- VkPtr<PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR> fGetPhysicalDeviceSurfaceCapabilitiesKHR;
- VkPtr<PFN_vkGetPhysicalDeviceSurfaceFormatsKHR> fGetPhysicalDeviceSurfaceFormatsKHR;
- VkPtr<PFN_vkGetPhysicalDeviceSurfacePresentModesKHR> fGetPhysicalDeviceSurfacePresentModesKHR;
-
- VkPtr<PFN_vkCreateSwapchainKHR> fCreateSwapchainKHR;
- VkPtr<PFN_vkDestroySwapchainKHR> fDestroySwapchainKHR;
- VkPtr<PFN_vkGetSwapchainImagesKHR> fGetSwapchainImagesKHR;
- VkPtr<PFN_vkAcquireNextImageKHR> fAcquireNextImageKHR;
- VkPtr<PFN_vkQueuePresentKHR> fQueuePresentKHR;
-
- VkPtr<PFN_vkDestroyInstance> fDestroyInstance;
- VkPtr<PFN_vkDeviceWaitIdle> fDeviceWaitIdle;
- VkPtr<PFN_vkQueueWaitIdle> fQueueWaitIdle;
- VkPtr<PFN_vkDestroyDevice> fDestroyDevice;
- VkPtr<PFN_vkGetDeviceQueue> fGetDeviceQueue;
+ PFN_vkDestroySurfaceKHR fDestroySurfaceKHR = nullptr;
+ PFN_vkGetPhysicalDeviceSurfaceSupportKHR fGetPhysicalDeviceSurfaceSupportKHR = nullptr;
+ PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fGetPhysicalDeviceSurfaceCapabilitiesKHR =nullptr;
+ PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fGetPhysicalDeviceSurfaceFormatsKHR = nullptr;
+ PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fGetPhysicalDeviceSurfacePresentModesKHR =nullptr;
+
+ PFN_vkCreateSwapchainKHR fCreateSwapchainKHR = nullptr;
+ PFN_vkDestroySwapchainKHR fDestroySwapchainKHR = nullptr;
+ PFN_vkGetSwapchainImagesKHR fGetSwapchainImagesKHR = nullptr;
+ PFN_vkAcquireNextImageKHR fAcquireNextImageKHR = nullptr;
+ PFN_vkQueuePresentKHR fQueuePresentKHR = nullptr;
+
+ PFN_vkDestroyInstance fDestroyInstance = nullptr;
+ PFN_vkDeviceWaitIdle fDeviceWaitIdle = nullptr;
+ PFN_vkQueueWaitIdle fQueueWaitIdle = nullptr;
+ PFN_vkDestroyDevice fDestroyDevice = nullptr;
+ PFN_vkGetDeviceQueue fGetDeviceQueue = nullptr;
sk_sp<const GrVkInterface> fInterface;
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-18 19:53:52 +0000