// Probe for zero-copy D3D12 <-> CUDA/HIP sharing under Proton.
//
// D3D12 shared NT handles are a dead end under Wine (no unix fd behind them;
// vkd3d-proton exports only textures), so this goes through vkd3d-proton's
// Vulkan interop instead:
//   - a VkBuffer in device-local memory, allocated on vkd3d-proton's own
//     VkDevice with VkExportMemoryAllocateInfo (winevulkan makes it a host
//     OPAQUE_FD export),
//   - imported into HIP by the d4r nvcuda bridge (d4rImportVulkanMemory),
//   - filled from / copied into a D3D12 texture by raw Vulkan copy commands
//     recorded inside a D3D12 command list (ID3D12DXVKInteropDevice1::
//     BeginVkCommandBufferInterop), which is where the NGX shim records its
//     staging copies today.
//
// usage: d3d12_hip_interop_probe.exe NVCUDA_BRIDGE_DLL REPORT_FILE [WIDTH HEIGHT]
// (Proton does not connect the console, so results go to REPORT_FILE.)
#define WIDL_EXPLICIT_AGGREGATE_RETURNS
#include <windows.h>
#include <d3d12.h>
#include <vulkan/vulkan_core.h>

#include <chrono>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <vector>

using CUresult = int;
using CUdeviceptr = unsigned long long;

// vkd3d-proton's interop interface (include/vkd3d_device_vkd3d_ext.idl).
MIDL_INTERFACE("39da4e09-bd1c-4198-9fae-86bbe3be41fd")
ID3D12DXVKInteropDevice : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetDXGIAdapter(REFIID iid, void** object) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetInstanceExtensions(UINT* count, const char** extensions) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetDeviceExtensions(UINT* count, const char** extensions) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetDeviceFeatures(const VkPhysicalDeviceFeatures2** features) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetVulkanHandles(VkInstance* instance, VkPhysicalDevice* physical, VkDevice* device) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetVulkanQueueInfo(ID3D12CommandQueue* queue, VkQueue* vk_queue, UINT32* family) = 0;
    virtual void STDMETHODCALLTYPE GetVulkanImageLayout(ID3D12Resource* resource, D3D12_RESOURCE_STATES state,
                                                        VkImageLayout* layout) = 0;
    virtual HRESULT STDMETHODCALLTYPE GetVulkanResourceInfo(ID3D12Resource* resource, UINT64* handle, UINT64* offset) = 0;
    virtual HRESULT STDMETHODCALLTYPE LockCommandQueue(ID3D12CommandQueue* queue) = 0;
    virtual HRESULT STDMETHODCALLTYPE UnlockCommandQueue(ID3D12CommandQueue* queue) = 0;
};

MIDL_INTERFACE("902d8115-59eb-4406-9518-fe00f991ee65")
ID3D12DXVKInteropDevice1 : public ID3D12DXVKInteropDevice
{
    virtual HRESULT STDMETHODCALLTYPE GetVulkanResourceInfo1(ID3D12Resource* resource, UINT64* handle, UINT64* offset,
                                                             VkFormat* format) = 0;
    virtual HRESULT STDMETHODCALLTYPE CreateInteropCommandQueue(const D3D12_COMMAND_QUEUE_DESC* desc, UINT32 family,
                                                                ID3D12CommandQueue** queue) = 0;
    virtual HRESULT STDMETHODCALLTYPE CreateInteropCommandAllocator(D3D12_COMMAND_LIST_TYPE type, UINT32 family,
                                                                    ID3D12CommandAllocator** allocator) = 0;
    virtual HRESULT STDMETHODCALLTYPE BeginVkCommandBufferInterop(ID3D12CommandList* list, VkCommandBuffer* buffer) = 0;
    virtual HRESULT STDMETHODCALLTYPE EndVkCommandBufferInterop(ID3D12CommandList* list) = 0;
};
__CRT_UUID_DECL(ID3D12DXVKInteropDevice1, 0x902d8115, 0x59eb, 0x4406, 0x95, 0x18, 0xfe, 0x00, 0xf9, 0x91, 0xee, 0x65)

static ID3D12Device* g_device;
static ID3D12CommandQueue* g_queue;
static ID3D12CommandAllocator* g_allocator;
static ID3D12GraphicsCommandList* g_list;
static ID3D12Fence* g_fence;
static HANDLE g_event;
static UINT64 g_fenceValue;

static bool check(HRESULT hr, const char* what)
{
    if (FAILED(hr))
        std::printf("%s failed: 0x%08lx\n", what, hr);
    return SUCCEEDED(hr);
}

static bool flush()
{
    if (!check(g_list->Close(), "Close"))
        return false;
    ID3D12CommandList* lists[] = {g_list};
    g_queue->ExecuteCommandLists(1, lists);
    g_queue->Signal(g_fence, ++g_fenceValue);
    g_fence->SetEventOnCompletion(g_fenceValue, g_event);
    WaitForSingleObject(g_event, INFINITE);
    return check(g_allocator->Reset(), "allocator Reset") && check(g_list->Reset(g_allocator, nullptr), "list Reset");
}

static double elapsed_ms(std::chrono::steady_clock::time_point start)
{
    return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start).count();
}

static ID3D12Resource* create_buffer(D3D12_HEAP_TYPE type, UINT64 size, D3D12_RESOURCE_STATES state)
{
    D3D12_HEAP_PROPERTIES heap = {};
    heap.Type = type;
    D3D12_RESOURCE_DESC desc = {};
    desc.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER;
    desc.Width = size;
    desc.Height = 1;
    desc.DepthOrArraySize = 1;
    desc.MipLevels = 1;
    desc.SampleDesc.Count = 1;
    desc.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR;
    ID3D12Resource* resource = nullptr;
    if (!check(g_device->CreateCommittedResource(&heap, D3D12_HEAP_FLAG_NONE, &desc, state, nullptr,
                                                 __uuidof(ID3D12Resource), reinterpret_cast<void**>(&resource)),
               "CreateCommittedResource(buffer)"))
        return nullptr;
    return resource;
}

static void transition(ID3D12Resource* resource, D3D12_RESOURCE_STATES before, D3D12_RESOURCE_STATES after)
{
    D3D12_RESOURCE_BARRIER barrier = {};
    barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
    barrier.Transition.pResource = resource;
    barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
    barrier.Transition.StateBefore = before;
    barrier.Transition.StateAfter = after;
    g_list->ResourceBarrier(1, &barrier);
}

static uint64_t pattern(uint64_t i)
{
    return (i * 0x9E3779B97F4A7C15ull) ^ (i >> 7);
}

