[FFI] Namespace cleanup (#3329)

MasterJH5574 · web-flow · commit c51f083bdc0f · 2025-09-08T10:45:25.000-04:00
Following apache/tvm#18280, this PR updates the ffi namespace in MLC.
diff --git a/3rdparty/tvm b/3rdparty/tvm
@@ -1 +1 @@
-Subproject commit 729421ae03d1010758d7682336fc5dc1a897a5cf
+Subproject commit 53ed43ac9343613fb11edea0dd9f066f96a84458
diff --git a/cpp/json_ffi/json_ffi_engine.cc b/cpp/json_ffi/json_ffi_engine.cc
@@ -98,7 +98,7 @@ bool JSONFFIEngine::AddRequest(std::string request_json_str, std::string request
   }
   // create a generation config from request
   const auto& default_gen_cfg = default_generation_config_;
-  auto gen_cfg = make_object<GenerationConfigNode>();
+  auto gen_cfg = tvm::ffi::make_object<GenerationConfigNode>();
   gen_cfg->n = request.n;
   gen_cfg->temperature = request.temperature.value_or(default_gen_cfg->temperature);
   gen_cfg->top_p = request.top_p.value_or(default_gen_cfg->top_p);
@@ -299,7 +299,7 @@ class JSONFFIEngineImpl : public JSONFFIEngine, public ffi::ModuleObj {
 TVM_FFI_STATIC_INIT_BLOCK({
   namespace refl = tvm::ffi::reflection;
   refl::GlobalDef().def("mlc.json_ffi.CreateJSONFFIEngine",
-                        []() { return ffi::Module(make_object<JSONFFIEngineImpl>()); });
+                        []() { return ffi::Module(tvm::ffi::make_object<JSONFFIEngineImpl>()); });
 });
 
 }  // namespace json_ffi
