woutermans
283738d626
- Add docs/in-place-inputs.md: reading the DLSS inputs in place does not work, because a hardware texture fetch on a HIP texture object over memory imported from vkd3d-proton returns stale data while plain loads and cuMemcpy2D are correct; records the measurements, the rule-outs and the reworked-fetch workaround that turned out not to pay for itself. - Add tools/hip_vk_texture_stale_repro.cpp and its build script, the native Vulkan + HIP reproducer that rules out a general ROCm or RADV bug.
480 lines
24 KiB
C++
480 lines
24 KiB
C++
// Standalone check (no Wine, no DLSS): does a HIP texture object created on memory imported from Vulkan
|
|
// see what Vulkan writes to that memory afterwards?
|
|
//
|
|
// 1. Vulkan creates a linear-tiled RGBA16F image (or, with --buffer, a plain buffer) on exportable memory
|
|
// and uploads pattern A.
|
|
// 2. HIP imports the memory, creates a pitch-linear texture object on it and samples it in a kernel.
|
|
// 3. Vulkan uploads pattern B. HIP samples again, and also reads the memory with hipMemcpy.
|
|
// 4. HIP copies the texels out and back (a rewrite with their own bytes) and samples once more.
|
|
//
|
|
// The d4r NGX shim sees step 3's sample return pattern A for game textures while hipMemcpy returns B.
|
|
// usage: hip_vk_texture_stale_repro [--buffer] [--hip-first] [--prewrites N] [--game-usage] [WIDTH HEIGHT]
|
|
// --buffer export a VkBuffer (written with vkCmdCopyBuffer) instead of a linear VkImage
|
|
// --hip-first initialise HIP before the Vulkan object exists (default: after pattern A is uploaded)
|
|
// --prewrites N Vulkan uploads N times (ending on A) before HIP imports the memory (default 1)
|
|
// --game-usage create the image as vkd3d-proton would a render target: more usages, mutable format
|
|
#include <hip/hip_runtime.h>
|
|
#include <vulkan/vulkan.h>
|
|
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <unistd.h>
|
|
#include <vector>
|
|
|
|
__global__ void sample_texture(hipTextureObject_t texture, float* out, int width, int height)
|
|
{
|
|
const int x = blockIdx.x * blockDim.x + threadIdx.x, y = blockIdx.y * blockDim.y + threadIdx.y;
|
|
if (x >= width || y >= height)
|
|
return;
|
|
const float4 texel = tex2D<float4>(texture, x + 0.5f, y + 0.5f);
|
|
float* pixel = out + (static_cast<size_t>(y) * width + x) * 4;
|
|
pixel[0] = texel.x, pixel[1] = texel.y, pixel[2] = texel.z, pixel[3] = texel.w;
|
|
}
|
|
|
|
#define VK_CHECK(call) \
|
|
do \
|
|
{ \
|
|
const VkResult vkResult_ = (call); \
|
|
if (vkResult_ != VK_SUCCESS) \
|
|
{ \
|
|
std::fprintf(stderr, "%s failed: %d\n", #call, vkResult_); \
|
|
std::exit(1); \
|
|
} \
|
|
} while (0)
|
|
#define HIP_CHECK(call) \
|
|
do \
|
|
{ \
|
|
const hipError_t hipResult_ = (call); \
|
|
if (hipResult_ != hipSuccess) \
|
|
{ \
|
|
std::fprintf(stderr, "%s failed: %s\n", #call, hipGetErrorName(hipResult_)); \
|
|
std::exit(1); \
|
|
} \
|
|
} while (0)
|
|
|
|
// Values k/256 only: exact as halves.
|
|
static uint16_t half_of(unsigned k)
|
|
{
|
|
if (k == 0)
|
|
return 0;
|
|
int exponent = 0;
|
|
while ((k >> exponent) > 1)
|
|
++exponent; // k = 1.m * 2^exponent
|
|
const unsigned mantissa = (k << (10 - exponent)) & 0x3ffu;
|
|
return static_cast<uint16_t>((exponent - 8 + 15) << 10 | mantissa);
|
|
}
|
|
|
|
// Pattern 0 ("A") and 1 ("B") differ in every texel.
|
|
static unsigned pattern_value(int pattern, int x, int y, int channel)
|
|
{
|
|
const unsigned base = (x * 7 + y * 13 + channel * 29) % 200;
|
|
return pattern == 0 ? base + 1 : 256 - base;
|
|
}
|
|
|
|
static void fill_pattern(uint16_t* texels, int width, int height, size_t rowPitch, int pattern)
|
|
{
|
|
for (int y = 0; y < height; ++y)
|
|
{
|
|
uint16_t* row = reinterpret_cast<uint16_t*>(reinterpret_cast<uint8_t*>(texels) + y * rowPitch);
|
|
for (int x = 0; x < width; ++x)
|
|
for (int channel = 0; channel < 4; ++channel)
|
|
row[x * 4 + channel] = half_of(pattern_value(pattern, x, y, channel));
|
|
}
|
|
}
|
|
|
|
// Which pattern the floats hold: 'A', 'B', or '?' with the number of texels matching each.
|
|
static char classify(const float* values, int width, int height, size_t* matchA, size_t* matchB)
|
|
{
|
|
*matchA = *matchB = 0;
|
|
for (int y = 0; y < height; ++y)
|
|
for (int x = 0; x < width; ++x)
|
|
{
|
|
bool a = true, b = true;
|
|
for (int channel = 0; channel < 4; ++channel)
|
|
{
|
|
const float value = values[(static_cast<size_t>(y) * width + x) * 4 + channel];
|
|
a &= value == pattern_value(0, x, y, channel) / 256.0f;
|
|
b &= value == pattern_value(1, x, y, channel) / 256.0f;
|
|
}
|
|
*matchA += a, *matchB += b;
|
|
}
|
|
const size_t texels = static_cast<size_t>(width) * height;
|
|
return *matchA == texels ? 'A' : *matchB == texels ? 'B' : '?';
|
|
}
|
|
|
|
static float half_to_float(uint16_t half)
|
|
{
|
|
const int exponent = (half >> 10) & 31, mantissa = half & 0x3ff;
|
|
if (exponent == 0)
|
|
return mantissa / 1024.0f / 16384.0f;
|
|
float value = 1.0f + mantissa / 1024.0f;
|
|
for (int shift = exponent - 15; shift != 0; shift += shift < 0 ? 1 : -1)
|
|
value = shift < 0 ? value / 2 : value * 2;
|
|
return value;
|
|
}
|
|
|
|
struct Vulkan
|
|
{
|
|
VkInstance instance = VK_NULL_HANDLE;
|
|
VkPhysicalDevice physical = VK_NULL_HANDLE;
|
|
VkDevice device = VK_NULL_HANDLE;
|
|
VkQueue queue = VK_NULL_HANDLE;
|
|
VkCommandPool pool = VK_NULL_HANDLE;
|
|
VkCommandBuffer cmd = VK_NULL_HANDLE;
|
|
VkPhysicalDeviceMemoryProperties memory = {};
|
|
};
|
|
|
|
static uint32_t memory_type(const Vulkan& vk, uint32_t typeBits, VkMemoryPropertyFlags wanted)
|
|
{
|
|
for (uint32_t index = 0; index < vk.memory.memoryTypeCount; ++index)
|
|
if ((typeBits & (1u << index)) && (vk.memory.memoryTypes[index].propertyFlags & wanted) == wanted)
|
|
return index;
|
|
std::fprintf(stderr, "no memory type with flags 0x%x\n", wanted);
|
|
std::exit(1);
|
|
}
|
|
|
|
static void submit(const Vulkan& vk)
|
|
{
|
|
VK_CHECK(vkEndCommandBuffer(vk.cmd));
|
|
VkSubmitInfo info = {VK_STRUCTURE_TYPE_SUBMIT_INFO};
|
|
info.commandBufferCount = 1;
|
|
info.pCommandBuffers = &vk.cmd;
|
|
VK_CHECK(vkQueueSubmit(vk.queue, 1, &info, VK_NULL_HANDLE));
|
|
VK_CHECK(vkQueueWaitIdle(vk.queue));
|
|
}
|
|
|
|
static void begin(const Vulkan& vk)
|
|
{
|
|
VkCommandBufferBeginInfo info = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO};
|
|
info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
|
VK_CHECK(vkResetCommandBuffer(vk.cmd, 0));
|
|
VK_CHECK(vkBeginCommandBuffer(vk.cmd, &info));
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
bool useBuffer = false, hipFirst = false, gameUsage = false, zeroInit = false;
|
|
int prewrites = 1, forcedType = -1;
|
|
int width = 1280, height = 720, positional = 0;
|
|
for (int index = 1; index < argc; ++index)
|
|
{
|
|
if (!std::strcmp(argv[index], "--buffer"))
|
|
useBuffer = true;
|
|
else if (!std::strcmp(argv[index], "--hip-first"))
|
|
hipFirst = true;
|
|
else if (!std::strcmp(argv[index], "--zero-init"))
|
|
zeroInit = true; // allocate with VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT, as vkd3d-proton does
|
|
else if (!std::strcmp(argv[index], "--game-usage"))
|
|
gameUsage = true;
|
|
else if (!std::strcmp(argv[index], "--memory-type") && index + 1 < argc)
|
|
forcedType = std::atoi(argv[++index]); // Vulkan memory type index for the shared object
|
|
else if (!std::strcmp(argv[index], "--prewrites") && index + 1 < argc)
|
|
prewrites = std::atoi(argv[++index]);
|
|
else
|
|
(positional++ == 0 ? width : height) = std::atoi(argv[index]);
|
|
}
|
|
if (hipFirst)
|
|
HIP_CHECK(hipInit(0));
|
|
|
|
// --- Vulkan device ---
|
|
Vulkan vk;
|
|
VkApplicationInfo app = {VK_STRUCTURE_TYPE_APPLICATION_INFO};
|
|
app.apiVersion = VK_API_VERSION_1_2;
|
|
VkInstanceCreateInfo instanceInfo = {VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO};
|
|
instanceInfo.pApplicationInfo = &app;
|
|
VK_CHECK(vkCreateInstance(&instanceInfo, nullptr, &vk.instance));
|
|
uint32_t count = 0;
|
|
VK_CHECK(vkEnumeratePhysicalDevices(vk.instance, &count, nullptr));
|
|
std::vector<VkPhysicalDevice> devices(count);
|
|
VK_CHECK(vkEnumeratePhysicalDevices(vk.instance, &count, devices.data()));
|
|
VkPhysicalDeviceProperties properties = {};
|
|
for (VkPhysicalDevice candidate : devices)
|
|
{
|
|
vkGetPhysicalDeviceProperties(candidate, &properties);
|
|
if (properties.vendorID == 0x1002 && properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
|
|
{
|
|
vk.physical = candidate;
|
|
break;
|
|
}
|
|
}
|
|
if (vk.physical == VK_NULL_HANDLE)
|
|
{
|
|
std::fprintf(stderr, "no discrete AMD Vulkan device\n");
|
|
return 1;
|
|
}
|
|
std::printf("Vulkan device: %s (driver version 0x%x)\n", properties.deviceName, properties.driverVersion);
|
|
vkGetPhysicalDeviceMemoryProperties(vk.physical, &vk.memory);
|
|
uint32_t families = 0;
|
|
vkGetPhysicalDeviceQueueFamilyProperties(vk.physical, &families, nullptr);
|
|
std::vector<VkQueueFamilyProperties> familyProperties(families);
|
|
vkGetPhysicalDeviceQueueFamilyProperties(vk.physical, &families, familyProperties.data());
|
|
uint32_t family = 0;
|
|
while (family < families && !(familyProperties[family].queueFlags & VK_QUEUE_GRAPHICS_BIT))
|
|
++family;
|
|
const float priority = 1.0f;
|
|
VkDeviceQueueCreateInfo queueInfo = {VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO};
|
|
queueInfo.queueFamilyIndex = family;
|
|
queueInfo.queueCount = 1;
|
|
queueInfo.pQueuePriorities = &priority;
|
|
const char* extensions[] = {VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, "VK_EXT_zero_initialize_device_memory"};
|
|
VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT zeroFeature = {
|
|
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT};
|
|
zeroFeature.zeroInitializeDeviceMemory = VK_TRUE;
|
|
VkDeviceCreateInfo deviceInfo = {VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, zeroInit ? &zeroFeature : nullptr};
|
|
deviceInfo.queueCreateInfoCount = 1;
|
|
deviceInfo.pQueueCreateInfos = &queueInfo;
|
|
deviceInfo.enabledExtensionCount = zeroInit ? 2 : 1;
|
|
deviceInfo.ppEnabledExtensionNames = extensions;
|
|
VK_CHECK(vkCreateDevice(vk.physical, &deviceInfo, nullptr, &vk.device));
|
|
vkGetDeviceQueue(vk.device, family, 0, &vk.queue);
|
|
VkCommandPoolCreateInfo poolInfo = {VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO};
|
|
poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
|
|
poolInfo.queueFamilyIndex = family;
|
|
VK_CHECK(vkCreateCommandPool(vk.device, &poolInfo, nullptr, &vk.pool));
|
|
VkCommandBufferAllocateInfo cmdInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO};
|
|
cmdInfo.commandPool = vk.pool;
|
|
cmdInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
|
cmdInfo.commandBufferCount = 1;
|
|
VK_CHECK(vkAllocateCommandBuffers(vk.device, &cmdInfo, &vk.cmd));
|
|
|
|
// --- the shared object: a linear image or a buffer on exportable device-local memory ---
|
|
VkExternalMemoryImageCreateInfo externalImage = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO};
|
|
externalImage.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
|
|
VkExternalMemoryBufferCreateInfo externalBuffer = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO};
|
|
externalBuffer.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
|
|
VkImage image = VK_NULL_HANDLE;
|
|
VkBuffer shared = VK_NULL_HANDLE;
|
|
VkMemoryRequirements requirements = {};
|
|
size_t rowPitch = static_cast<size_t>(width) * 8, texelOffset = 0;
|
|
VkMemoryDedicatedAllocateInfo dedicated = {VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO};
|
|
if (useBuffer)
|
|
{
|
|
rowPitch = (rowPitch + 255) & ~static_cast<size_t>(255);
|
|
VkBufferCreateInfo info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, &externalBuffer};
|
|
info.size = rowPitch * height;
|
|
info.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
|
|
VK_CHECK(vkCreateBuffer(vk.device, &info, nullptr, &shared));
|
|
vkGetBufferMemoryRequirements(vk.device, shared, &requirements);
|
|
dedicated.buffer = shared;
|
|
}
|
|
else
|
|
{
|
|
VkImageCreateInfo info = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &externalImage};
|
|
info.imageType = VK_IMAGE_TYPE_2D;
|
|
info.format = VK_FORMAT_R16G16B16A16_SFLOAT;
|
|
info.extent = {static_cast<uint32_t>(width), static_cast<uint32_t>(height), 1};
|
|
info.mipLevels = info.arrayLayers = 1;
|
|
info.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
info.tiling = VK_IMAGE_TILING_LINEAR;
|
|
info.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
|
|
if (gameUsage)
|
|
{
|
|
info.usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
|
|
info.flags |= VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT;
|
|
}
|
|
info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
VK_CHECK(vkCreateImage(vk.device, &info, nullptr, &image));
|
|
vkGetImageMemoryRequirements(vk.device, image, &requirements);
|
|
dedicated.image = image;
|
|
}
|
|
VkExportMemoryAllocateInfo exportInfo = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, &dedicated};
|
|
exportInfo.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
|
|
VkMemoryAllocateFlagsInfo allocateFlags = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, &exportInfo};
|
|
allocateFlags.flags = VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT;
|
|
VkMemoryAllocateInfo allocation = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
|
|
zeroInit ? static_cast<const void*>(&allocateFlags) : &exportInfo};
|
|
allocation.allocationSize = requirements.size;
|
|
allocation.memoryTypeIndex = memory_type(vk, requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
if (forcedType >= 0)
|
|
allocation.memoryTypeIndex = static_cast<uint32_t>(forcedType);
|
|
VkDeviceMemory sharedMemory = VK_NULL_HANDLE;
|
|
VK_CHECK(vkAllocateMemory(vk.device, &allocation, nullptr, &sharedMemory));
|
|
if (useBuffer)
|
|
VK_CHECK(vkBindBufferMemory(vk.device, shared, sharedMemory, 0));
|
|
else
|
|
{
|
|
VK_CHECK(vkBindImageMemory(vk.device, image, sharedMemory, 0));
|
|
const VkImageSubresource subresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0};
|
|
VkSubresourceLayout layout = {};
|
|
vkGetImageSubresourceLayout(vk.device, image, &subresource, &layout);
|
|
rowPitch = layout.rowPitch;
|
|
texelOffset = layout.offset;
|
|
}
|
|
std::printf("shared %s: %dx%d RGBA16F, row pitch %zu, offset %zu, allocation %llu bytes, memory type %u\n",
|
|
useBuffer ? "VkBuffer" : "linear VkImage", width, height, rowPitch, texelOffset,
|
|
static_cast<unsigned long long>(requirements.size), allocation.memoryTypeIndex);
|
|
|
|
// --- host-visible staging buffer for uploads and Vulkan-side readback ---
|
|
const size_t stagingBytes = rowPitch * height;
|
|
VkBufferCreateInfo stagingInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
|
|
stagingInfo.size = stagingBytes;
|
|
stagingInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
|
|
VkBuffer staging = VK_NULL_HANDLE;
|
|
VK_CHECK(vkCreateBuffer(vk.device, &stagingInfo, nullptr, &staging));
|
|
VkMemoryRequirements stagingRequirements = {};
|
|
vkGetBufferMemoryRequirements(vk.device, staging, &stagingRequirements);
|
|
VkMemoryAllocateInfo stagingAllocation = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO};
|
|
stagingAllocation.allocationSize = stagingRequirements.size;
|
|
stagingAllocation.memoryTypeIndex = memory_type(
|
|
vk, stagingRequirements.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
VkDeviceMemory stagingMemory = VK_NULL_HANDLE;
|
|
VK_CHECK(vkAllocateMemory(vk.device, &stagingAllocation, nullptr, &stagingMemory));
|
|
VK_CHECK(vkBindBufferMemory(vk.device, staging, stagingMemory, 0));
|
|
void* stagingMap = nullptr;
|
|
VK_CHECK(vkMapMemory(vk.device, stagingMemory, 0, VK_WHOLE_SIZE, 0, &stagingMap));
|
|
|
|
VkBufferImageCopy region = {};
|
|
region.bufferRowLength = static_cast<uint32_t>(rowPitch / 8);
|
|
region.imageSubresource = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1};
|
|
region.imageExtent = {static_cast<uint32_t>(width), static_cast<uint32_t>(height), 1};
|
|
const VkBufferCopy bufferRegion = {0, 0, stagingBytes};
|
|
bool imageInitialised = false;
|
|
const auto vulkan_upload = [&](int pattern) {
|
|
std::memset(stagingMap, 0, stagingBytes);
|
|
fill_pattern(static_cast<uint16_t*>(stagingMap), width, height, rowPitch, pattern);
|
|
begin(vk);
|
|
if (useBuffer)
|
|
vkCmdCopyBuffer(vk.cmd, staging, shared, 1, &bufferRegion);
|
|
else
|
|
{
|
|
if (!imageInitialised)
|
|
{
|
|
VkImageMemoryBarrier barrier = {VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER};
|
|
barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_TRANSFER_READ_BIT;
|
|
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL;
|
|
barrier.srcQueueFamilyIndex = barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
|
|
barrier.image = image;
|
|
barrier.subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1};
|
|
vkCmdPipelineBarrier(vk.cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0,
|
|
nullptr, 0, nullptr, 1, &barrier);
|
|
imageInitialised = true;
|
|
}
|
|
vkCmdCopyBufferToImage(vk.cmd, staging, image, VK_IMAGE_LAYOUT_GENERAL, 1, ®ion);
|
|
}
|
|
submit(vk);
|
|
};
|
|
std::vector<float> floats(static_cast<size_t>(width) * height * 4);
|
|
size_t matchA = 0, matchB = 0;
|
|
const auto report = [&](const char* what, char expected, const char* source) {
|
|
const char seen = classify(floats.data(), width, height, &matchA, &matchB);
|
|
std::printf(" %-34s %-22s pattern %c (texels matching A: %zu, B: %zu) %s\n", what, source, seen, matchA, matchB,
|
|
seen == expected ? "ok" : "MISMATCH");
|
|
return seen == expected;
|
|
};
|
|
const auto halves_to_floats = [&](const uint16_t* texels) {
|
|
for (int y = 0; y < height; ++y)
|
|
{
|
|
const uint16_t* row = reinterpret_cast<const uint16_t*>(reinterpret_cast<const uint8_t*>(texels) + y * rowPitch);
|
|
for (int x = 0; x < width * 4; ++x)
|
|
floats[static_cast<size_t>(y) * width * 4 + x] = half_to_float(row[x]);
|
|
}
|
|
};
|
|
const auto vulkan_read = [&](const char* what, char expected) {
|
|
std::memset(stagingMap, 0, stagingBytes);
|
|
begin(vk);
|
|
if (useBuffer)
|
|
vkCmdCopyBuffer(vk.cmd, shared, staging, 1, &bufferRegion);
|
|
else
|
|
vkCmdCopyImageToBuffer(vk.cmd, image, VK_IMAGE_LAYOUT_GENERAL, staging, 1, ®ion);
|
|
submit(vk);
|
|
halves_to_floats(static_cast<const uint16_t*>(stagingMap));
|
|
return report(what, expected, "Vulkan copy");
|
|
};
|
|
|
|
for (int write = prewrites - 1; write >= 0; --write)
|
|
vulkan_upload(write & 1); // alternating, ending on A
|
|
std::printf("Vulkan uploaded %d time(s) before the import, ending on pattern A\n", prewrites);
|
|
|
|
// --- HIP: import, texture object, sampling kernel ---
|
|
if (!hipFirst)
|
|
HIP_CHECK(hipInit(0));
|
|
int fd = -1;
|
|
VkMemoryGetFdInfoKHR fdInfo = {VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR};
|
|
fdInfo.memory = sharedMemory;
|
|
fdInfo.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
|
|
const auto getMemoryFd = reinterpret_cast<PFN_vkGetMemoryFdKHR>(vkGetDeviceProcAddr(vk.device, "vkGetMemoryFdKHR"));
|
|
VK_CHECK(getMemoryFd(vk.device, &fdInfo, &fd));
|
|
hipExternalMemoryHandleDesc handle = {};
|
|
handle.type = hipExternalMemoryHandleTypeOpaqueFd;
|
|
handle.handle.fd = fd;
|
|
handle.size = requirements.size;
|
|
handle.flags = hipExternalMemoryDedicated;
|
|
hipExternalMemory_t external = nullptr;
|
|
HIP_CHECK(hipImportExternalMemory(&external, &handle));
|
|
close(fd);
|
|
hipExternalMemoryBufferDesc mapping = {};
|
|
mapping.size = requirements.size;
|
|
void* base = nullptr;
|
|
HIP_CHECK(hipExternalMemoryGetMappedBuffer(&base, external, &mapping));
|
|
uint8_t* texels = static_cast<uint8_t*>(base) + texelOffset;
|
|
std::printf("HIP imported the memory at %p\n", base);
|
|
|
|
hipResourceDesc resource = {};
|
|
resource.resType = hipResourceTypePitch2D;
|
|
resource.res.pitch2D.devPtr = texels;
|
|
resource.res.pitch2D.desc = hipCreateChannelDesc(16, 16, 16, 16, hipChannelFormatKindFloat);
|
|
resource.res.pitch2D.width = width;
|
|
resource.res.pitch2D.height = height;
|
|
resource.res.pitch2D.pitchInBytes = rowPitch;
|
|
hipTextureDesc sampler = {};
|
|
sampler.addressMode[0] = sampler.addressMode[1] = hipAddressModeClamp;
|
|
sampler.filterMode = hipFilterModePoint;
|
|
sampler.readMode = hipReadModeElementType;
|
|
sampler.normalizedCoords = 0;
|
|
hipTextureObject_t texture = nullptr;
|
|
HIP_CHECK(hipCreateTextureObject(&texture, &resource, &sampler, nullptr));
|
|
float* deviceOut = nullptr;
|
|
HIP_CHECK(hipMalloc(&deviceOut, floats.size() * sizeof(float)));
|
|
const auto hip_sample = [&](const char* what, char expected) {
|
|
HIP_CHECK(hipMemset(deviceOut, 0, floats.size() * sizeof(float)));
|
|
const dim3 block(16, 16), grid((width + 15) / 16, (height + 15) / 16);
|
|
hipLaunchKernelGGL(sample_texture, grid, block, 0, 0, texture, deviceOut, width, height);
|
|
HIP_CHECK(hipDeviceSynchronize());
|
|
HIP_CHECK(hipMemcpy(floats.data(), deviceOut, floats.size() * sizeof(float), hipMemcpyDeviceToHost));
|
|
return report(what, expected, "HIP texture sample");
|
|
};
|
|
std::vector<uint16_t> hostTexels(stagingBytes / 2);
|
|
const auto hip_memcpy = [&](const char* what, char expected) {
|
|
HIP_CHECK(hipMemcpy(hostTexels.data(), texels, stagingBytes, hipMemcpyDeviceToHost));
|
|
halves_to_floats(hostTexels.data());
|
|
return report(what, expected, "hipMemcpy to host");
|
|
};
|
|
|
|
bool ok = true;
|
|
std::printf("after import (Vulkan last wrote A):\n");
|
|
ok &= hip_sample("texture created after A", 'A');
|
|
ok &= hip_memcpy("", 'A');
|
|
|
|
vulkan_upload(1);
|
|
std::printf("Vulkan uploaded pattern B:\n");
|
|
ok &= vulkan_read("", 'B');
|
|
ok &= hip_memcpy("", 'B');
|
|
ok &= hip_sample("same texture object", 'B');
|
|
hipTextureObject_t second = nullptr;
|
|
HIP_CHECK(hipCreateTextureObject(&second, &resource, &sampler, nullptr));
|
|
std::swap(texture, second);
|
|
ok &= hip_sample("new texture object", 'B');
|
|
std::swap(texture, second);
|
|
|
|
// HIP rewrites the texels with their own bytes.
|
|
void* scratch = nullptr;
|
|
HIP_CHECK(hipMalloc(&scratch, stagingBytes));
|
|
HIP_CHECK(hipMemcpy(scratch, texels, stagingBytes, hipMemcpyDeviceToDevice));
|
|
HIP_CHECK(hipMemcpy(texels, scratch, stagingBytes, hipMemcpyDeviceToDevice));
|
|
HIP_CHECK(hipDeviceSynchronize());
|
|
std::printf("HIP copied the texels out and back:\n");
|
|
ok &= hip_sample("same texture object", 'B');
|
|
ok &= vulkan_read("", 'B');
|
|
|
|
vulkan_upload(0);
|
|
std::printf("Vulkan uploaded pattern A again:\n");
|
|
ok &= hip_memcpy("", 'A');
|
|
ok &= hip_sample("same texture object", 'A');
|
|
|
|
std::printf("%s\n", ok ? "RESULT: consistent - HIP texture sampling follows Vulkan's writes"
|
|
: "RESULT: INCONSISTENT - see MISMATCH lines");
|
|
return ok ? 0 : 3;
|
|
}
|