int main(int argc, char** argv)
{
    if (argc < 3)
    {
        std::printf("usage: %s NVCUDA_BRIDGE_DLL REPORT_FILE [WIDTH HEIGHT]\n", argv[0]);
        return 2;
    }
    if (std::freopen(argv[2], "w", stdout) == nullptr)
        return 2;
    std::setvbuf(stdout, nullptr, _IONBF, 0);
    const UINT width = argc > 4 ? static_cast<UINT>(std::strtoul(argv[3], nullptr, 0)) : 2560;
    const UINT height = argc > 4 ? static_cast<UINT>(std::strtoul(argv[4], nullptr, 0)) : 1440;
    const UINT64 texel = 8; // R16G16B16A16_FLOAT, the DLSS output format
    const UINT64 pitch = width * texel;
    const UINT64 bytes = pitch * height;
    const UINT64 words = bytes / 8;
    if (pitch % D3D12_TEXTURE_DATA_PITCH_ALIGNMENT != 0)
    {
        std::printf("width must make a 256-byte aligned row pitch\n");
        return 2;
    }

    if (!check(D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_12_0, __uuidof(ID3D12Device),
                                 reinterpret_cast<void**>(&g_device)),
               "D3D12CreateDevice"))
        return 1;
    D3D12_COMMAND_QUEUE_DESC queueDesc = {};
    queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
    if (!check(g_device->CreateCommandQueue(&queueDesc, __uuidof(ID3D12CommandQueue), reinterpret_cast<void**>(&g_queue)),
               "CreateCommandQueue") ||
        !check(g_device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, __uuidof(ID3D12CommandAllocator),
                                                reinterpret_cast<void**>(&g_allocator)),
               "CreateCommandAllocator") ||
        !check(g_device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, g_allocator, nullptr,
                                           __uuidof(ID3D12GraphicsCommandList), reinterpret_cast<void**>(&g_list)),
               "CreateCommandList") ||
        !check(g_device->CreateFence(0, D3D12_FENCE_FLAG_NONE, __uuidof(ID3D12Fence), reinterpret_cast<void**>(&g_fence)),
               "CreateFence"))
        return 1;
    g_event = CreateEventA(nullptr, FALSE, FALSE, nullptr);

    ID3D12DXVKInteropDevice1* interop = nullptr;
    if (!check(g_device->QueryInterface(__uuidof(ID3D12DXVKInteropDevice1), reinterpret_cast<void**>(&interop)),
               "QueryInterface(ID3D12DXVKInteropDevice1)"))
        return 1;
    VkInstance vkInstance = VK_NULL_HANDLE;
    VkPhysicalDevice vkPhysical = VK_NULL_HANDLE;
    VkDevice vkDevice = VK_NULL_HANDLE;
    if (!check(interop->GetVulkanHandles(&vkInstance, &vkPhysical, &vkDevice), "GetVulkanHandles"))
        return 1;
    UINT extensionCount = 0;
    interop->GetDeviceExtensions(&extensionCount, nullptr);
    std::vector<const char*> extensions(extensionCount);
    interop->GetDeviceExtensions(&extensionCount, extensions.data());
    bool win32Memory = false;
    for (const char* name : extensions)
        win32Memory |= std::strcmp(name, "VK_KHR_external_memory_win32") == 0;
    std::printf("vkd3d-proton VkDevice %p, %u extensions, VK_KHR_external_memory_win32 %s\n",
                static_cast<void*>(vkDevice), extensionCount, win32Memory ? "enabled" : "MISSING");

    HMODULE vulkan = LoadLibraryA("vulkan-1.dll");
    auto getInstanceProc = vulkan != nullptr ? reinterpret_cast<PFN_vkGetInstanceProcAddr>(
                                                   reinterpret_cast<void*>(GetProcAddress(vulkan, "vkGetInstanceProcAddr")))
                                             : nullptr;
    if (getInstanceProc == nullptr)
    {
        std::printf("vulkan-1.dll unavailable\n");
        return 1;
    }
    auto getDeviceProc = reinterpret_cast<PFN_vkGetDeviceProcAddr>(getInstanceProc(vkInstance, "vkGetDeviceProcAddr"));
    auto getMemoryProperties = reinterpret_cast<PFN_vkGetPhysicalDeviceMemoryProperties>(
        getInstanceProc(vkInstance, "vkGetPhysicalDeviceMemoryProperties"));
#define DEVICE_PROC(name) auto name = reinterpret_cast<PFN_##name>(getDeviceProc(vkDevice, #name))
    DEVICE_PROC(vkCreateBuffer);
    DEVICE_PROC(vkGetBufferMemoryRequirements);
    DEVICE_PROC(vkAllocateMemory);
    DEVICE_PROC(vkBindBufferMemory);
    DEVICE_PROC(vkCmdPipelineBarrier);
    DEVICE_PROC(vkCmdCopyImageToBuffer);
    DEVICE_PROC(vkCmdCopyBufferToImage);