diff --git a/cpp/serve/config.cc b/cpp/serve/config.cc
@@ -264,7 +264,7 @@ Result<GenerationConfig> GenerationConfig::Validate(GenerationConfig cfg) {
 Result<GenerationConfig> GenerationConfig::FromJSON(const picojson::object& config,
                                                     const GenerationConfig& default_config) {
   using TResult = Result<GenerationConfig>;
-  ObjectPtr<GenerationConfigNode> n = make_object<GenerationConfigNode>();
+  ObjectPtr<GenerationConfigNode> n = tvm::ffi::make_object<GenerationConfigNode>();
   n->n = json::LookupOrDefault<int64_t>(config, "n", default_config->n);
   n->temperature =
       json::LookupOrDefault<double>(config, "temperature", default_config->temperature);
@@ -358,7 +358,7 @@ Result<GenerationConfig> GenerationConfig::FromJSON(const picojson::object& conf
 
 GenerationConfig GenerationConfig::GetDefaultFromModelConfig(
     const picojson::object& model_config_json) {
-  ObjectPtr<GenerationConfigNode> n = make_object<GenerationConfigNode>();
+  ObjectPtr<GenerationConfigNode> n = tvm::ffi::make_object<GenerationConfigNode>();
   n->max_tokens = -1;
   n->temperature = json::LookupOrDefault<double>(model_config_json, "temperature", n->temperature);
   n->top_p = json::LookupOrDefault<double>(model_config_json, "top_p", n->top_p);
@@ -418,7 +418,7 @@ EngineConfig EngineConfig::FromJSONAndInferredConfig(
   CHECK(inferred_config.max_total_sequence_length.has_value());
   CHECK(inferred_config.prefill_chunk_size.has_value());
   CHECK(inferred_config.max_history_size.has_value());
-  ObjectPtr<EngineConfigNode> n = make_object<EngineConfigNode>();
+  ObjectPtr<EngineConfigNode> n = tvm::ffi::make_object<EngineConfigNode>();
 
   // - Get models and model libs.
   n->model = json::Lookup<std::string>(json, "model");
diff --git a/cpp/serve/config.h b/cpp/serve/config.h
@@ -23,6 +23,9 @@ namespace serve {
 
 using namespace tvm;
 using namespace tvm::runtime;
+using tvm::ffi::Array;
+using tvm::ffi::Optional;
+using tvm::ffi::String;
 
 /****************** GenerationConfig ******************/
 
diff --git a/cpp/serve/data.cc b/cpp/serve/data.cc
@@ -57,7 +57,7 @@ std::pair<Array<Data>, Array<Data>> SplitData(const Array<Data>& original_data,
 /****************** TextData ******************/
 
 TextData::TextData(String text) {
-  ObjectPtr<TextDataNode> n = make_object<TextDataNode>();
+  ObjectPtr<TextDataNode> n = tvm::ffi::make_object<TextDataNode>();
   n->text = std::move(text);
   data_ = std::move(n);
 }
@@ -82,13 +82,13 @@ TVM_FFI_STATIC_INIT_BLOCK({
 /****************** TokenData ******************/
 
 TokenData::TokenData(IntTuple token_ids) {
-  ObjectPtr<TokenDataNode> n = make_object<TokenDataNode>();
+  ObjectPtr<TokenDataNode> n = tvm::ffi::make_object<TokenDataNode>();
   n->token_ids = std::move(token_ids);
   data_ = std::move(n);
 }
 
 TokenData::TokenData(std::vector<int32_t> token_ids) {
-  ObjectPtr<TokenDataNode> n = make_object<TokenDataNode>();
+  ObjectPtr<TokenDataNode> n = tvm::ffi::make_object<TokenDataNode>();
   n->token_ids = IntTuple(token_ids.begin(), token_ids.end());
   data_ = std::move(n);
 }
@@ -117,7 +117,7 @@ TVM_FFI_STATIC_INIT_BLOCK({
 /****************** ImageData ******************/
 
 ImageData::ImageData(Tensor image, int embed_size) {
-  ObjectPtr<ImageDataNode> n = make_object<ImageDataNode>();
+  ObjectPtr<ImageDataNode> n = tvm::ffi::make_object<ImageDataNode>();
   n->image = std::move(image);
   n->embed_size = embed_size;
   data_ = std::move(n);
@@ -206,7 +206,7 @@ RequestStreamOutput::RequestStreamOutput(
     std::optional<std::vector<std::vector<String>>> group_delta_logprob_json_strs,
     std::vector<Optional<String>> group_finish_reason,
     std::vector<String> group_extra_prefix_string) {
-  ObjectPtr<RequestStreamOutputObj> n = make_object<RequestStreamOutputObj>();
+  ObjectPtr<RequestStreamOutputObj> n = tvm::ffi::make_object<RequestStreamOutputObj>();
   n->request_id = std::move(request_id);
   n->group_delta_token_ids = std::move(group_delta_token_ids);
   n->group_delta_logprob_json_strs = std::move(group_delta_logprob_json_strs);
@@ -217,7 +217,7 @@ RequestStreamOutput::RequestStreamOutput(
 
 RequestStreamOutput RequestStreamOutput::Usage(String request_id,
                                                String request_final_usage_json_str) {
-  ObjectPtr<RequestStreamOutputObj> n = make_object<RequestStreamOutputObj>();
+  ObjectPtr<RequestStreamOutputObj> n = tvm::ffi::make_object<RequestStreamOutputObj>();
   n->request_id = std::move(request_id);
   n->request_final_usage_json_str = std::move(request_final_usage_json_str);
   return RequestStreamOutput(n);
diff --git a/cpp/serve/engine.cc b/cpp/serve/engine.cc
@@ -55,7 +55,7 @@ inline std::optional<TokenizerInfo> GetTokenizerInfo(const picojson::object& mod
   }
   const picojson::object& tokenizer_info_obj =
       model_config.at("tokenizer_info").get<picojson::object>();
-  auto info = make_object<TokenizerInfoNode>();
+  auto info = tvm::ffi::make_object<TokenizerInfoNode>();
   if (tokenizer_info_obj.count("token_postproc_method")) {
     info->token_postproc_method = tokenizer_info_obj.at("token_postproc_method").get<std::string>();
   }
@@ -583,7 +583,7 @@ class EngineImpl : public Engine {
       }
       // - Override the "n" in generation config to 1.
       ObjectPtr<GenerationConfigNode> updated_generation_cfg =
-          make_object<GenerationConfigNode>(*request->generation_cfg.get());
+          tvm::ffi::make_object<GenerationConfigNode>(*request->generation_cfg.get());
       updated_generation_cfg->n = 1;
       request->generation_cfg = GenerationConfig(updated_generation_cfg);
       return false;
@@ -617,7 +617,7 @@ class EngineImpl : public Engine {
 
       RequestState rstate = it_rstate->second;
       ObjectPtr<GenerationConfigNode> updated_generation_cfg =
-          make_object<GenerationConfigNode>(*request->generation_cfg.get());
+          tvm::ffi::make_object<GenerationConfigNode>(*request->generation_cfg.get());
       // - Split the input data into two parts at the position "kv_window_begin".
       CHECK(!request->inputs.empty());
       auto [lhs_data, rhs_data] = SplitData(request->inputs, input_length, kv_window_begin);
@@ -895,7 +895,7 @@ class EngineImpl : public Engine {
       return TResult::Error(err);
     }
     picojson::object config = config_json.get<picojson::object>();
-    ObjectPtr<EngineConfigNode> n = make_object<EngineConfigNode>();
+    ObjectPtr<EngineConfigNode> n = tvm::ffi::make_object<EngineConfigNode>();
 
     // - Get the engine mode and maximum GPU utilization for inference.
     EngineMode mode = EngineModeFromString(json::Lookup<std::string>(config, "mode"));
@@ -1049,7 +1049,7 @@ class EngineModule : public ffi::ModuleObj {
     this->default_generation_config_ = output.default_generation_cfg;
   }
   /*! \brief Construct an EngineModule. */
-  static ffi::Module Create() { return ffi::Module(make_object<EngineModule>()); }
+  static ffi::Module Create() { return ffi::Module(tvm::ffi::make_object<EngineModule>()); }
   /*! \brief Redirection to `Engine::AddRequest`. */
   void AddRequest(Request request) { return GetEngine()->AddRequest(std::move(request)); }
   /*! \brief Redirection to `Engine::AbortRequest`. */
diff --git a/cpp/serve/engine_actions/auto_spec_decode.cc b/cpp/serve/engine_actions/auto_spec_decode.cc
@@ -80,7 +80,7 @@ class AutoSpecDecodeActionObj : public EngineActionObj {
 EngineAction EngineAction::AutoSpecDecode(std::vector<EngineAction> spec_decode_actions_,
                                           std::vector<EngineAction> batch_decode_actions_,
                                           EngineConfig engine_config) {
-  return EngineAction(make_object<AutoSpecDecodeActionObj>(
+  return EngineAction(tvm::ffi::make_object<AutoSpecDecodeActionObj>(
       Array<EngineAction>(spec_decode_actions_), Array<EngineAction>(batch_decode_actions_),
       std::move(engine_config)));
 }
diff --git a/cpp/serve/engine_actions/batch_decode.cc b/cpp/serve/engine_actions/batch_decode.cc
@@ -317,7 +317,7 @@ EngineAction EngineAction::BatchDecode(Array<Model> models, Tokenizer tokenizer,
                                        LogitProcessor logit_processor, Sampler sampler,
                                        EngineConfig engine_config,
                                        Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<BatchDecodeActionObj>(
+  return EngineAction(tvm::ffi::make_object<BatchDecodeActionObj>(
       std::move(models), std::move(tokenizer), std::move(logit_processor), std::move(sampler),
       std::move(engine_config), std::move(trace_recorder)));
 }
diff --git a/cpp/serve/engine_actions/batch_draft.cc b/cpp/serve/engine_actions/batch_draft.cc
@@ -194,8 +194,8 @@ class BatchDraftActionObj : public EngineActionObj {
             if (engine_config_->spec_tree_width == 1) {
               return mstates[i]->request->generation_cfg;
             }
-            auto spec_generation_cfg =
-                make_object<GenerationConfigNode>(*(mstates[i]->request->generation_cfg.get()));
+            auto spec_generation_cfg = tvm::ffi::make_object<GenerationConfigNode>(
+                *(mstates[i]->request->generation_cfg.get()));
             spec_generation_cfg->top_logprobs = engine_config_->spec_tree_width;
             spec_generation_cfg->logprobs = true;
             spec_generation_cfg->temperature = 1.0;
@@ -397,7 +397,7 @@ EngineAction EngineAction::BatchDraft(Array<Model> models, LogitProcessor logit_
                                       DraftTokenWorkspaceManager draft_token_workspace_manager,
                                       EngineConfig engine_config,
                                       Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<BatchDraftActionObj>(
+  return EngineAction(tvm::ffi::make_object<BatchDraftActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(draft_token_workspace_manager),
       std::move(engine_config), std::move(trace_recorder)));
diff --git a/cpp/serve/engine_actions/batch_jumpforward.cc b/cpp/serve/engine_actions/batch_jumpforward.cc
@@ -230,7 +230,7 @@ class BatchJumpForwardActionObj : public EngineActionObj {
 
 EngineAction EngineAction::BatchJumpForward(Array<Model> models, Tokenizer tokenizer,
                                             Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<BatchJumpForwardActionObj>(
+  return EngineAction(tvm::ffi::make_object<BatchJumpForwardActionObj>(
       std::move(models), std::move(tokenizer), std::move(trace_recorder)));
 }
 
diff --git a/cpp/serve/engine_actions/batch_verify.cc b/cpp/serve/engine_actions/batch_verify.cc
@@ -371,7 +371,7 @@ EngineAction EngineAction::BatchVerify(Array<Model> models, LogitProcessor logit
                                        DraftTokenWorkspaceManager draft_token_workspace_manager,
                                        EngineConfig engine_config,
                                        Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<BatchVerifyActionObj>(
+  return EngineAction(tvm::ffi::make_object<BatchVerifyActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(draft_token_workspace_manager),
       std::move(engine_config), std::move(trace_recorder)));
diff --git a/cpp/serve/engine_actions/disagg_prepare_recv.cc b/cpp/serve/engine_actions/disagg_prepare_recv.cc
@@ -431,7 +431,7 @@ EngineAction EngineAction::DisaggPrepareReceive(Array<Model> models, EngineConfi
                                                 std::vector<picojson::object> model_configs,
                                                 Optional<EventTraceRecorder> trace_recorder,
                                                 FRequestStreamCallback request_stream_callback) {
-  return EngineAction(make_object<DisaggPrepareReceiveActionObj>(
+  return EngineAction(tvm::ffi::make_object<DisaggPrepareReceiveActionObj>(
       std::move(models), std::move(engine_config), std::move(model_configs),
       std::move(trace_recorder), std::move(request_stream_callback)));
 }
diff --git a/cpp/serve/engine_actions/disagg_remote_send.cc b/cpp/serve/engine_actions/disagg_remote_send.cc
@@ -487,7 +487,7 @@ EngineAction EngineAction::DisaggRemoteSend(
     Array<Model> models, std::vector<ModelWorkspace> model_workspaces, EngineConfig engine_config,
     std::vector<picojson::object> model_configs, Optional<EventTraceRecorder> trace_recorder,
     FRequestStreamCallback request_stream_callback, Device device) {
-  return EngineAction(make_object<DisaggRemoteSendActionObj>(
+  return EngineAction(tvm::ffi::make_object<DisaggRemoteSendActionObj>(
       std::move(models), std::move(model_workspaces), std::move(engine_config),
       std::move(model_configs), std::move(trace_recorder), std::move(request_stream_callback),
       device));
diff --git a/cpp/serve/engine_actions/eagle_batch_draft.cc b/cpp/serve/engine_actions/eagle_batch_draft.cc
@@ -223,7 +223,7 @@ EngineAction EngineAction::EagleBatchDraft(Array<Model> models, LogitProcessor l
                                            DraftTokenWorkspaceManager draft_token_workspace_manager,
                                            EngineConfig engine_config,
                                            Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<EagleBatchDraftActionObj>(
+  return EngineAction(tvm::ffi::make_object<EagleBatchDraftActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(draft_token_workspace_manager),
       std::move(engine_config), std::move(trace_recorder)));
diff --git a/cpp/serve/engine_actions/eagle_batch_verify.cc b/cpp/serve/engine_actions/eagle_batch_verify.cc
@@ -449,7 +449,7 @@ EngineAction EngineAction::EagleBatchVerify(
     std::vector<ModelWorkspace> model_workspaces,
     DraftTokenWorkspaceManager draft_token_workspace_manager, EngineConfig engine_config,
     Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<EagleBatchVerifyActionObj>(
+  return EngineAction(tvm::ffi::make_object<EagleBatchVerifyActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(draft_token_workspace_manager),
       std::move(engine_config), std::move(trace_recorder)));
diff --git a/cpp/serve/engine_actions/eagle_new_request_prefill.cc b/cpp/serve/engine_actions/eagle_new_request_prefill.cc
@@ -487,7 +487,7 @@ EngineAction EngineAction::EagleNewRequestPrefill(
     std::vector<ModelWorkspace> model_workspaces,
     DraftTokenWorkspaceManager draft_token_workspace_manager, EngineConfig engine_config,
     std::vector<picojson::object> model_configs, Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<EagleNewRequestPrefillActionObj>(
+  return EngineAction(tvm::ffi::make_object<EagleNewRequestPrefillActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(draft_token_workspace_manager),
       std::move(engine_config), std::move(model_configs), std::move(trace_recorder)));
diff --git a/cpp/serve/engine_actions/new_request_prefill.cc b/cpp/serve/engine_actions/new_request_prefill.cc
@@ -354,7 +354,7 @@ EngineAction EngineAction::NewRequestPrefill(Array<Model> models, LogitProcessor
                                              EngineConfig engine_config,
                                              std::vector<picojson::object> model_configs,
                                              Optional<EventTraceRecorder> trace_recorder) {
-  return EngineAction(make_object<NewRequestPrefillActionObj>(
+  return EngineAction(tvm::ffi::make_object<NewRequestPrefillActionObj>(
       std::move(models), std::move(logit_processor), std::move(sampler),
       std::move(model_workspaces), std::move(engine_config), std::move(model_configs),
       std::move(trace_recorder)));
diff --git a/cpp/serve/engine_state.cc b/cpp/serve/engine_state.cc
@@ -8,7 +8,7 @@ namespace mlc {
 namespace llm {
 namespace serve {
 
-EngineState::EngineState() { data_ = make_object<EngineStateObj>(); }
+EngineState::EngineState() { data_ = tvm::ffi::make_object<EngineStateObj>(); }
 
 void EngineStateObj::Reset() {
   running_queue.clear();
diff --git a/cpp/serve/function_table.cc b/cpp/serve/function_table.cc
@@ -119,10 +119,10 @@ void FunctionTable::Init(String reload_lib_path, Device device, picojson::object
       if (device.device_type == kDLOpenCL) {
         auto f_get = executable->GetFunction("opencl.GetPreCompiledPrograms", true);
         CHECK(f_get.defined()) << "Cannot find opencl.GetPreCompiledPrograms";
-        tvm::String bytes = f_get.value()().cast<String>();
+        tvm::ffi::String bytes = f_get.value()().cast<String>();
         auto f_set = executable->GetFunction("opencl.SetPreCompiledPrograms", true);
         CHECK(f_set.defined()) << "Cannot find opencl.SetPreCompiledPrograms";
-        f_set.value()(tvm::String(bytes));
+        f_set.value()(tvm::ffi::String(bytes));
       }
       ICHECK(fload_exec.defined()) << "TVM runtime cannot find vm_load_executable";
     }
diff --git a/cpp/serve/logit_processor.cc b/cpp/serve/logit_processor.cc
@@ -495,8 +495,8 @@ class LogitProcessorImpl : public LogitProcessorObj {
 
 LogitProcessor::LogitProcessor(int max_num_token, int vocab_size, FunctionTable* ft,
                                DLDevice device, Optional<EventTraceRecorder> trace_recorder) {
-  data_ = make_object<LogitProcessorImpl>(max_num_token, vocab_size, ft, device,
-                                          std::move(trace_recorder));
+  data_ = tvm::ffi::make_object<LogitProcessorImpl>(max_num_token, vocab_size, ft, device,
+                                                    std::move(trace_recorder));
 }
 
 }  // namespace serve
diff --git a/cpp/serve/model.cc b/cpp/serve/model.cc
@@ -28,8 +28,8 @@ class ModelImpl;
 Model Model::Create(String reload_lib_path, String model_path, const picojson::object& model_config,
                     DLDevice device, const Optional<Session>& session, int num_shards,
                     int num_stages, bool trace_enabled) {
-  return Model(make_object<ModelImpl>(reload_lib_path, model_path, model_config, device, session,
-                                      num_shards, num_stages, trace_enabled));
+  return Model(tvm::ffi::make_object<ModelImpl>(reload_lib_path, model_path, model_config, device,
+                                                session, num_shards, num_stages, trace_enabled));
 }
 
 Result<picojson::object> Model::LoadModelConfig(const String& model_path) {
diff --git a/cpp/serve/prefix_cache.cc b/cpp/serve/prefix_cache.cc
@@ -425,12 +425,12 @@ class NoPrefixCache : public PrefixCacheObj {
 PrefixCache PrefixCache::CreateRadixPrefixCache(size_t max_num_recycling_seqs,
                                                 PrefixCacheRemoveCallback remove_callback) {
   ObjectPtr<PrefixCacheImpl> n =
-      make_object<PrefixCacheImpl>(max_num_recycling_seqs, std::move(remove_callback));
+      tvm::ffi::make_object<PrefixCacheImpl>(max_num_recycling_seqs, std::move(remove_callback));
   return PrefixCache(std::move(n));
 }
 
 PrefixCache PrefixCache::CreateNoPrefixCache() {
-  ObjectPtr<NoPrefixCache> n = make_object<NoPrefixCache>();
+  ObjectPtr<NoPrefixCache> n = tvm::ffi::make_object<NoPrefixCache>();
   return PrefixCache(std::move(n));
 }
 
diff --git a/cpp/serve/request.cc b/cpp/serve/request.cc
@@ -34,7 +34,7 @@ Request::Request(String id, Array<Data> inputs, GenerationConfig generation_cfg)
     }
   }
 
-  ObjectPtr<RequestNode> n = make_object<RequestNode>();
+  ObjectPtr<RequestNode> n = tvm::ffi::make_object<RequestNode>();
   n->id = std::move(id);
   n->inputs = std::move(inputs);
   n->prompt_tokens = prompt_tokens;
diff --git a/cpp/serve/request_state.cc b/cpp/serve/request_state.cc
diff --git a/cpp/serve/sampler/cpu_sampler.cc b/cpp/serve/sampler/cpu_sampler.cc
diff --git a/cpp/serve/sampler/gpu_sampler.cc b/cpp/serve/sampler/gpu_sampler.cc
diff --git a/cpp/serve/threaded_engine.cc b/cpp/serve/threaded_engine.cc

Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ class AutoSpecDecodeActionObj : public EngineActionObj {`
`80`	`80`	`EngineAction EngineAction::AutoSpecDecode(std::vector<EngineAction> spec_decode_actions_,`
`81`	`81`	`std::vector<EngineAction> batch_decode_actions_,`
`82`	`82`	`EngineConfig engine_config) {`
`83`		`- return EngineAction(make_object<AutoSpecDecodeActionObj>(`
	`83`	`+ return EngineAction(tvm::ffi::make_object<AutoSpecDecodeActionObj>(`
`84`	`84`	`Array<EngineAction>(spec_decode_actions_), Array<EngineAction>(batch_decode_actions_),`
`85`	`85`	`std::move(engine_config)));`
`86`	`86`	`}`
Original file line number	Diff line number	Diff line change
`@@ -317,7 +317,7 @@ EngineAction EngineAction::BatchDecode(Array<Model> models, Tokenizer tokenizer,`
`317`	`317`	`LogitProcessor logit_processor, Sampler sampler,`
`318`	`318`	`EngineConfig engine_config,`
`319`	`319`	`Optional<EventTraceRecorder> trace_recorder) {`
`320`		`- return EngineAction(make_object<BatchDecodeActionObj>(`
	`320`	`+ return EngineAction(tvm::ffi::make_object<BatchDecodeActionObj>(`
`321`	`321`	`std::move(models), std::move(tokenizer), std::move(logit_processor), std::move(sampler),`
`322`	`322`	`std::move(engine_config), std::move(trace_recorder)));`
`323`	`323`	`}`
Original file line number	Diff line number	Diff line change
`@@ -230,7 +230,7 @@ class BatchJumpForwardActionObj : public EngineActionObj {`
`230`	`230`
`231`	`231`	`EngineAction EngineAction::BatchJumpForward(Array<Model> models, Tokenizer tokenizer,`
`232`	`232`	`Optional<EventTraceRecorder> trace_recorder) {`
`233`		`- return EngineAction(make_object<BatchJumpForwardActionObj>(`
	`233`	`+ return EngineAction(tvm::ffi::make_object<BatchJumpForwardActionObj>(`
`234`	`234`	`std::move(models), std::move(tokenizer), std::move(trace_recorder)));`
`235`	`235`	`}`
`236`	`236`