mirror of
https://github.com/UniXNU/NativeMetal.git
synced 2026-11-16 04:24:55 +03:00
69efcdcdc5
Use a writable per-user cache with container fallback, keep Turnip disk caching enabled, and isolate concurrent cache-pack imports. Verify cache round trips, concurrent imports, and the iPadOS 27 plugin compile.
655 lines
34 KiB
C++
655 lines
34 KiB
C++
// SPDX-License-Identifier: MIT
|
|
// Turnip smoke test, run by the Adreno Metal plugin from inside the system process that loaded it (under that process's sandbox) once the raw
|
|
// userspace test (NativeAdrenoUserTest.h) has passed. It loads the real Mesa Turnip driver (libvulkan_freedreno.dylib, built with the native
|
|
// Darwin kernel backend and shipped next to the plugin binary) and drives it through the Vulkan ICD entry points without a loader:
|
|
// instance, physical device, device, queue, a host-visible buffer, one vkCmdFillBuffer, a fence, and a read-back of the fill pattern.
|
|
// Every stage leaves a progress marker (IOServiceOpen type 0x4147<value>, see NativeAdrenoUserTest.h): 6001 library loaded, 6002 entry points,
|
|
// 6003 instance, 6004 physical device, 6005 device, 6007 buffer memory mapped, 6006 command buffer recorded, 6008 submitted, 6009 fence
|
|
// signalled, 600a fill pattern verified; then the shader tests: 6100 compute begins, 6101 pipeline, 6102 recorded, 6103 fence, 6104 all words
|
|
// right (61fS = compute step S failed); 6200 render begins, 6201 pipeline, 6202 recorded, 6203 fence, 6204 image right (62fS = render step S
|
|
// failed); 600b everything destroyed. A setup failure leaves 6fSS (stage SS) followed by 6eRR (RR = -VkResult).
|
|
// The outcome is a short text for the kernel's report row:
|
|
// "T s<stage> r<VkResult> v<fill words> c<compute words> g<triangle pixels>/<stray pixels> <first Vulkan error message>".
|
|
#pragma once
|
|
#define VK_NO_PROTOTYPES 1
|
|
#include <vulkan/vulkan_core.h>
|
|
#include "SharedShaderCache.h"
|
|
#include "NativeTurnipShaders.h" // generated: scripts/gen-turnip-smoke-shaders.py
|
|
#include <dlfcn.h>
|
|
#include <mach/mach.h>
|
|
#include <mach-o/dyld.h>
|
|
#include <pthread.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
// Vulkan create-info structs are written as {sType} with every other member zero.
|
|
#pragma clang diagnostic push
|
|
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
|
|
namespace turnip {
|
|
|
|
static char gFirstError[96];
|
|
|
|
static VKAPI_ATTR VkBool32 VKAPI_CALL onMessage(VkDebugUtilsMessageSeverityFlagBitsEXT severity, VkDebugUtilsMessageTypeFlagsEXT,
|
|
const VkDebugUtilsMessengerCallbackDataEXT *data, void *) {
|
|
if ((severity & VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT) && !gFirstError[0] && data && data->pMessage)
|
|
snprintf(gFirstError, sizeof gFirstError, "%s", data->pMessage);
|
|
return VK_FALSE;
|
|
}
|
|
|
|
struct Result {
|
|
int stage = 0; // first setup failure (0 = none): 1 library .. 9 fence wait
|
|
int vkResult = 0;
|
|
int verified = -1; // fill test: words of 1024 that hold the expected value (-1 = not run)
|
|
int computeWords = -1; // compute test: words of 1024 written by the shader with the expected value (-1 = not run)
|
|
int computeStage = 0; // first failing step of the compute test (0 = none)
|
|
int renderTriangle = -1, renderOther = -1; // render test: triangle-colour pixels, pixels that are neither colour (-1 = not run)
|
|
int renderStage = 0;
|
|
bool ok = false;
|
|
};
|
|
|
|
// Device-level entry points the tests use, resolved once through vkGetDeviceProcAddr.
|
|
#define TURNIP_DEVICE_FNS(X) \
|
|
X(vkDestroyDevice) X(vkGetDeviceQueue) X(vkCreateCommandPool) X(vkDestroyCommandPool) X(vkAllocateCommandBuffers) \
|
|
X(vkResetCommandBuffer) X(vkBeginCommandBuffer) X(vkEndCommandBuffer) X(vkCmdFillBuffer) X(vkCreateBuffer) X(vkDestroyBuffer) \
|
|
X(vkGetBufferMemoryRequirements) X(vkAllocateMemory) X(vkFreeMemory) X(vkBindBufferMemory) X(vkMapMemory) X(vkUnmapMemory) \
|
|
X(vkCreateFence) X(vkDestroyFence) X(vkQueueSubmit) X(vkWaitForFences) X(vkDeviceWaitIdle) X(vkCreateShaderModule) \
|
|
X(vkDestroyShaderModule) X(vkCreateDescriptorSetLayout) X(vkDestroyDescriptorSetLayout) X(vkCreatePipelineLayout) \
|
|
X(vkDestroyPipelineLayout) X(vkCreateComputePipelines) X(vkCreateGraphicsPipelines) X(vkDestroyPipeline) \
|
|
X(vkCreateDescriptorPool) X(vkDestroyDescriptorPool) X(vkAllocateDescriptorSets) X(vkUpdateDescriptorSets) \
|
|
X(vkCmdBindPipeline) X(vkCmdBindDescriptorSets) X(vkCmdPushConstants) X(vkCmdDispatch) X(vkCmdPipelineBarrier) \
|
|
X(vkCreateImage) X(vkDestroyImage) X(vkGetImageMemoryRequirements) X(vkBindImageMemory) X(vkCreateImageView) \
|
|
X(vkDestroyImageView) X(vkCreateRenderPass) X(vkDestroyRenderPass) X(vkCreateFramebuffer) X(vkDestroyFramebuffer) \
|
|
X(vkCmdBeginRenderPass) X(vkCmdEndRenderPass) X(vkCmdDraw) X(vkCmdCopyImageToBuffer)
|
|
|
|
struct Device {
|
|
VkDevice device = nullptr;
|
|
VkQueue queue = nullptr;
|
|
VkCommandPool pool = nullptr;
|
|
VkCommandBuffer cmd = nullptr;
|
|
VkPhysicalDeviceMemoryProperties memory = {};
|
|
#define TURNIP_DECLARE(name) PFN_##name name = nullptr;
|
|
TURNIP_DEVICE_FNS(TURNIP_DECLARE)
|
|
#undef TURNIP_DECLARE
|
|
|
|
uint32_t memoryType(uint32_t bits, VkMemoryPropertyFlags flags) const {
|
|
for (uint32_t i = 0; i < memory.memoryTypeCount; ++i)
|
|
if ((bits & (1u << i)) && (memory.memoryTypes[i].propertyFlags & flags) == flags) return i;
|
|
return UINT32_MAX;
|
|
}
|
|
// Records into the one command buffer, submits it with a fresh fence and waits up to five seconds.
|
|
VkResult submitAndWait() {
|
|
VkFenceCreateInfo fci = {VK_STRUCTURE_TYPE_FENCE_CREATE_INFO};
|
|
VkFence fence = nullptr;
|
|
VkResult r = vkCreateFence(device, &fci, nullptr, &fence);
|
|
if (r != VK_SUCCESS) return r;
|
|
VkSubmitInfo si = {VK_STRUCTURE_TYPE_SUBMIT_INFO};
|
|
si.commandBufferCount = 1;
|
|
si.pCommandBuffers = &cmd;
|
|
r = vkQueueSubmit(queue, 1, &si, fence);
|
|
if (r == VK_SUCCESS) r = vkWaitForFences(device, 1, &fence, VK_TRUE, 5000000000ull);
|
|
vkDestroyFence(device, fence, nullptr);
|
|
return r;
|
|
}
|
|
VkResult begin() {
|
|
vkResetCommandBuffer(cmd, 0);
|
|
VkCommandBufferBeginInfo bi = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
|
|
bi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
return vkBeginCommandBuffer(cmd, &bi);
|
|
}
|
|
};
|
|
|
|
// A host-visible buffer with its memory, mapped for the CPU.
|
|
struct HostBuffer {
|
|
VkBuffer buffer = nullptr;
|
|
VkDeviceMemory memory = nullptr;
|
|
volatile uint32_t *words = nullptr;
|
|
VkResult create(Device &d, VkDeviceSize bytes, VkBufferUsageFlags usage) {
|
|
VkBufferCreateInfo bci = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
bci.size = bytes;
|
|
bci.usage = usage;
|
|
bci.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
VkResult r = d.vkCreateBuffer(d.device, &bci, nullptr, &buffer);
|
|
if (r != VK_SUCCESS) return r;
|
|
VkMemoryRequirements req = {};
|
|
d.vkGetBufferMemoryRequirements(d.device, buffer, &req);
|
|
const uint32_t type = d.memoryType(req.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
if (type == UINT32_MAX) return VK_ERROR_FEATURE_NOT_PRESENT;
|
|
VkMemoryAllocateInfo mai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
mai.allocationSize = req.size;
|
|
mai.memoryTypeIndex = type;
|
|
r = d.vkAllocateMemory(d.device, &mai, nullptr, &memory);
|
|
if (r == VK_SUCCESS) r = d.vkBindBufferMemory(d.device, buffer, memory, 0);
|
|
void *mapped = nullptr;
|
|
if (r == VK_SUCCESS) r = d.vkMapMemory(d.device, memory, 0, bytes, 0, &mapped);
|
|
words = static_cast<volatile uint32_t *>(mapped);
|
|
return r != VK_SUCCESS ? r : (words ? VK_SUCCESS : VK_ERROR_MEMORY_MAP_FAILED);
|
|
}
|
|
void destroy(Device &d) {
|
|
if (words) d.vkUnmapMemory(d.device, memory);
|
|
if (buffer) d.vkDestroyBuffer(d.device, buffer, nullptr);
|
|
if (memory) d.vkFreeMemory(d.device, memory, nullptr);
|
|
*this = HostBuffer();
|
|
}
|
|
};
|
|
|
|
static VkShaderModule shaderModule(Device &d, const uint32_t *words, size_t bytes) {
|
|
VkShaderModuleCreateInfo ci = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
|
|
ci.codeSize = bytes;
|
|
ci.pCode = words;
|
|
VkShaderModule module = nullptr;
|
|
return d.vkCreateShaderModule(d.device, &ci, nullptr, &module) == VK_SUCCESS ? module : nullptr;
|
|
}
|
|
|
|
static void hostBarrier(Device &d, VkPipelineStageFlags from, VkAccessFlags access) {
|
|
VkMemoryBarrier barrier = {VK_STRUCTURE_TYPE_MEMORY_BARRIER};
|
|
barrier.srcAccessMask = access;
|
|
barrier.dstAccessMask = VK_ACCESS_HOST_READ_BIT;
|
|
d.vkCmdPipelineBarrier(d.cmd, from, VK_PIPELINE_STAGE_HOST_BIT, 0, 1, &barrier, 0, nullptr, 0, nullptr);
|
|
}
|
|
|
|
// Fill: vkCmdFillBuffer of the first half of a 4 KiB buffer (Turnip implements it with its own internal blit). Returns verified words or < 0.
|
|
template <typename Marker>
|
|
static int fillTest(Device &d, Marker &mark, int &failStage, VkResult &failResult) {
|
|
constexpr VkDeviceSize kBytes = 4096;
|
|
constexpr uint32_t kPattern = 0xc0ffee42u;
|
|
HostBuffer b;
|
|
VkResult r = b.create(d, kBytes, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
|
|
if (r != VK_SUCCESS) {b.destroy(d); failStage = 7; failResult = r; return -1;}
|
|
for (unsigned i = 0; i < kBytes / 4; ++i) b.words[i] = 0xdeadbeef;
|
|
mark(0x6007);
|
|
if ((r = d.begin()) != VK_SUCCESS) {b.destroy(d); failStage = 6; failResult = r; return -1;}
|
|
d.vkCmdFillBuffer(d.cmd, b.buffer, 0, kBytes / 2, kPattern); // the first half only: the second half must keep 0xdeadbeef
|
|
hostBarrier(d, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT);
|
|
if ((r = d.vkEndCommandBuffer(d.cmd)) != VK_SUCCESS) {b.destroy(d); failStage = 6; failResult = r; return -1;}
|
|
mark(0x6006);
|
|
mark(0x6008);
|
|
if ((r = d.submitAndWait()) != VK_SUCCESS) {b.destroy(d); failStage = 9; failResult = r; return -1;}
|
|
mark(0x6009);
|
|
int good = 0;
|
|
for (unsigned i = 0; i < kBytes / 8; ++i) good += b.words[i] == kPattern;
|
|
for (unsigned i = kBytes / 8; i < kBytes / 4; ++i) good += b.words[i] == 0xdeadbeefu;
|
|
if (good == int(kBytes / 4)) mark(0x600a);
|
|
b.destroy(d);
|
|
return good;
|
|
}
|
|
|
|
// Compute: 16 workgroups of 64 invocations each write v[i] = i * 3 + 0x1000 (push constants) into a storage buffer.
|
|
template <typename Marker>
|
|
static int computeTest(Device &d, Marker &mark, int &stage) {
|
|
constexpr uint32_t kWords = 1024, kMul = 3, kAdd = 0x1000;
|
|
mark(0x6100);
|
|
HostBuffer b;
|
|
VkShaderModule module = nullptr;
|
|
VkDescriptorSetLayout setLayout = nullptr;
|
|
VkPipelineLayout layout = nullptr;
|
|
VkPipeline pipeline = nullptr;
|
|
VkDescriptorPool pool = nullptr;
|
|
int result = -1;
|
|
auto fail = [&](int s) {stage = s; mark(0x61f0 | s);};
|
|
do {
|
|
if (b.create(d, kWords * 4, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT) != VK_SUCCESS) {fail(1); break;}
|
|
for (uint32_t i = 0; i < kWords; ++i) b.words[i] = 0xdeadbeef;
|
|
if (!(module = shaderModule(d, kSpv_smoke_fill_comp, sizeof kSpv_smoke_fill_comp))) {fail(2); break;}
|
|
VkDescriptorSetLayoutBinding binding = {0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_COMPUTE_BIT, nullptr};
|
|
VkDescriptorSetLayoutCreateInfo dsl = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO};
|
|
dsl.bindingCount = 1;
|
|
dsl.pBindings = &binding;
|
|
if (d.vkCreateDescriptorSetLayout(d.device, &dsl, nullptr, &setLayout) != VK_SUCCESS) {fail(3); break;}
|
|
VkPushConstantRange push = {VK_SHADER_STAGE_COMPUTE_BIT, 0, 8};
|
|
VkPipelineLayoutCreateInfo pl = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
|
|
pl.setLayoutCount = 1;
|
|
pl.pSetLayouts = &setLayout;
|
|
pl.pushConstantRangeCount = 1;
|
|
pl.pPushConstantRanges = &push;
|
|
if (d.vkCreatePipelineLayout(d.device, &pl, nullptr, &layout) != VK_SUCCESS) {fail(4); break;}
|
|
VkComputePipelineCreateInfo cp = {VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO};
|
|
cp.stage = {VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, VK_SHADER_STAGE_COMPUTE_BIT, module, "main", nullptr};
|
|
cp.layout = layout;
|
|
if (d.vkCreateComputePipelines(d.device, nullptr, 1, &cp, nullptr, &pipeline) != VK_SUCCESS) {fail(5); break;}
|
|
mark(0x6101);
|
|
VkDescriptorPoolSize size = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1};
|
|
VkDescriptorPoolCreateInfo dp = {VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO};
|
|
dp.maxSets = 1;
|
|
dp.poolSizeCount = 1;
|
|
dp.pPoolSizes = &size;
|
|
if (d.vkCreateDescriptorPool(d.device, &dp, nullptr, &pool) != VK_SUCCESS) {fail(6); break;}
|
|
VkDescriptorSetAllocateInfo da = {VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO};
|
|
da.descriptorPool = pool;
|
|
da.descriptorSetCount = 1;
|
|
da.pSetLayouts = &setLayout;
|
|
VkDescriptorSet set = nullptr;
|
|
if (d.vkAllocateDescriptorSets(d.device, &da, &set) != VK_SUCCESS) {fail(6); break;}
|
|
VkDescriptorBufferInfo info = {b.buffer, 0, kWords * 4};
|
|
VkWriteDescriptorSet write = {VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET};
|
|
write.dstSet = set;
|
|
write.descriptorCount = 1;
|
|
write.descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
|
|
write.pBufferInfo = &info;
|
|
d.vkUpdateDescriptorSets(d.device, 1, &write, 0, nullptr);
|
|
if (d.begin() != VK_SUCCESS) {fail(7); break;}
|
|
const uint32_t constants[2] = {kMul, kAdd};
|
|
d.vkCmdBindPipeline(d.cmd, VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
|
|
d.vkCmdBindDescriptorSets(d.cmd, VK_PIPELINE_BIND_POINT_COMPUTE, layout, 0, 1, &set, 0, nullptr);
|
|
d.vkCmdPushConstants(d.cmd, layout, VK_SHADER_STAGE_COMPUTE_BIT, 0, sizeof constants, constants);
|
|
d.vkCmdDispatch(d.cmd, kWords / 64, 1, 1);
|
|
hostBarrier(d, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_ACCESS_SHADER_WRITE_BIT);
|
|
if (d.vkEndCommandBuffer(d.cmd) != VK_SUCCESS) {fail(7); break;}
|
|
mark(0x6102);
|
|
if (d.submitAndWait() != VK_SUCCESS) {fail(8); break;}
|
|
mark(0x6103);
|
|
int good = 0;
|
|
for (uint32_t i = 0; i < kWords; ++i) good += b.words[i] == i * kMul + kAdd;
|
|
result = good;
|
|
if (good == int(kWords)) mark(0x6104);
|
|
} while (false);
|
|
if (pipeline) d.vkDestroyPipeline(d.device, pipeline, nullptr);
|
|
if (pool) d.vkDestroyDescriptorPool(d.device, pool, nullptr);
|
|
if (layout) d.vkDestroyPipelineLayout(d.device, layout, nullptr);
|
|
if (setLayout) d.vkDestroyDescriptorSetLayout(d.device, setLayout, nullptr);
|
|
if (module) d.vkDestroyShaderModule(d.device, module, nullptr);
|
|
b.destroy(d);
|
|
return result;
|
|
}
|
|
|
|
// Render: a 64x64 RGBA8 colour attachment cleared to blue, one triangle drawn in orange (push constant), copied to a host buffer.
|
|
// The triangle covers 512 pixels in exact arithmetic; every other pixel must keep the clear colour.
|
|
template <typename Marker>
|
|
static void renderTest(Device &d, Marker &mark, int &stage, int &triangle, int &other) {
|
|
constexpr uint32_t kSize = 64;
|
|
mark(0x6200);
|
|
HostBuffer b;
|
|
VkImage image = nullptr;
|
|
VkDeviceMemory imageMemory = nullptr;
|
|
VkImageView view = nullptr;
|
|
VkRenderPass pass = nullptr;
|
|
VkFramebuffer framebuffer = nullptr;
|
|
VkShaderModule vs = nullptr, fs = nullptr;
|
|
VkPipelineLayout layout = nullptr;
|
|
VkPipeline pipeline = nullptr;
|
|
auto fail = [&](int s) {stage = s; mark(0x62f0 | s);};
|
|
do {
|
|
if (b.create(d, kSize * kSize * 4, VK_BUFFER_USAGE_TRANSFER_DST_BIT) != VK_SUCCESS) {fail(1); break;}
|
|
for (uint32_t i = 0; i < kSize * kSize; ++i) b.words[i] = 0x5a5a5a5a;
|
|
VkImageCreateInfo ic = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO};
|
|
ic.imageType = VK_IMAGE_TYPE_2D;
|
|
ic.format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
ic.extent = {kSize, kSize, 1};
|
|
ic.mipLevels = 1;
|
|
ic.arrayLayers = 1;
|
|
ic.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
ic.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
ic.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
|
|
ic.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
if (d.vkCreateImage(d.device, &ic, nullptr, &image) != VK_SUCCESS) {fail(2); break;}
|
|
VkMemoryRequirements req = {};
|
|
d.vkGetImageMemoryRequirements(d.device, image, &req);
|
|
uint32_t type = d.memoryType(req.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
if (type == UINT32_MAX) type = d.memoryType(req.memoryTypeBits, 0);
|
|
VkMemoryAllocateInfo mai = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
mai.allocationSize = req.size;
|
|
mai.memoryTypeIndex = type;
|
|
if (type == UINT32_MAX || d.vkAllocateMemory(d.device, &mai, nullptr, &imageMemory) != VK_SUCCESS ||
|
|
d.vkBindImageMemory(d.device, image, imageMemory, 0) != VK_SUCCESS) {fail(2); break;}
|
|
VkImageViewCreateInfo vc = {VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO};
|
|
vc.image = image;
|
|
vc.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
vc.format = ic.format;
|
|
vc.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
|
if (d.vkCreateImageView(d.device, &vc, nullptr, &view) != VK_SUCCESS) {fail(3); break;}
|
|
VkAttachmentDescription attachment = {0, ic.format, VK_SAMPLE_COUNT_1_BIT, VK_ATTACHMENT_LOAD_OP_CLEAR, VK_ATTACHMENT_STORE_OP_STORE,
|
|
VK_ATTACHMENT_LOAD_OP_DONT_CARE, VK_ATTACHMENT_STORE_OP_DONT_CARE, VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL};
|
|
VkAttachmentReference ref = {0, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL};
|
|
VkSubpassDescription subpass = {};
|
|
subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
|
|
subpass.colorAttachmentCount = 1;
|
|
subpass.pColorAttachments = &ref;
|
|
VkSubpassDependency after = {0, VK_SUBPASS_EXTERNAL, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
|
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT, 0};
|
|
VkRenderPassCreateInfo rp = {VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO};
|
|
rp.attachmentCount = 1;
|
|
rp.pAttachments = &attachment;
|
|
rp.subpassCount = 1;
|
|
rp.pSubpasses = &subpass;
|
|
rp.dependencyCount = 1;
|
|
rp.pDependencies = &after;
|
|
if (d.vkCreateRenderPass(d.device, &rp, nullptr, &pass) != VK_SUCCESS) {fail(4); break;}
|
|
VkFramebufferCreateInfo fb = {VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO};
|
|
fb.renderPass = pass;
|
|
fb.attachmentCount = 1;
|
|
fb.pAttachments = &view;
|
|
fb.width = kSize;
|
|
fb.height = kSize;
|
|
fb.layers = 1;
|
|
if (d.vkCreateFramebuffer(d.device, &fb, nullptr, &framebuffer) != VK_SUCCESS) {fail(4); break;}
|
|
vs = shaderModule(d, kSpv_smoke_triangle_vert, sizeof kSpv_smoke_triangle_vert);
|
|
fs = shaderModule(d, kSpv_smoke_triangle_frag, sizeof kSpv_smoke_triangle_frag);
|
|
if (!vs || !fs) {fail(5); break;}
|
|
VkPushConstantRange push = {VK_SHADER_STAGE_FRAGMENT_BIT, 0, 16};
|
|
VkPipelineLayoutCreateInfo pl = {VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO};
|
|
pl.pushConstantRangeCount = 1;
|
|
pl.pPushConstantRanges = &push;
|
|
if (d.vkCreatePipelineLayout(d.device, &pl, nullptr, &layout) != VK_SUCCESS) {fail(6); break;}
|
|
VkPipelineShaderStageCreateInfo stages[2] = {
|
|
{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, VK_SHADER_STAGE_VERTEX_BIT, vs, "main", nullptr},
|
|
{VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, nullptr, 0, VK_SHADER_STAGE_FRAGMENT_BIT, fs, "main", nullptr}};
|
|
VkPipelineVertexInputStateCreateInfo vi = {VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO};
|
|
VkPipelineInputAssemblyStateCreateInfo ia = {VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO};
|
|
ia.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
|
|
VkViewport viewport = {0, 0, float(kSize), float(kSize), 0, 1};
|
|
VkRect2D scissor = {{0, 0}, {kSize, kSize}};
|
|
VkPipelineViewportStateCreateInfo vp = {VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO};
|
|
vp.viewportCount = 1;
|
|
vp.pViewports = &viewport;
|
|
vp.scissorCount = 1;
|
|
vp.pScissors = &scissor;
|
|
VkPipelineRasterizationStateCreateInfo rs = {VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO};
|
|
rs.polygonMode = VK_POLYGON_MODE_FILL;
|
|
rs.cullMode = VK_CULL_MODE_NONE;
|
|
rs.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
|
|
rs.lineWidth = 1.0f;
|
|
VkPipelineMultisampleStateCreateInfo ms = {VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO};
|
|
ms.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
|
|
VkPipelineColorBlendAttachmentState blend = {};
|
|
blend.colorWriteMask = 0xf;
|
|
VkPipelineColorBlendStateCreateInfo cb = {VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO};
|
|
cb.attachmentCount = 1;
|
|
cb.pAttachments = &blend;
|
|
VkGraphicsPipelineCreateInfo gp = {VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO};
|
|
gp.stageCount = 2;
|
|
gp.pStages = stages;
|
|
gp.pVertexInputState = &vi;
|
|
gp.pInputAssemblyState = &ia;
|
|
gp.pViewportState = &vp;
|
|
gp.pRasterizationState = &rs;
|
|
gp.pMultisampleState = &ms;
|
|
gp.pColorBlendState = &cb;
|
|
gp.layout = layout;
|
|
gp.renderPass = pass;
|
|
if (d.vkCreateGraphicsPipelines(d.device, nullptr, 1, &gp, nullptr, &pipeline) != VK_SUCCESS) {fail(7); break;}
|
|
mark(0x6201);
|
|
if (d.begin() != VK_SUCCESS) {fail(8); break;}
|
|
VkClearValue clear = {};
|
|
clear.color.float32[2] = 1.0f;
|
|
clear.color.float32[3] = 1.0f;
|
|
VkRenderPassBeginInfo rb = {VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO};
|
|
rb.renderPass = pass;
|
|
rb.framebuffer = framebuffer;
|
|
rb.renderArea = scissor;
|
|
rb.clearValueCount = 1;
|
|
rb.pClearValues = &clear;
|
|
d.vkCmdBeginRenderPass(d.cmd, &rb, VK_SUBPASS_CONTENTS_INLINE);
|
|
d.vkCmdBindPipeline(d.cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
const float color[4] = {1.0f, 0.5f, 0.0f, 1.0f};
|
|
d.vkCmdPushConstants(d.cmd, layout, VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof color, color);
|
|
d.vkCmdDraw(d.cmd, 3, 1, 0, 0);
|
|
d.vkCmdEndRenderPass(d.cmd);
|
|
VkBufferImageCopy copy = {};
|
|
copy.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
|
|
copy.imageExtent = {kSize, kSize, 1};
|
|
d.vkCmdCopyImageToBuffer(d.cmd, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, b.buffer, 1, ©);
|
|
hostBarrier(d, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_ACCESS_TRANSFER_WRITE_BIT);
|
|
if (d.vkEndCommandBuffer(d.cmd) != VK_SUCCESS) {fail(8); break;}
|
|
mark(0x6202);
|
|
if (d.submitAndWait() != VK_SUCCESS) {fail(9); break;}
|
|
mark(0x6203);
|
|
// RGBA8 little-endian words: clear = (0, 0, 255, 255), triangle = (255, 127 or 128, 0, 255).
|
|
int tri = 0, rest = 0;
|
|
for (uint32_t i = 0; i < kSize * kSize; ++i) {
|
|
const uint32_t px = b.words[i];
|
|
if (px == 0xffff0000u) continue;
|
|
if (px == 0xff0080ffu || px == 0xff007fffu) ++tri;
|
|
else ++rest;
|
|
}
|
|
triangle = tri;
|
|
other = rest;
|
|
if (rest == 0 && tri >= 480 && tri <= 544) mark(0x6204);
|
|
} while (false);
|
|
if (pipeline) d.vkDestroyPipeline(d.device, pipeline, nullptr);
|
|
if (layout) d.vkDestroyPipelineLayout(d.device, layout, nullptr);
|
|
if (vs) d.vkDestroyShaderModule(d.device, vs, nullptr);
|
|
if (fs) d.vkDestroyShaderModule(d.device, fs, nullptr);
|
|
if (framebuffer) d.vkDestroyFramebuffer(d.device, framebuffer, nullptr);
|
|
if (pass) d.vkDestroyRenderPass(d.device, pass, nullptr);
|
|
if (view) d.vkDestroyImageView(d.device, view, nullptr);
|
|
if (image) d.vkDestroyImage(d.device, image, nullptr);
|
|
if (imageMemory) d.vkFreeMemory(d.device, imageMemory, nullptr);
|
|
b.destroy(d);
|
|
}
|
|
|
|
template <typename Marker>
|
|
static Result run(Marker &&mark, const char *libraryPath) {
|
|
Result out;
|
|
auto fail = [&](int stage, int result) {
|
|
out.stage = stage;
|
|
out.vkResult = result;
|
|
mark(0x6f00 | stage);
|
|
mark(0x6e00 | ((-result) & 0xff));
|
|
return out;
|
|
};
|
|
// The Darwin backend reaches the driver the same way the plugin does: the AGX accelerator service with open type 0x4147, ABI methods through
|
|
// an admitted selector. The shader cache uses the same writable per-user directory as the Metal runtime.
|
|
setenv("TU_DARWIN_SERVICE", "IOAcceleratorES", 0);
|
|
const std::string sharedCache = sharedShaderCacheDirectory();
|
|
if (!sharedCache.empty()) configureShaderDiskCache(sharedCache);
|
|
// Concurrent binning (BV running ahead of BR) is a performance feature; its barriers make BR wait for BV timestamps. int-058's
|
|
// first fill hung with the ring stopped inside the IB (no fault), before the kernel framed IBs for both threads. Keep it off
|
|
// until a run with the framing has passed.
|
|
setenv("TU_DEBUG", "nocb", 0);
|
|
|
|
void *lib = dlopen(libraryPath, RTLD_NOW | RTLD_LOCAL);
|
|
if (!lib) return fail(1, -1);
|
|
mark(0x6001);
|
|
auto gipa = reinterpret_cast<PFN_vkGetInstanceProcAddr>(dlsym(lib, "vk_icdGetInstanceProcAddr"));
|
|
if (!gipa) return fail(2, -2);
|
|
auto createInstance = reinterpret_cast<PFN_vkCreateInstance>(gipa(nullptr, "vkCreateInstance"));
|
|
if (!createInstance) return fail(2, -3);
|
|
mark(0x6002);
|
|
|
|
const char *extensions[] = {VK_EXT_DEBUG_UTILS_EXTENSION_NAME};
|
|
VkDebugUtilsMessengerCreateInfoEXT messenger = {VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT};
|
|
messenger.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
|
|
messenger.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT;
|
|
messenger.pfnUserCallback = onMessage;
|
|
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO};
|
|
app.pApplicationName = "NativeAdrenoMetal";
|
|
app.apiVersion = VK_API_VERSION_1_1;
|
|
VkInstanceCreateInfo ici = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
|
|
ici.pNext = &messenger;
|
|
ici.pApplicationInfo = &app;
|
|
ici.enabledExtensionCount = 1;
|
|
ici.ppEnabledExtensionNames = extensions;
|
|
VkInstance instance = nullptr;
|
|
VkResult r = createInstance(&ici, nullptr, &instance);
|
|
if (r != VK_SUCCESS) return fail(3, r);
|
|
mark(0x6003);
|
|
|
|
#define INSTANCE_FN(name) auto name = reinterpret_cast<PFN_##name>(gipa(instance, #name)); if (!name) return fail(3, -4)
|
|
INSTANCE_FN(vkEnumeratePhysicalDevices);
|
|
INSTANCE_FN(vkGetPhysicalDeviceMemoryProperties);
|
|
INSTANCE_FN(vkGetPhysicalDeviceQueueFamilyProperties);
|
|
INSTANCE_FN(vkCreateDevice);
|
|
INSTANCE_FN(vkGetDeviceProcAddr);
|
|
INSTANCE_FN(vkDestroyInstance);
|
|
#undef INSTANCE_FN
|
|
|
|
uint32_t count = 1;
|
|
VkPhysicalDevice physical = nullptr;
|
|
r = vkEnumeratePhysicalDevices(instance, &count, &physical);
|
|
if ((r != VK_SUCCESS && r != VK_INCOMPLETE) || !count || !physical) return fail(4, r == VK_SUCCESS ? -5 : r);
|
|
mark(0x6004);
|
|
|
|
uint32_t families = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(physical, &families, nullptr);
|
|
if (!families) return fail(4, -6);
|
|
VkQueueFamilyProperties family[8] = {};
|
|
if (families > 8) families = 8;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(physical, &families, family);
|
|
uint32_t queueFamily = families;
|
|
for (uint32_t i = 0; i < families && queueFamily == families; ++i)
|
|
if (family[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) queueFamily = i;
|
|
if (queueFamily == families) return fail(4, -7);
|
|
|
|
float priority = 1.0f;
|
|
VkDeviceQueueCreateInfo qci = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO};
|
|
qci.queueFamilyIndex = queueFamily;
|
|
qci.queueCount = 1;
|
|
qci.pQueuePriorities = &priority;
|
|
VkDeviceCreateInfo dci = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO};
|
|
dci.queueCreateInfoCount = 1;
|
|
dci.pQueueCreateInfos = &qci;
|
|
Device d;
|
|
r = vkCreateDevice(physical, &dci, nullptr, &d.device);
|
|
if (r != VK_SUCCESS) return fail(5, r);
|
|
mark(0x6005);
|
|
#define TURNIP_RESOLVE(name) d.name = reinterpret_cast<PFN_##name>(vkGetDeviceProcAddr(d.device, #name)); if (!d.name) return fail(5, -8);
|
|
TURNIP_DEVICE_FNS(TURNIP_RESOLVE)
|
|
#undef TURNIP_RESOLVE
|
|
vkGetPhysicalDeviceMemoryProperties(physical, &d.memory);
|
|
d.vkGetDeviceQueue(d.device, queueFamily, 0, &d.queue);
|
|
VkCommandPoolCreateInfo pci = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
|
|
pci.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
pci.queueFamilyIndex = queueFamily;
|
|
r = d.vkCreateCommandPool(d.device, &pci, nullptr, &d.pool);
|
|
if (r != VK_SUCCESS) return fail(6, r);
|
|
VkCommandBufferAllocateInfo cai = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
|
|
cai.commandPool = d.pool;
|
|
cai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
cai.commandBufferCount = 1;
|
|
r = d.vkAllocateCommandBuffers(d.device, &cai, &d.cmd);
|
|
if (r != VK_SUCCESS) return fail(6, r);
|
|
|
|
// The three tests are independent: a failed or unverified one does not stop the next, unless the GPU stopped retiring work (fence timeout).
|
|
int failStage = 0;
|
|
VkResult failResult = VK_SUCCESS;
|
|
out.verified = fillTest(d, mark, failStage, failResult);
|
|
if (failStage) {
|
|
fail(failStage, failResult);
|
|
}
|
|
if (failStage != 9) {
|
|
out.computeWords = computeTest(d, mark, out.computeStage);
|
|
if (out.computeStage != 8) renderTest(d, mark, out.renderStage, out.renderTriangle, out.renderOther);
|
|
}
|
|
|
|
d.vkDeviceWaitIdle(d.device);
|
|
d.vkDestroyCommandPool(d.device, d.pool, nullptr);
|
|
d.vkDestroyDevice(d.device, nullptr);
|
|
vkDestroyInstance(instance, nullptr);
|
|
mark(0x600b);
|
|
out.ok = !failStage && out.verified == 1024 && out.computeWords == 1024 && out.renderOther == 0 && out.renderTriangle >= 480 &&
|
|
out.renderTriangle <= 544;
|
|
return out;
|
|
}
|
|
|
|
// Watchdog. run() executes on a worker thread; if it has not returned after 15, 45 and 90 seconds, the calling thread samples the worker and
|
|
// sends "W <last marker> s<run state> u<user us>/k<system us> over 300 ms, then the stack": the PC, LR and frame-pointer return addresses, each
|
|
// as <image letter><offset in that image> (v = libvulkan_freedreno.dylib; offsets resolve against the unstripped build). A worker that is
|
|
// running in the kernel (system time only, or no time at all: a core parked by the panic screen) is not suspended, because thread_suspend
|
|
// would wait for it forever; its line ends in "kern".
|
|
struct Watched {
|
|
const char *libraryPath;
|
|
void (*mark)(void *, uint32_t);
|
|
void *markContext;
|
|
volatile uint32_t lastMark;
|
|
volatile int done;
|
|
Result result;
|
|
};
|
|
|
|
static void *watchedWorker(void *argument) {
|
|
Watched *w = static_cast<Watched *>(argument);
|
|
w->result = run([w](uint32_t value) { w->lastMark = value; w->mark(w->markContext, value); }, w->libraryPath);
|
|
__atomic_store_n(&w->done, 1, __ATOMIC_RELEASE);
|
|
return nullptr;
|
|
}
|
|
|
|
static size_t frameText(char *out, size_t size, uint64_t address) {
|
|
Dl_info info = {};
|
|
if (!address || !dladdr(reinterpret_cast<const void *>(address), &info) || !info.dli_fbase)
|
|
return (size_t)snprintf(out, size, " ?%llx", (unsigned long long)address);
|
|
const char *name = info.dli_fname ? strrchr(info.dli_fname, '/') : nullptr;
|
|
name = name ? name + 1 : (info.dli_fname ? info.dli_fname : "?");
|
|
const char tag = !strncmp(name, "libvulkan", 9) ? 'v' : name[0];
|
|
return (size_t)snprintf(out, size, " %c%llx", tag, (unsigned long long)(address - reinterpret_cast<uint64_t>(info.dli_fbase)));
|
|
}
|
|
|
|
static void sample(Watched &w, pthread_t worker, char *text, size_t size) {
|
|
const mach_port_t thread = pthread_mach_thread_np(worker);
|
|
thread_basic_info_data_t a = {}, b = {};
|
|
mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
|
|
thread_info(thread, THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(&a), &count);
|
|
usleep(300000);
|
|
count = THREAD_BASIC_INFO_COUNT;
|
|
thread_info(thread, THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(&b), &count);
|
|
auto us = [](time_value_t t) { return int64_t(t.seconds) * 1000000 + t.microseconds; };
|
|
const int64_t du = us(b.user_time) - us(a.user_time), dk = us(b.system_time) - us(a.system_time);
|
|
size_t at = (size_t)snprintf(text, size, "W %x s%d u%lld/k%lld", unsigned(w.lastMark), b.run_state, (long long)du, (long long)dk);
|
|
if (b.run_state == TH_STATE_RUNNING && du <= 0) {
|
|
snprintf(text + at, size - at, " kern");
|
|
return;
|
|
}
|
|
if (thread_suspend(thread) != KERN_SUCCESS) {snprintf(text + at, size - at, " nosusp"); return;}
|
|
arm_thread_state64_t state = {};
|
|
count = ARM_THREAD_STATE64_COUNT;
|
|
if (thread_get_state(thread, ARM_THREAD_STATE64, reinterpret_cast<thread_state_t>(&state), &count) == KERN_SUCCESS) {
|
|
const uint64_t pc = arm_thread_state64_get_pc(state), lr = arm_thread_state64_get_lr(state);
|
|
uint64_t fp = arm_thread_state64_get_fp(state);
|
|
at += frameText(text + at, size - at, pc);
|
|
if (at < size) at += frameText(text + at, size - at, lr);
|
|
const uint64_t low = reinterpret_cast<uint64_t>(pthread_get_stackaddr_np(worker)) - pthread_get_stacksize_np(worker);
|
|
const uint64_t high = reinterpret_cast<uint64_t>(pthread_get_stackaddr_np(worker));
|
|
for (unsigned i = 0; i < 8 && at + 4 < size && fp >= low && fp + 16 <= high && !(fp & 7); ++i) {
|
|
const uint64_t next = reinterpret_cast<const uint64_t *>(fp)[0], ret = reinterpret_cast<const uint64_t *>(fp)[1];
|
|
if (ret != lr || i) at += frameText(text + at, size - at, ret);
|
|
if (next <= fp) break;
|
|
fp = next;
|
|
}
|
|
}
|
|
thread_resume(thread);
|
|
}
|
|
|
|
template <typename Marker, typename Reporter>
|
|
static Result runWatched(Marker &mark, Reporter &&report, const char *libraryPath) {
|
|
Watched *w = new Watched{};
|
|
w->libraryPath = libraryPath;
|
|
w->markContext = &mark;
|
|
w->mark = [](void *context, uint32_t value) { (*static_cast<Marker *>(context))(value); };
|
|
pthread_attr_t attr;
|
|
pthread_attr_init(&attr);
|
|
pthread_attr_setstacksize(&attr, 8u << 20); // Mesa's NIR/ir3 passes recurse; the default 512 KiB secondary stack is small
|
|
pthread_t worker;
|
|
const bool started = pthread_create(&worker, &attr, watchedWorker, w) == 0;
|
|
pthread_attr_destroy(&attr);
|
|
if (!started) {Result r; r.stage = 0; r.vkResult = -12; return r;}
|
|
static const unsigned checkpoints[] = {15, 45, 90};
|
|
unsigned next = 0;
|
|
for (unsigned tenths = 0; !__atomic_load_n(&w->done, __ATOMIC_ACQUIRE); ++tenths) {
|
|
usleep(100000);
|
|
if (next < 3 && tenths == checkpoints[next] * 10) {
|
|
char text[64] = {};
|
|
sample(*w, worker, text, sizeof text);
|
|
report(text);
|
|
++next;
|
|
}
|
|
}
|
|
pthread_join(worker, nullptr);
|
|
Result result = w->result;
|
|
delete w;
|
|
return result;
|
|
}
|
|
|
|
// Path of libvulkan_freedreno.dylib: next to the image this code is part of (the plugin binary inside the bundle).
|
|
static bool libraryPath(char *path, size_t size) {
|
|
Dl_info info = {};
|
|
if (!dladdr(reinterpret_cast<const void *>(&libraryPath), &info) || !info.dli_fname) return false;
|
|
snprintf(path, size, "%s", info.dli_fname);
|
|
char *slash = strrchr(path, '/');
|
|
if (!slash) return false;
|
|
snprintf(slash + 1, size - size_t(slash + 1 - path), "libvulkan_freedreno.dylib");
|
|
return true;
|
|
}
|
|
|
|
} // namespace turnip
|
|
#pragma clang diagnostic pop
|