Method run

src/models/heartmula/mula.cpp:686–739

    }

    HeartMuLaBackbonePrefillOutput run(const std::vector<float> & embeddings) {
        allocate_workspace();
        const auto & config = runtime_->assets().mula_config.backbone;
        const int64_t head_dim = require_head_dim(config);
        if (static_cast<int64_t>(embeddings.size()) != batch_size_ * steps_ * config.embed_dim) {
            throw std::runtime_error("HeartMuLa backbone prefill embedding payload size mismatch");
        }
        ggml_backend_tensor_set(input_, embeddings.data(), 0, embeddings.size() * sizeof(float));
        core::set_backend_threads(runtime_->backend(), runtime_->threads());
        const ggml_status status = engine::core::compute_backend_graph(runtime_->backend(), graph_);
        ggml_backend_synchronize(runtime_->backend());
        if (status != GGML_STATUS_SUCCESS) {
            throw std::runtime_error("HeartMuLa backbone prefill graph compute failed");
        }
        HeartMuLaBackbonePrefillOutput out;
        out.result.logits.vocab_size = runtime_->assets().mula_config.audio_vocab_size;
        out.result.logits.values.resize(static_cast<size_t>(batch_size_ * out.result.logits.vocab_size));
        ggml_backend_tensor_get(
            logits_output_,
            out.result.logits.values.data(),
            0,
            out.result.logits.values.size() * sizeof(float));
        out.result.last_hidden.dims = config.embed_dim;
        out.result.last_hidden.values.resize(static_cast<size_t>(batch_size_ * config.embed_dim));
        ggml_backend_tensor_get(
            hidden_output_,
            out.result.last_hidden.values.data(),
            0,
            out.result.last_hidden.values.size() * sizeof(float));
        out.state.current_end = steps_;
        out.state.layers.resize(keys_.size());
        const size_t layer_values = static_cast<size_t>(steps_ * layer_step_elems_);
        for (size_t layer = 0; layer < keys_.size(); ++layer) {
            auto & state_layer = out.state.layers[layer];
            state_layer.valid_steps = steps_;
            std::vector<float> key_values(layer_values);
            std::vector<float> value_values(layer_values);
            ggml_backend_tensor_get(keys_[layer], key_values.data(), 0, key_values.size() * sizeof(float));
            ggml_backend_tensor_get(values_[layer], value_values.data(), 0, value_values.size() * sizeof(float));
            state_layer.key = flatten_prefill_cache_by_step(
                key_values,
                batch_size_,
                steps_,
                config.num_kv_heads,
                head_dim);
            state_layer.value = flatten_prefill_cache_by_step(
                value_values,
                batch_size_,
                steps_,
                config.num_kv_heads,
                head_dim);
        }
        return out;
    }

private:
    void allocate_workspace() {