compute.cpp

 
// UFO
#include <ufo/compute/compute.hpp>
 
// STL
#include <cassert>
#include <cstring>
#include <format>
#include <fstream>
#include <iostream>
#include <string>
#include <string_view>
 
namespace ufo::compute
{
WGPUInstance createInstance(WGPUInstanceDescriptor const* descriptor)
{
    WGPUInstance instance = wgpuCreateInstance(descriptor);
    assert(nullptr != instance);
    return instance;
}
 
WGPUAdapter createAdapter(WGPUInstance instance, WGPUSurface compatible_surface,
                          WGPUPowerPreference power_preference,
                          WGPUBackendType backend_type, WGPUBool force_fallback_adapter)
{
    assert(nullptr != instance);
 
    WGPUAdapter adapter       = nullptr;
    bool        request_ended = false;
 
    WGPURequestAdapterOptions options = WGPU_REQUEST_ADAPTER_OPTIONS_INIT;
    options.powerPreference           = power_preference;
    options.compatibleSurface         = compatible_surface;
    options.backendType               = backend_type;
    options.forceFallbackAdapter      = force_fallback_adapter;
 
    WGPURequestAdapterCallbackInfo callback_info = WGPU_REQUEST_ADAPTER_CALLBACK_INFO_INIT;
 
    callback_info.callback = [](WGPURequestAdapterStatus status, WGPUAdapter adapter,
                                WGPUStringView message, void* userdata1, void* userdata2) {
        if (WGPURequestAdapterStatus_Success == status) {
            *static_cast<WGPUAdapter*>(userdata1) = adapter;
        } else {
            std::cerr << "Could not get WebGPU adapter: " << message.data << std::endl;
        }
        *static_cast<bool*>(userdata2) = true;
    };
    callback_info.userdata1 = static_cast<void*>(&adapter);
    callback_info.userdata2 = static_cast<void*>(&request_ended);
 
    wgpuInstanceRequestAdapter(instance, &options, callback_info);
 
    // We wait until request_ended gets true
#ifdef __EMSCRIPTEN__
    while (!request_ended) {
        emscripten_sleep(100);
    }
#endif  // __EMSCRIPTEN__
 
    assert(request_ended);
    assert(nullptr != adapter);
 
    return adapter;
}
 
WGPUDevice createDevice(WGPUAdapter adapter, WGPULimits const* required_limits)
{
    assert(nullptr != adapter);
 
    WGPUDevice device        = nullptr;
    bool       request_ended = false;
 
    WGPUDeviceDescriptor desc = WGPU_DEVICE_DESCRIPTOR_INIT;
    // desc.label       = (window_name_ + " Device").c_str();
    // desc.requiredFeatureCount = 0;
    // desc.requiredFeatures     = nullptr;
 
    desc.requiredLimits = required_limits;
 
    // desc.defaultQueue.label       = (window_name_ + " Default Queue").c_str();
 
    // TODO: Fix
    // desc.deviceLostCallbackInfo.callback =
    //     [](WGPUDeviceImpl* const, WGPUDeviceLostReason reason, WGPUStringView message,
    //        void* /* userdata1 */, void* /* userdata2 */) {
    //      std::cout << "Device lost: reason " << reason;
    //      if (0 < message.length) {
    //          std::cout << " (" << message.data << ")";
    //      }
    //      std::cout << std::endl;
    //     };
 
    // desc.uncapturedErrorCallbackInfo.nextInChain = nullptr;
    // desc.uncapturedErrorCallbackInfo.userdata    = nullptr;
    // desc.uncapturedErrorCallbackInfo.callback    = nullptr;
 
    WGPURequestDeviceCallbackInfo callback_info = WGPU_REQUEST_DEVICE_CALLBACK_INFO_INIT;
 
    callback_info.callback = [](WGPURequestDeviceStatus status, WGPUDevice device,
                                WGPUStringView message, void* userdata1, void* userdata2) {
        if (WGPURequestDeviceStatus_Success == status) {
            *static_cast<WGPUDevice*>(userdata1) = device;
        } else {
            std::cout << "Could not get WebGPU device: " << message.data << std::endl;
        }
        *static_cast<bool*>(userdata2) = true;
    };
    callback_info.userdata1 = static_cast<void*>(&device);
    callback_info.userdata2 = static_cast<void*>(&request_ended);
 
    wgpuAdapterRequestDevice(adapter, &desc, callback_info);
 
    // We wait until request_ended gets true
#ifdef __EMSCRIPTEN__
    while (!request_ended) {
        emscripten_sleep(100);
    }
#endif  // __EMSCRIPTEN__
 
    assert(request_ended);
    assert(nullptr != device);
 
    return device;
}
 
WGPUQueue queue(WGPUDevice device)
{
    assert(nullptr != device);
    return wgpuDeviceGetQueue(device);
}
 
std::size_t bufferPaddedSize(std::size_t size)
{
    static constexpr std::size_t const COPY_BUFFER_ALIGNMENT = 4;
    static constexpr std::size_t const align_mask            = COPY_BUFFER_ALIGNMENT - 1;
    return std::max((size + align_mask) & ~align_mask, COPY_BUFFER_ALIGNMENT);
}
 
std::size_t bufferPaddedSize(std::size_t width, std::size_t bytes_per_pixel)
{
    static constexpr std::size_t const COPY_BYTES_PER_ROW_ALIGNMENT = 256;
 
    std::size_t const unpadded_bytes_per_row = width * bytes_per_pixel;
    std::size_t const padded_bytes_per_row_padding =
        (COPY_BYTES_PER_ROW_ALIGNMENT -
         unpadded_bytes_per_row % COPY_BYTES_PER_ROW_ALIGNMENT) %
        COPY_BYTES_PER_ROW_ALIGNMENT;
    return unpadded_bytes_per_row + padded_bytes_per_row_padding;
}
 
WGPUBuffer createBuffer(WGPUDevice device, std::string label, std::size_t size,
                        WGPUBufferUsage usage, bool mapped_at_creation)
{
    std::size_t padded_size = bufferPaddedSize(size);
 
    WGPUBufferDescriptor desc = WGPU_BUFFER_DESCRIPTOR_INIT;
    desc.label                = {label.c_str(), label.length()};
    desc.size                 = padded_size;
    desc.usage                = usage;
    desc.mappedAtCreation     = mapped_at_creation;
    return wgpuDeviceCreateBuffer(device, &desc);
}
 
WGPUBuffer createBufferInit(WGPUDevice device, std::string label, WGPUBufferUsage usage,
                            void* content, std::size_t content_size)
{
    if (0 == content_size) {
        return createBuffer(device, label, 0, usage, false);
    }
 
    WGPUBuffer buffer = createBuffer(device, label, content_size, usage, true);
 
    assert(nullptr != buffer);
 
    void* buf = wgpuBufferGetMappedRange(buffer, 0, content_size);
    std::memcpy(buf, content, content_size);
    wgpuBufferUnmap(buffer);
 
    return buffer;
}
 
WGPUSurfaceCapabilities surfaceCapabilities(WGPUSurface surface, WGPUAdapter adapter)
{
    WGPUSurfaceCapabilities surface_capabilities = WGPU_SURFACE_CAPABILITIES_INIT;
    wgpuSurfaceGetCapabilities(surface, adapter, &surface_capabilities);
    return surface_capabilities;
}
 
WGPUShaderModule loadShaderModule(WGPUDevice device, std::filesystem::path const& path)
{
    std::ifstream file(path);
    if (!file.is_open()) {
        return nullptr;
    }
 
    file.seekg(0, std::ios::end);
    std::size_t size = file.tellg();
    std::string shader_source(size, ' ');
    file.seekg(0);
    file.read(shader_source.data(), size);
 
    WGPUShaderSourceWGSL shader_wgsl = WGPU_SHADER_SOURCE_WGSL_INIT;
    shader_wgsl.chain.sType          = WGPUSType_ShaderSourceWGSL;
    // FIXME: Should this be `shader_source.length()`?
    shader_wgsl.code = {shader_source.c_str(), WGPU_STRLEN};
 
    WGPUShaderModuleDescriptor shader_desc = WGPU_SHADER_MODULE_DESCRIPTOR_INIT;
    // TODO: shader_code_desc.label
    shader_desc.nextInChain = reinterpret_cast<WGPUChainedStruct const*>(&shader_wgsl);
 
    return wgpuDeviceCreateShaderModule(device, &shader_desc);
}
 
// Release
 
void release(WGPUInstance instance) { wgpuInstanceRelease(instance); }
 
void release(WGPUSurface surface) { wgpuSurfaceRelease(surface); }
 
void release(WGPUAdapter adapter) { wgpuAdapterRelease(adapter); }
 
void release(WGPUDevice device) { wgpuDeviceRelease(device); }
 
void release(WGPUQueue queue) { wgpuQueueRelease(queue); }
 
void release(WGPUShaderModule shader_module) { wgpuShaderModuleRelease(shader_module); }
 
void release(WGPUBindGroupLayout bind_group_layout)
{
    wgpuBindGroupLayoutRelease(bind_group_layout);
}
 
void release(WGPUPipelineLayout pipeline_layout)
{
    wgpuPipelineLayoutRelease(pipeline_layout);
}
 
void release(WGPURenderPipeline render_pipeline)
{
    wgpuRenderPipelineRelease(render_pipeline);
}
 
void release(WGPUTexture texture) { wgpuTextureRelease(texture); }
 
void release(WGPUTextureView texture_view) { wgpuTextureViewRelease(texture_view); }
 
void release(WGPURenderPassEncoder render_pass_encoder)
{
    wgpuRenderPassEncoderRelease(render_pass_encoder);
}
 
void release(WGPUCommandEncoder command_encoder)
{
    wgpuCommandEncoderRelease(command_encoder);
}
 
void release(WGPUCommandBuffer command_buffer)
{
    wgpuCommandBufferRelease(command_buffer);
}
 
void release(WGPUSampler sampler) { wgpuSamplerRelease(sampler); }
 
GPUInfo gpuInfo(WGPUAdapter adapter)
{
    bool const adapter_was_passed = (nullptr != adapter);
 
    WGPUInstance instance = nullptr;
    if (!adapter_was_passed) {
        instance = createInstance();
        if (nullptr == instance) {
            return GPUInfo{};
        }
 
        adapter = createAdapter(instance);
        if (nullptr == adapter) {
            release(instance);
            return GPUInfo{};
        }
    }
 
    WGPUAdapterInfo info = {};
    wgpuAdapterGetInfo(adapter, &info);
 
    GPUInfo gpu_info = {};
    gpu_info.name    = std::string_view(info.device.data, info.device.length);
    gpu_info.architecture =
        std::string_view(info.architecture.data, info.architecture.length);
    gpu_info.description = std::string_view(info.description.data, info.description.length);
 
    gpu_info.vendor = [id = info.vendorID, v = info.vendor.data] {
        switch (id) {
            case 0x10DE: return "NVIDIA";
            case 0x1002: return "AMD";
            case 0x8086: return "Intel";
            case 0x13B5: return "ARM";
            case 0x5143: return "Qualcomm";
            case 0x106B: return "Apple";
            default: return v;
        }
    }();
 
    gpu_info.type = [t = info.adapterType] {
        switch (t) {
            case WGPUAdapterType_DiscreteGPU: return "Discrete GPU";
            case WGPUAdapterType_IntegratedGPU: return "Integrated GPU";
            case WGPUAdapterType_CPU: return "CPU";
            case WGPUAdapterType_Unknown: return "Unknown";
            default: return "Other";
        }
    }();
 
    gpu_info.backend = [b = info.backendType] {
        switch (b) {
            case WGPUBackendType_WebGPU: return "WebGPU";
            case WGPUBackendType_D3D11: return "D3D11";
            case WGPUBackendType_D3D12: return "D3D12";
            case WGPUBackendType_Metal: return "Metal";
            case WGPUBackendType_Vulkan: return "Vulkan";
            case WGPUBackendType_OpenGL: return "OpenGL";
            case WGPUBackendType_OpenGLES: return "OpenGLES";
            default: return "Unknown";
        }
    }();
 
    wgpuAdapterInfoFreeMembers(info);
    if (!adapter_was_passed) {
        release(adapter);
        release(instance);
    }
 
    return gpu_info;
}
 
std::vector<GPUInfo> gpusInfo()
{
    WGPUInstance instance = createInstance();
    if (nullptr == instance) {
        return {};
    }
 
    size_t count = wgpuInstanceEnumerateAdapters(instance, nullptr, nullptr);
    if (0 == count) {
        release(instance);
        return {};
    }
 
    std::vector<WGPUAdapter> adapters(count);
    wgpuInstanceEnumerateAdapters(instance, nullptr, adapters.data());
 
    std::vector<GPUInfo> res;
    res.reserve(count);
    for (auto adapter : adapters) {
        res.push_back(gpuInfo(adapter));
        release(adapter);
    }
 
    release(instance);
 
    return res;
}
}  // namespace ufo::compute