gpu_host_select.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/format/editor_idle_pump.hpp>
#include <pulp/format/view_bridge.hpp>
#include <pulp/runtime/log.hpp>
#include <pulp/view/plugin_view_host.hpp>
 
#include <cstdlib>
#include <cstring>
 
// Shared GPU PluginViewHost auto-selection for every plugin format adapter
// (AU v2 / VST3 / CLAP / iOS AUv3). The renderer, JS runtime, Yoga layout,
// and surface management are identical across formats — only the per-format
// shell/lifecycle glue differs — so the *decision* of whether to request the
// GPU host belongs in one place.
//
// A developer building a Skia/Dawn/scripted editor gets the GPU host
// automatically; they never hand-set a flag. Hardcoding `use_gpu=false` is
// exactly the trap that made the ChainerSynth AU fall back to AutoUi/CPU.
 
namespace pulp::format {

inline bool plugin_gpu_disabled_by_env() {
    const char* v = std::getenv("PULP_DISABLE_PLUGIN_GPU");
    return v != nullptr && v[0] != '\0' && std::strcmp(v, "0") != 0;
}
 
struct GpuHostDecision {
    bool use_gpu = false;          
    const char* mode = "autoui";   
    bool wants_gpu = false;        
    bool create_view_null = false; 
};

inline GpuHostDecision decide_gpu_host(const ViewBridge& bridge) {
    GpuHostDecision d;
    const view::View* v = bridge.view();
    d.create_view_null = (v == nullptr);
 
    const bool scripted = bridge.uses_script_ui();
    const bool view_wants = (v != nullptr) && v->requires_gpu_host();
    d.wants_gpu = scripted || view_wants;
 
    if (scripted) {
        d.mode = "scripted";
    } else if (view_wants) {
        d.mode = "custom";
    } else {
        d.mode = "autoui";
    }
 
    const bool env_off = plugin_gpu_disabled_by_env();
    d.use_gpu = d.wants_gpu && !env_off;
 
    // Build-type flag (#perf): a Debug / unoptimized build makes the editor
    // (and DSP) feel sluggish in a DAW regardless of the GPU/JS path — the most
    // common "why is this slow?" cause. Surface it in the same log line so it's
    // obvious in Console/log stream which build a host loaded, and warn loudly
    // once on Debug. `pulp build` defaults to Release; raw cmake without
    // -DCMAKE_BUILD_TYPE does not, so this catches both.
#ifdef NDEBUG
    constexpr const char* kBuildType = "release";
#else
    constexpr const char* kBuildType = "debug";
#endif
    runtime::log_info(
        "[plugin-gpu-host] adapter mode={} use_gpu={} wants_gpu={} "
        "env_disabled={} scripted={} requires_gpu_host={} create_view_null={} build={}",
        d.mode, d.use_gpu, d.wants_gpu, env_off, scripted, view_wants,
        d.create_view_null, kBuildType);
#ifndef NDEBUG
    static bool warned_debug = false;
    if (!warned_debug) {
        warned_debug = true;
        runtime::log_warn(
            "[plugin-gpu-host] DEBUG build — the plugin UI/DSP will be noticeably "
            "slower than a Release build. Build Release (the `pulp build` default; "
            "with raw cmake pass -DCMAKE_BUILD_TYPE=Release) before judging perf.");
    }
#endif
 
    return d;
}

inline view::PluginViewHost::Options editor_host_options(
    const ViewBridge& bridge, const GpuHostDecision& gpu,
    view::PluginViewHost::Size size) {
    view::PluginViewHost::Options opts;
    opts.size = size;
    opts.use_gpu = gpu.use_gpu;
    opts.background_rgb = bridge.editor_background_rgb();
    return opts;
}

inline void warn_if_unexpected_cpu_fallback(const GpuHostDecision& d,
                                            const view::PluginViewHost* host) {
#ifdef PULP_HAS_SKIA
    if (!d.use_gpu || host == nullptr) return;
    if (host->gpu_surface_state() != view::PluginViewHost::GpuSurfaceState::unavailable)
        return;
    runtime::log_error(
        "[plugin-gpu-host] gpu-init-failed falling_back=cpu mode={} "
        "use_gpu=true host=cpu — a GPU/scripted editor view silently "
        "fell back to CPU rendering. Check Dawn/Metal availability in the "
        "host process (or set PULP_DISABLE_PLUGIN_GPU=1 intentionally).",
        d.mode);
#else
    (void) d;
    (void) host;
#endif
}

[[nodiscard]] inline view::PluginViewHost::GpuSurfaceSubscription
bind_gpu_surface(view::PluginViewHost& host, view::ScriptedEditorSession* session,
                 const GpuHostDecision& decision, const char* format_tag) {
    using State = view::PluginViewHost::GpuSurfaceState;
    const bool expected_gpu = decision.use_gpu;
    const char* mode = decision.mode;
    return host.observe_gpu_surface(
        [session, expected_gpu, mode,
         format_tag](const view::PluginViewHost::GpuSurfaceStatus& status) {
            // Route navigator.gpu / canvas.getContext('webgpu') through the
            // host's live GpuSurface — and, just as importantly, DETACH on the
            // way down so the session never holds a dangling surface.
            if (session) session->attach_gpu_surface(status.surface);
 
            switch (status.state) {
                case State::ready:
                    runtime::log_info(
                        "[plugin-gpu-host] GpuSurface attached to WidgetBridge "
                        "via ScriptedUiSession ({})",
                        format_tag);
                    break;
                case State::unavailable:
                    if (expected_gpu) {
                        runtime::log_error(
                            "[plugin-gpu-host] gpu-init-failed falling_back=cpu "
                            "mode={} use_gpu=true host=cpu ({}) — a "
                            "GPU/scripted editor view has no GPU surface. Check "
                            "Dawn availability in the host process (or set "
                            "PULP_DISABLE_PLUGIN_GPU=1 intentionally).",
                            mode, format_tag);
                    }
                    break;
                case State::pending:
                    // Not yet created. Nothing to say and nothing to warn
                    // about — this is the normal Windows pre-attach state.
                    break;
            }
        });
}
 
} // namespace pulp::format