Method run_step

src/models/heartmula/mula.cpp:902–948

    }

    HeartMuLaBackboneResult run_step(const std::vector<float> & embedding) {
        allocate_workspace();
        const auto & config = runtime_->assets().mula_config.backbone;
        if (static_cast<int64_t>(embedding.size()) != batch_size_ * config.embed_dim) {
            throw std::runtime_error("HeartMuLa backbone cached step embedding payload size mismatch");
        }
        if (step_cache_.valid_steps() >= cache_steps_) {
            throw std::runtime_error("HeartMuLa backbone cached step exceeds cache capacity");
        }
        ggml_backend_tensor_set(input_, embedding.data(), 0, embedding.size() * sizeof(float));
        const int32_t position = static_cast<int32_t>(step_cache_.current_end());
        ggml_backend_tensor_set(positions_, &position, 0, sizeof(int32_t));
        const int64_t cache_slot = step_cache_.valid_steps();
        std::fill(
            attention_mask_buffer_.begin(),
            attention_mask_buffer_.end(),
            ggml_fp32_to_fp16(-std::numeric_limits<float>::infinity()));
        for (int64_t i = 0; i < step_cache_.valid_steps(); ++i) {
            attention_mask_buffer_[static_cast<size_t>(i)] = ggml_fp32_to_fp16(0.0F);
        }
        attention_mask_buffer_[static_cast<size_t>(cache_steps_)] = ggml_fp32_to_fp16(0.0F);
        ggml_backend_tensor_set(
            attention_mask_,
            attention_mask_buffer_.data(),
            0,
            attention_mask_buffer_.size() * sizeof(ggml_fp16_t));
        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 cached step graph compute failed");
        }
        const size_t dst_slot = static_cast<size_t>(cache_slot);
        for (size_t layer = 0; layer < key_sources_.size(); ++layer) {
            ggml_backend_tensor_copy(key_sources_[layer], key_destinations_[dst_slot][layer]);
            ggml_backend_tensor_copy(value_sources_[layer], value_destinations_[dst_slot][layer]);
        }
        HeartMuLaBackboneResult out;
        out.logits.vocab_size = runtime_->assets().mula_config.audio_vocab_size;
        out.logits.values.resize(static_cast<size_t>(batch_size_ * out.logits.vocab_size));
        ggml_backend_tensor_get(logits_output_, out.logits.values.data(), 0, out.logits.values.size() * sizeof(float));
        out.last_hidden.dims = config.embed_dim;
        out.last_hidden.values.resize(static_cast<size_t>(batch_size_ * config.embed_dim));
        ggml_backend_tensor_get(hidden_output_, out.last_hidden.values.data(), 0, out.last_hidden.values.size() * sizeof(float));
        step_cache_.advance_after_direct_append(1);
        return out;
    }

private:
    void build_transfer_views(int64_t step_elems) {