Class FixedShapeGraph

src/models/roformer/runtime.cpp:450–524

public:
    FixedShapeGraph(ggml_backend_t backend, int compute_threads)
        : backend_(backend),
          compute_threads_(compute_threads) {
    }

    virtual ~FixedShapeGraph() {
        if (graph_ != nullptr) {
            engine::core::release_backend_graph_resources(backend_, graph_);
        }
        if (gallocr_ != nullptr) {
            ggml_gallocr_free(gallocr_);
        }
    }

    const std::vector<float> & run(const std::vector<float> & input_values) {
        if (static_cast<int64_t>(input_values.size()) != input_shape_.num_elements()) {
            throw std::runtime_error("roformer graph input size mismatch");
        }
        const auto upload_start = Clock::now();
        ggml_backend_tensor_set(input_, input_values.data(), 0, input_values.size() * sizeof(float));
        engine::debug::timing_log_scalar("mel_band_roformer.graph.input_upload_ms", engine::debug::elapsed_ms(upload_start));
        core::set_backend_threads(backend_, compute_threads_);
        const auto compute_start = Clock::now();
        const ggml_status status = engine::core::compute_backend_graph(backend_, graph_);
        ggml_backend_synchronize(backend_);
        engine::debug::timing_log_scalar("mel_band_roformer.graph.compute_ms", engine::debug::elapsed_ms(compute_start));
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("roformer graph compute failed");
        }
        const auto read_start = Clock::now();
        output_host_.resize(static_cast<size_t>(output_shape_.num_elements()));
        ggml_backend_tensor_get(output_, output_host_.data(), 0, output_host_.size() * sizeof(float));
        engine::debug::timing_log_scalar("mel_band_roformer.graph.output_read_ms", engine::debug::elapsed_ms(read_start));
        return output_host_;
    }

protected:
    void init_context(size_t arena_bytes) {
        ggml_init_params params{arena_bytes, nullptr, true};
        ctx_.reset(ggml_init(params));
        if (ctx_ == nullptr) {
            throw std::runtime_error("failed to initialize roformer ggml context");
        }
    }

    core::ModuleBuildContext make_build_context(core::ExecutionContext & execution_context, const char * name) {
        return core::ModuleBuildContext{
            ctx_.get(),
            name,
            execution_context.backend_type(),
        };
    }

    void finalize_graph(size_t max_nodes) {
        graph_ = ggml_new_graph_custom(ctx_.get(), max_nodes, false);
        ggml_build_forward_expand(graph_, output_);
        gallocr_ = ggml_gallocr_new(ggml_backend_get_default_buffer_type(backend_));
        if (gallocr_ == nullptr || !ggml_gallocr_alloc_graph(gallocr_, graph_)) {
            throw std::runtime_error("failed to allocate roformer graph buffer");