GPU Class Reference

Collaboration diagram for GPU:

Public Member Functions
const wgpu::Device &	get_device ()
const wgpu::Instance &	get_instance ()
const wgpu::Queue &	get_queue ()
bool	is_initialized ()
	GPU (const GPU &)=delete
GPU &	operator= (const GPU &)=delete
	GPU (GPU &&)=delete
GPU &	operator= (GPU &&)=delete
std::string	readWGSLFile (std::string_view shader_id)
wgpu::ComputePipeline	createPipeline (const std::string &filename, const std::string &label)
void	init_gpu ()

Static Public Member Functions
static GPU &	getClassInstance ()
static uint32_t	getAlignedBytesPerRow (uint32_t width, uint32_t bytesPerPixel=4)
static void	printShaderError (wgpu::ShaderModule shaderModule)

Private Member Functions
bool	validate_device ()

Private Attributes
wgpu::Instance	instance
wgpu::Adapter	adapter
wgpu::Device	device
wgpu::Queue	queue
bool	adapter_ready = false
bool	device_ready = false
bool	gpu_initialized = false

Detailed Description

Definition at line 21 of file gpu.h.

Constructor & Destructor Documentation

~GPU()

GPU::~GPU ( )

inline

Definition at line 273 of file gpu.h.

           {
        device = nullptr;
        adapter = nullptr;
        queue = nullptr;
        instance = nullptr;
        gpu_initialized = false;
    };

Member Function Documentation

createPipeline()

wgpu::ComputePipeline GPU::createPipeline ( const std::string &  filename, const std::string &  label  )

inline

Definition at line 89 of file gpu.h.

                                                                                          {
        wgpu::ShaderSourceWGSL wgsl;
        std::string shaderCode = readWGSLFile(filename);
        wgsl.code = shaderCode.c_str();
        wgpu::ShaderModuleDescriptor md = {};
        md.nextInChain = &wgsl;
        md.label = label.c_str();
        wgpu::ShaderModule sm = device.CreateShaderModule(&md);
 
        wgpu::ComputePipelineDescriptor cpd = {};
        cpd.compute.module = sm;
        cpd.compute.entryPoint = "main";
        return device.CreateComputePipeline(&cpd);
    };

get_device()

const wgpu::Device & GPU::get_device ( )

inline

Definition at line 54 of file gpu.h.

                                   {
        return device;
    }

get_instance()

const wgpu::Instance & GPU::get_instance ( )

inline

Definition at line 58 of file gpu.h.

                                       {
        return instance;
    }

get_queue()

const wgpu::Queue & GPU::get_queue ( )

inline

Definition at line 62 of file gpu.h.

                                 {
        return queue;
    }

getAlignedBytesPerRow()

static uint32_t GPU::getAlignedBytesPerRow ( uint32_t  width, uint32_t  bytesPerPixel = 4  )

inlinestatic

Definition at line 104 of file gpu.h.

                                                                                      {
        uint32_t unaligned = width * bytesPerPixel;
        uint32_t align = 256;
        return (unaligned + align - 1) & ~(align - 1);
    };

getClassInstance()

static GPU & GPU::getClassInstance ( )

inlinestatic

Definition at line 49 of file gpu.h.

                                   {
        static GPU gpuInstance;
        return gpuInstance;
    }

init_gpu()

void GPU::init_gpu ( )

inline

