Method run

src/models/demucs/pipeline.cpp:1573–1611

    ~HTDemucsGraph() override = default;

    void run(
        const std::vector<float> & freq_input,
        const std::vector<float> & time_input,
        std::vector<float> & freq_output,
        std::vector<float> & time_output) {
        const size_t freq_elements = static_cast<size_t>(
            config_.input_freq_channels * config_.stft_freq_bins * config_.stft_frames);
        const size_t time_elements = static_cast<size_t>(
            config_.audio_channels * config_.segment_samples);
        if (freq_input.size() != freq_elements || time_input.size() != time_elements) {
            throw std::runtime_error("HTDemucs graph input size mismatch");
        }
        rebuild();
        const auto upload_start = std::chrono::steady_clock::now();
        ggml_backend_tensor_set(freq_input_, freq_input.data(), 0, freq_input.size() * sizeof(float));
        ggml_backend_tensor_set(time_input_, time_input.data(), 0, time_input.size() * sizeof(float));
        const auto upload_end = std::chrono::steady_clock::now();
        const auto compute_start = upload_end;
        core::set_backend_threads(backend_, threads_);
        const ggml_status status = engine::core::compute_backend_graph(backend_, graph_);
        ggml_backend_synchronize(backend_);
        const auto compute_end = std::chrono::steady_clock::now();
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("HTDemucs graph compute failed");
        }
        const auto readback_start = compute_end;
        if (freq_output.size() != static_cast<size_t>(
                config_.output_freq_channels * config_.stft_freq_bins * config_.stft_frames) ||
            time_output.size() != static_cast<size_t>(
                config_.output_time_channels * config_.segment_samples)) {
            throw std::runtime_error("HTDemucs graph output buffer size mismatch");
        }
        ggml_backend_tensor_get(freq_output_, freq_output.data(), 0, freq_output.size() * sizeof(float));
        ggml_backend_tensor_get(time_output_, time_output.data(), 0, time_output.size() * sizeof(float));
        const auto readback_end = std::chrono::steady_clock::now();
        last_timing_.upload_ms = debug::elapsed_ms(upload_start, upload_end);
        last_timing_.compute_ms = debug::elapsed_ms(compute_start, compute_end);
        last_timing_.readback_ms = debug::elapsed_ms(readback_start, readback_end);
    }

    const Timing & last_timing() const noexcept { return last_timing_; }