Method run

src/models/ace_step/planner.cpp:1831–1875

        return runtime_.get() == &runtime && prompt_steps_ == prompt_steps;
    }

    PrefillOutput run(const std::vector<int32_t> & token_ids, const std::vector<int32_t> & attention_mask) {
        const auto & config = runtime_->assets().config.planner;
        if (static_cast<int64_t>(token_ids.size()) != prompt_steps_ ||
            static_cast<int64_t>(attention_mask.size()) != prompt_steps_) {
            throw std::runtime_error("ACE-Step planner prefill token or attention-mask count mismatch");
        }
        ggml_backend_tensor_set(token_ids_, token_ids.data(), 0, token_ids.size() * sizeof(int32_t));
        std::vector<int32_t> position_ids(static_cast<size_t>(prompt_steps_), 0);
        for (int64_t i = 0; i < prompt_steps_; ++i) {
            position_ids[static_cast<size_t>(i)] = static_cast<int32_t>(i);
        }
        ggml_backend_tensor_set(positions_, position_ids.data(), 0, position_ids.size() * sizeof(int32_t));
        const auto attention_mask_values = build_prefill_attention_mask_values(attention_mask);
        ggml_backend_tensor_set(
            attention_mask_,
            attention_mask_values.data(),
            0,
            attention_mask_values.size() * sizeof(ggml_fp16_t));
        std::vector<float> query_mask_values(static_cast<size_t>(prompt_steps_), 0.0F);
        for (int64_t i = 0; i < prompt_steps_; ++i) {
            query_mask_values[static_cast<size_t>(i)] = attention_mask[static_cast<size_t>(i)] != 0 ? 1.0F : 0.0F;
        }
        ggml_backend_tensor_set(query_mask_, query_mask_values.data(), 0, query_mask_values.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("ACE-Step planner prefill graph compute failed");
        }
        PrefillOutput out;
        out.logits.resize(static_cast<size_t>(config.vocab_size));
        ggml_backend_tensor_get(logits_, out.logits.data(), 0, out.logits.size() * sizeof(float));
        out.kv_state.current_end = prompt_steps_;
        out.kv_state.layers.resize(keys_.size());
        const size_t layer_values = static_cast<size_t>(prompt_steps_ * config.num_key_value_heads * config.head_dim);
        for (size_t layer = 0; layer < keys_.size(); ++layer) {
            auto & state = out.kv_state.layers[layer];
            state.valid_steps = prompt_steps_;
            state.key.resize(layer_values);
            state.value.resize(layer_values);
            ggml_backend_tensor_get(keys_[layer], state.key.data(), 0, state.key.size() * sizeof(float));
            ggml_backend_tensor_get(values_[layer], state.value.data(), 0, state.value.size() * sizeof(float));
        }
        return out;
    }

private: