Method run_step

src/models/heartmula/mula.cpp:1313–1361

    }

    HeartMuLaDecoderResult run_step(const std::vector<float> & embedding, int64_t codebook_index) {
        allocate_workspace();
        const auto & full_config = runtime_->assets().mula_config;
        const auto & config = full_config.decoder;
        if (static_cast<int64_t>(embedding.size()) != batch_size_ * full_config.backbone.embed_dim) {
            throw std::runtime_error("HeartMuLa decoder cached step embedding payload size mismatch");
        }
        if (codebook_index < 0 || codebook_index >= full_config.audio_num_codebooks - 1) {
            throw std::runtime_error("HeartMuLa decoder cached step codebook index is out of range");
        }
        if (step_cache_.valid_steps() >= cache_steps_) {
            throw std::runtime_error("HeartMuLa decoder 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 int32_t cache_slot = static_cast<int32_t>(step_cache_.valid_steps());
        ggml_backend_tensor_set(cache_slot_, &cache_slot, 0, sizeof(int32_t));
        const int32_t codebook = static_cast<int32_t>(codebook_index);
        ggml_backend_tensor_set(codebook_index_, &codebook, 0, sizeof(int32_t));
        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_slot)] = 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 decoder cached step graph compute failed");
        }
        HeartMuLaDecoderResult out;
        out.logits.vocab_size = full_config.audio_vocab_size;
        out.logits.values.resize(static_cast<size_t>(batch_size_ * full_config.audio_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 allocate_workspace() {