#undef DEVICE_PROC

    // Exportable device-local buffer on vkd3d-proton's device.
    VkExternalMemoryBufferCreateInfo externalBuffer = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO};
    externalBuffer.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
    VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, &externalBuffer};
    bufferInfo.size = bytes;
    bufferInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    VkBuffer vkBuffer = VK_NULL_HANDLE;
    VkResult vr = vkCreateBuffer(vkDevice, &bufferInfo, nullptr, &vkBuffer);
    VkMemoryRequirements requirements = {};
    vkGetBufferMemoryRequirements(vkDevice, vkBuffer, &requirements);
    VkPhysicalDeviceMemoryProperties memoryProperties = {};
    getMemoryProperties(vkPhysical, &memoryProperties);
    int memoryType = -1;
    for (int pass = 0; pass < 2 && memoryType < 0; ++pass)
        for (uint32_t i = 0; i < memoryProperties.memoryTypeCount && memoryType < 0; ++i)
        {
            const VkMemoryPropertyFlags flags = memoryProperties.memoryTypes[i].propertyFlags;
            if ((requirements.memoryTypeBits & (1u << i)) && (flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) &&
                (pass == 1 || !(flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT)))
                memoryType = static_cast<int>(i);
        }
    VkMemoryDedicatedAllocateInfo dedicated = {VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO};
    dedicated.buffer = vkBuffer;
    VkExportMemoryAllocateInfo exportInfo = {VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, &dedicated};
    exportInfo.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
    VkMemoryAllocateInfo allocateInfo = {VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, &exportInfo};
    allocateInfo.allocationSize = requirements.size;
    allocateInfo.memoryTypeIndex = static_cast<uint32_t>(memoryType);
    VkDeviceMemory vkMemory = VK_NULL_HANDLE;
    if (vr == VK_SUCCESS && memoryType >= 0)
        vr = vkAllocateMemory(vkDevice, &allocateInfo, nullptr, &vkMemory);
    if (vr == VK_SUCCESS)
        vr = vkBindBufferMemory(vkDevice, vkBuffer, vkMemory, 0);
    std::printf("exportable VkBuffer: %llu bytes (allocation %llu, memory type %d): VkResult %d\n",
                static_cast<unsigned long long>(bytes), static_cast<unsigned long long>(requirements.size), memoryType,
                vr);
    if (vr != VK_SUCCESS || memoryType < 0)
        return 1;

    HMODULE bridge = LoadLibraryA(argv[1]);
    if (bridge == nullptr)
    {
        std::printf("LoadLibrary(%s) failed: %lu\n", argv[1], GetLastError());
        return 1;
    }
    using ImportFn = CUresult(WINAPI*)(void*, uint64_t, uint64_t, CUdeviceptr*, void**);
    using DtoHFn = CUresult(WINAPI*)(void*, CUdeviceptr, size_t);
    using MemsetFn = CUresult(WINAPI*)(CUdeviceptr, unsigned int, size_t);
    using SyncFn = CUresult(WINAPI*)();
    using AllocFn = CUresult(WINAPI*)(CUdeviceptr*, size_t);
    using DtoDFn = CUresult(WINAPI*)(CUdeviceptr, CUdeviceptr, size_t);
    auto import = reinterpret_cast<ImportFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "d4rImportVulkanMemory")));
    auto dtoh = reinterpret_cast<DtoHFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "cuMemcpyDtoH")));
    auto memset32 = reinterpret_cast<MemsetFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "cuMemsetD32")));
    auto synchronize = reinterpret_cast<SyncFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "cuCtxSynchronize")));
    auto alloc = reinterpret_cast<AllocFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "cuMemAlloc")));
    auto dtod = reinterpret_cast<DtoDFn>(reinterpret_cast<void*>(GetProcAddress(bridge, "cuMemcpyDtoD")));
    if (import == nullptr || dtoh == nullptr || memset32 == nullptr || synchronize == nullptr || alloc == nullptr ||
        dtod == nullptr)
    {
        std::printf("bridge exports missing\n");
        return 1;
    }
    CUdeviceptr device = 0;
    void* external = nullptr;
    CUresult result = import(vkDevice, reinterpret_cast<uint64_t>(vkMemory), requirements.size, &device, &external);
    std::printf("d4rImportVulkanMemory -> %d, device 0x%llx\n", result, device);
    if (result != 0)
        return 1;

    // A game-like R16G16B16A16_FLOAT texture, filled through an upload buffer.
    D3D12_HEAP_PROPERTIES defaultHeap = {};
    defaultHeap.Type = D3D12_HEAP_TYPE_DEFAULT;
    D3D12_RESOURCE_DESC textureDesc = {};
    textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D;
    textureDesc.Width = width;
    textureDesc.Height = height;
    textureDesc.DepthOrArraySize = 1;
    textureDesc.MipLevels = 1;
    textureDesc.Format = DXGI_FORMAT_R16G16B16A16_FLOAT;
    textureDesc.SampleDesc.Count = 1;
    textureDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS;
    ID3D12Resource* texture = nullptr;
    ID3D12Resource* upload = create_buffer(D3D12_HEAP_TYPE_UPLOAD, bytes, D3D12_RESOURCE_STATE_GENERIC_READ);
    ID3D12Resource* readback = create_buffer(D3D12_HEAP_TYPE_READBACK, bytes, D3D12_RESOURCE_STATE_COPY_DEST);
    if (!check(g_device->CreateCommittedResource(&defaultHeap, D3D12_HEAP_FLAG_NONE, &textureDesc,
                                                 D3D12_RESOURCE_STATE_COPY_DEST, nullptr, __uuidof(ID3D12Resource),
                                                 reinterpret_cast<void**>(&texture)),
               "CreateCommittedResource(texture)") ||
        upload == nullptr || readback == nullptr)
        return 1;
    UINT64 vkImageHandle = 0, unusedOffset = 0;
    interop->GetVulkanResourceInfo(texture, &vkImageHandle, &unusedOffset);
    const VkImage vkImage = reinterpret_cast<VkImage>(vkImageHandle);

    uint64_t* mapped = nullptr;
    D3D12_RANGE none = {0, 0};
    if (!check(upload->Map(0, &none, reinterpret_cast<void**>(&mapped)), "Map upload"))
        return 1;
    for (UINT64 i = 0; i < words; ++i)
        mapped[i] = pattern(i) & 0x3BFF3BFF3BFF3BFFull; // finite halves: copies must not canonicalize NaNs
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT footprint = {};
    footprint.Footprint.Format = textureDesc.Format;
    footprint.Footprint.Width = width;
    footprint.Footprint.Height = height;
    footprint.Footprint.Depth = 1;
    footprint.Footprint.RowPitch = static_cast<UINT>(pitch);
    D3D12_TEXTURE_COPY_LOCATION textureLocation = {};
    textureLocation.pResource = texture;
    textureLocation.Type = D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX;
    D3D12_TEXTURE_COPY_LOCATION uploadLocation = {};
    uploadLocation.pResource = upload;
    uploadLocation.Type = D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT;
    uploadLocation.PlacedFootprint = footprint;
    D3D12_TEXTURE_COPY_LOCATION readbackLocation = uploadLocation;
    readbackLocation.pResource = readback;
    g_list->CopyTextureRegion(&textureLocation, 0, 0, 0, &uploadLocation, nullptr);
    transition(texture, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
    if (!flush())
        return 1;

    VkBufferImageCopy region = {};
    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.layerCount = 1;
    region.imageExtent = {width, height, 1};
    VkMemoryBarrier toTransfer = {VK_STRUCTURE_TYPE_MEMORY_BARRIER};
    toTransfer.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
    toTransfer.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT | VK_ACCESS_TRANSFER_WRITE_BIT;
    VkMemoryBarrier fromTransfer = {VK_STRUCTURE_TYPE_MEMORY_BARRIER};
    fromTransfer.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
    fromTransfer.dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT;

    // Texture -> exportable buffer, recorded inside the D3D12 command list.
    auto recordTextureToBuffer = [&]() {
        VkCommandBuffer cmd = VK_NULL_HANDLE;
        if (!check(interop->BeginVkCommandBufferInterop(g_list, &cmd), "BeginVkCommandBufferInterop"))
            return false;
        VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
        interop->GetVulkanImageLayout(texture, D3D12_RESOURCE_STATE_COPY_SOURCE, &layout);
        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &toTransfer,
                             0, nullptr, 0, nullptr);
        vkCmdCopyImageToBuffer(cmd, vkImage, layout, vkBuffer, 1, &region);
        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 1,
                             &fromTransfer, 0, nullptr, 0, nullptr);
        return check(interop->EndVkCommandBufferInterop(g_list), "EndVkCommandBufferInterop");
    };
    if (!recordTextureToBuffer() || !flush())
        return 1;
    std::vector<uint64_t> host(words);
    result = dtoh(host.data(), device, bytes);
    size_t mismatches = 0;
    for (UINT64 i = 0; i < words; ++i)
        mismatches += host[i] != (pattern(i) & 0x3BFF3BFF3BFF3BFFull);
    std::printf("D3D12 texture -> Vulkan buffer -> CUDA: result %d, %zu of %llu texels mismatched\n", result,
                mismatches, static_cast<unsigned long long>(words));

    // CUDA write -> buffer -> D3D12 texture (the DLSS output direction).
    result = memset32(device, 0x3C003800u, bytes / 4);
    if (result == 0)
        result = synchronize();
    transition(texture, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_COPY_DEST);
    auto recordBufferToTexture = [&]() {
        VkCommandBuffer cmd = VK_NULL_HANDLE;
        if (!check(interop->BeginVkCommandBufferInterop(g_list, &cmd), "BeginVkCommandBufferInterop"))
            return false;
        VkImageLayout layout = VK_IMAGE_LAYOUT_UNDEFINED;
        interop->GetVulkanImageLayout(texture, D3D12_RESOURCE_STATE_COPY_DEST, &layout);
        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 1, &toTransfer,
                             0, nullptr, 0, nullptr);
        vkCmdCopyBufferToImage(cmd, vkBuffer, vkImage, layout, 1, &region);
        vkCmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 1,
                             &fromTransfer, 0, nullptr, 0, nullptr);
        return check(interop->EndVkCommandBufferInterop(g_list), "EndVkCommandBufferInterop");
    };
    if (!recordBufferToTexture())
        return 1;
    transition(texture, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
    g_list->CopyTextureRegion(&readbackLocation, 0, 0, 0, &textureLocation, nullptr);
    if (!flush())
        return 1;
    uint64_t* back = nullptr;
    D3D12_RANGE all = {0, static_cast<SIZE_T>(bytes)};
    readback->Map(0, &all, reinterpret_cast<void**>(&back));
    size_t reverse = 0;
    for (UINT64 i = 0; i < words; ++i)
        reverse += back[i] != 0x3C0038003C003800ull;
    readback->Unmap(0, nullptr);
    std::printf("CUDA -> Vulkan buffer -> D3D12 texture: result %d, %zu of %llu texels mismatched\n", result, reverse,
                static_cast<unsigned long long>(words));

    // Timings: interop copies vs today's texture -> readback copy, and a CUDA
    // device copy out of the imported buffer.
    double toBuffer = 1e9, toTexture = 1e9, toReadback = 1e9, cudaCopy = 1e9;
    for (int i = 0; i < 10; ++i)
    {
        auto start = std::chrono::steady_clock::now();
        recordTextureToBuffer();
        flush();
        toBuffer = std::min(toBuffer, elapsed_ms(start));

        transition(texture, D3D12_RESOURCE_STATE_COPY_SOURCE, D3D12_RESOURCE_STATE_COPY_DEST);
        flush();
        start = std::chrono::steady_clock::now();
        recordBufferToTexture();
        flush();
        toTexture = std::min(toTexture, elapsed_ms(start));
        transition(texture, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_COPY_SOURCE);
        flush();

        start = std::chrono::steady_clock::now();
        g_list->CopyTextureRegion(&readbackLocation, 0, 0, 0, &textureLocation, nullptr);
        flush();
        toReadback = std::min(toReadback, elapsed_ms(start));
    }
    CUdeviceptr local = 0;
    if (alloc(&local, bytes) == 0)
        for (int i = 0; i < 10; ++i)
        {
            synchronize();
            const auto start = std::chrono::steady_clock::now();
            dtod(local, device, bytes);
            synchronize();
            cudaCopy = std::min(cudaCopy, elapsed_ms(start));
        }
    std::printf("%ux%u RGBA16F (%.1f MB), best of 10 incl. submit+wait:\n", width, height, bytes / 1048576.0);
    std::printf("  interop texture -> VRAM buffer:  %.3f ms\n", toBuffer);
    std::printf("  interop VRAM buffer -> texture:  %.3f ms\n", toTexture);
    std::printf("  D3D12 texture -> readback (today): %.3f ms\n", toReadback);
    std::printf("  CUDA device copy from imported:  %.3f ms\n", cudaCopy);
    const bool ok = mismatches == 0 && reverse == 0;
    std::printf("zero-copy interop probe: %s\n", ok ? "PASS" : "FAIL");
    return ok ? 0 : 1;
}