Definition at line 134 of file gpu.h.

                    {
        if (gpu_initialized)
            return;
 
        wgpu::InstanceDescriptor instanceDesc = {};
        instance = wgpu::CreateInstance(&instanceDesc);
 
        if (!instance) {
            IMG2NUM_LOG_INFO("Fatal: WebGPU instance creation failed.");
            return;
        }
 
        // ---------------------------------------------------------
        // 1. Get Adapter
        // ---------------------------------------------------------
        IMG2NUM_LOG_INFO("Requesting Adapter...");
        adapter_ready = false;
 
        instance.RequestAdapter(
            nullptr,
            wgpu::CallbackMode::AllowProcessEvents, // <--- ALLOW EVENTS
            [this](wgpu::RequestAdapterStatus status, wgpu::Adapter a, wgpu::StringView msg) {
                if (status == wgpu::RequestAdapterStatus::Success) {
                    adapter = std::move(a);
                    IMG2NUM_LOG_INFO("Adapter Acquired");
                } else {
                    IMG2NUM_LOG_INFO(
                        "Adapter Failed: {}", std::string_view(msg.data ? msg.data : "", msg.length)
                    );
                }
                adapter_ready = true; // Unblock the loop
            }
        );
 
        // WAIT LOOP: Yield to browser so it can actually find the adapter
        while (!adapter_ready) {
            instance.ProcessEvents();
#if defined(__EMSCRIPTEN__)
            emscripten_sleep(10); // Sleep 10ms
#endif
        }
 
        if (!adapter) {
            IMG2NUM_LOG_INFO("Fatal: Could not get WebGPU Adapter.");
            return;
        }
 
        // ---------------------------------------------------------
        // 2. Get Device
        // ---------------------------------------------------------
        IMG2NUM_LOG_INFO("Requesting Device...");
        device_ready = false;
 
        wgpu::DeviceDescriptor deviceDesc = {};
        deviceDesc.SetUncapturedErrorCallback([](const wgpu::Device&, wgpu::ErrorType type,
                                                 wgpu::StringView msg) {
            // 1. Safely extract the string using the provided length
            std::string err_str = (msg.data && msg.length > 0) ? std::string(msg.data, msg.length)
                                                               : "Unknown Error (Null message)";
 
            // 2. Print it safely
            IMG2NUM_LOG_INFO(
                "\n[WEBGPU FATAL ERROR] Type: {} | Msg: {}\n", static_cast<uint32_t>(type), err_str
            );
        });
        deviceDesc.SetDeviceLostCallback(
            wgpu::CallbackMode::AllowProcessEvents,
            [](const wgpu::Device&, wgpu::DeviceLostReason reason, wgpu::StringView msg) {
                std::string err_msg = (msg.data && msg.length > 0)
                                          ? std::string(msg.data, msg.length)
                                          : "Unknown device lost reason";
                // 1. Ignore teardown cancellations so we don't log during static destruction
                if (reason == wgpu::DeviceLostReason::CallbackCancelled) {
                    return;
                }
                IMG2NUM_LOG_INFO(
                    "[DEVICE LOST] Reason: {} Msg: {}", static_cast<int>(reason), err_msg
                );
            }
        );
 
        // Set maximum possible device hardware memory
        wgpu::Limits supportedLimits;
        wgpu::Limits requiredLimits;
        if (adapter.GetLimits(&supportedLimits)) {
            // nominally the device Buffer limit is 256MB
 
            // Copy the adapter's physical limits over to your requested limits
            requiredLimits = supportedLimits;
 
            IMG2NUM_LOG_INFO("maxBufferSize: {}", requiredLimits.maxBufferSize);
            IMG2NUM_LOG_INFO(
                "maxStorageBufferBindingSize: {}", requiredLimits.maxStorageBufferBindingSize
            );
 
            deviceDesc.requiredLimits = &requiredLimits;
        }
 
        adapter.RequestDevice(
            &deviceDesc,
            wgpu::CallbackMode::AllowProcessEvents, // <--- ALLOW EVENTS
            [this](wgpu::RequestDeviceStatus status, wgpu::Device d, wgpu::StringView msg) {
                if (status == wgpu::RequestDeviceStatus::Success) {
                    device = std::move(d);
                    IMG2NUM_LOG_INFO("Device Acquired");
                } else {
                    IMG2NUM_LOG_INFO(
                        "Device Failed: {}", msg.data && msg.length > 0
                                                 ? std::string(msg.data, msg.length)
                                                 : "Unknown error"
                    );
                }
                device_ready = true; // Unblock the loop
            }
        );
 
        // WAIT LOOP
        while (!device_ready) {
            instance.ProcessEvents();
#if defined(__EMSCRIPTEN__)
            emscripten_sleep(10);
#endif
        }
 
        if (!device) {
            IMG2NUM_LOG_INFO("Fatal: Could not get WebGPU Device.");
            return;
        }
 
        if (!validate_device()) {
            IMG2NUM_LOG_INFO("Fatal: Could not get WebGPU Device.");
            return;
        }
 
        queue = device.GetQueue();
        gpu_initialized = true;
        IMG2NUM_LOG_INFO("GPU Fully Initialized.");
    };

is_initialized()

bool GPU::is_initialized ( )

inline

Definition at line 66 of file gpu.h.

                          {
        return gpu_initialized;
    }

printShaderError()

static void GPU::printShaderError ( wgpu::ShaderModule  shaderModule )

inlinestatic

Definition at line 110 of file gpu.h.

                                                                {
        shaderModule.GetCompilationInfo(
            // Callback Mode (New API Requirement)
            wgpu::CallbackMode::AllowProcessEvents,
            // Callback Lambda
            [](wgpu::CompilationInfoRequestStatus status, const wgpu::CompilationInfo* info) {
                if (status != wgpu::CompilationInfoRequestStatus::Success || !info)
                    return;
 
                for (uint32_t i = 0; i < info->messageCount; ++i) {
                    const auto& msg = info->messages[i];
                    IMG2NUM_LOG_INFO(
                        "Shader Error [{}] Line {}:{} - {}",
                        msg.type == wgpu::CompilationMessageType::Error ? "ERR" : "WARN",
                        msg.lineNum, msg.linePos,
                        std::string_view(
                            msg.message.data ? msg.message.data : "", msg.message.length
                        )
                    );
                }
            }
        );
    };

readWGSLFile()

std::string GPU::readWGSLFile ( std::string_view  shader_id )

inline

Definition at line 76 of file gpu.h.

                                                     {
        // A simple linear search over 9 items is blazingly fast in C++
        for (const auto& entry : embedded_shaders::shaders) {
            if (entry.id == shader_id) {
                // Safely convert the string_view back to a std::string for Dawn
                return std::string(entry.source);
            }
        }
 
        // Always good to handle the "not found" case gracefully!
        return "";
    }

validate_device()

bool GPU::validate_device ( )

inlineprivate

Definition at line 34 of file gpu.h.

                           {
        if (!device)
            return false;
 
        // Try creating a trivial buffer to ensure the device is usable
        wgpu::BufferDescriptor desc = {};
        desc.size = 4;
        desc.usage = wgpu::BufferUsage::CopyDst;
 
        wgpu::Buffer test = device.CreateBuffer(&desc);
        return test != nullptr;
    }

Member Data Documentation

adapter

wgpu::Adapter GPU::adapter

private

Definition at line 24 of file gpu.h.

adapter_ready

bool GPU::adapter_ready = false

private

Definition at line 28 of file gpu.h.

device

wgpu::Device GPU::device

private

Definition at line 25 of file gpu.h.

device_ready

bool GPU::device_ready = false

private

Definition at line 29 of file gpu.h.

gpu_initialized

bool GPU::gpu_initialized = false

private

Definition at line 30 of file gpu.h.

instance

wgpu::Instance GPU::instance

private

Definition at line 23 of file gpu.h.

queue

wgpu::Queue GPU::queue

private

Definition at line 26 of file gpu.h.

---

The documentation for this class was generated from the following file:

• include/internal/gpu.h