feat(minimax-h3): add native Windows RTX path

Build MiniMax H3 plans in isolated processes and stream them directly to disk so Windows builds and inference do not co-reside every model stage.

Add portable shared-library loading, explicit Windows SDK inputs, file-backed TensorRT-RTX deserialization with plan integrity checks, staged denoiser/VAE residency, and public-safe documentation. Keep the standard TensorRT path unchanged and omit machine-identifying provenance.

Author: yifeif-nv

CMakeLists.txt

@@ -53,6 +53,25 @@ if(TRTMC_MODEL_PROOF_MODEL)
   endif()
 endif()
 
+if(TRTMC_RUNTIME_MODELS)
+  set(_trtmc_selected_model_manifests)
+  foreach(_trtmc_model IN LISTS TRTMC_RUNTIME_MODELS)
+    if(NOT _trtmc_model MATCHES "^[A-Za-z0-9_.-]+$")
+      message(FATAL_ERROR
+        "TRTMC_RUNTIME_MODELS contains an unsafe model id: '${_trtmc_model}'")
+    endif()
+    set(_trtmc_selected_manifest
+      "${PROJECT_SOURCE_DIR}/src/runtime/models/${_trtmc_model}/MODEL.toml")
+    if(NOT EXISTS "${_trtmc_selected_manifest}")
+      message(FATAL_ERROR
+        "TRTMC_RUNTIME_MODELS requests unknown model '${_trtmc_model}'")
+    endif()
+    list(APPEND _trtmc_selected_model_manifests "${_trtmc_selected_manifest}")
+  endforeach()
+  list(REMOVE_DUPLICATES _trtmc_selected_model_manifests)
+  set(TRTMC_RUNTIME_MODEL_MANIFESTS ${_trtmc_selected_model_manifests})
+endif()
+
 set(TRTMC_RUNTIME_MODEL_IDS)
 foreach(_trtmc_model_manifest IN LISTS TRTMC_RUNTIME_MODEL_MANIFESTS)
   get_filename_component(_trtmc_model_dir "${_trtmc_model_manifest}" DIRECTORY)
@@ -71,7 +90,10 @@ foreach(_trtmc_model_manifest IN LISTS TRTMC_RUNTIME_MODEL_MANIFESTS)
 
   _trtmc_model_manifest_string("${_trtmc_model_manifest_text}" "runtime_library"
     _trtmc_runtime_library)
-  if(NOT _trtmc_runtime_library)
+  if(WIN32)
+    set(_trtmc_runtime_library
+      "${CMAKE_SHARED_LIBRARY_PREFIX}trtmc_model_${_trtmc_model}${CMAKE_SHARED_LIBRARY_SUFFIX}")
+  elseif(NOT _trtmc_runtime_library)
     set(_trtmc_runtime_library "libtrtmc_model_${_trtmc_model}.so")
   endif()
 

cmake/trtmc_pipeline_plugins.cmake

@@ -22,10 +22,9 @@ struct DistributedRuntimeGroup {
 
 // Initialize an NCCL communicator for TensorRT 11.0+ distributed collective layers.
 //
-// This intentionally avoids compile-time MPI/NCCL dependencies: ranks are
-// discovered from common mpirun environment variables, and NCCL is loaded with
-// dlopen at runtime. Rank 0 writes the NCCL unique ID to a small rendezvous
-// file under /tmp unless TRTMC_NCCL_RENDEZVOUS points elsewhere.
+// Linux avoids compile-time MPI/NCCL dependencies: ranks are discovered from
+// common mpirun environment variables and NCCL is loaded at runtime. Native
+// Windows builds support only the single-device case and reject tp_size > 1.
 DistributedRuntimeGroup initialize_tensor_parallel_group(int tp_size);
 
 } // namespace trtmc

include/trtmc/runtime/distributed_runtime.h

@@ -37,8 +37,9 @@ std::optional<std::string> legacy_runtime_strategy_alias_target(const std::strin
                                                                 const std::string& config_text);
 
 // Load the model plugin that owns strategy. Search paths are directories that
-// contain libtrtmc_model_<model>.so; TRTMC_MODEL_PLUGIN_DIR and build/install
-// defaults are consulted after these explicit paths. When
+// contain the platform-native trtmc_model_<model> shared library;
+// TRTMC_MODEL_PLUGIN_DIR and build/install defaults are consulted after these
+// explicit paths. When
 // TRTMC_MODEL_PLUGIN_STRICT=1, only explicit paths and TRTMC_MODEL_PLUGIN_DIR
 // are used, so an installed or stale build-tree DSO cannot satisfy a CI proof.
 void load_model_plugin_for_strategy(const std::string& strategy,

include/trtmc/runtime/pipeline_plugin_loader.h

@@ -178,8 +178,9 @@ def _open_atomic_bundle_output(destination: Path):
         except FileExistsError:
             continue
         try:
-            if destination_mode is not None:
-                os.fchmod(descriptor, destination_mode)
+            fchmod = getattr(os, "fchmod", None)
+            if destination_mode is not None and fchmod is not None:
+                fchmod(descriptor, destination_mode)
             return os.fdopen(descriptor, "wb"), temporary_path
         except Exception:
             os.close(descriptor)

python/tensorrt_model_connect/bundle_writer.py

@@ -1722,6 +1722,35 @@ def _build_diffusion_bundle(
     if "_transformer_config" in weights:
         config.raw["_transformer_config"] = weights["_transformer_config"]
 
+    # A model may require isolated component processes and file-backed bundle
+    # sections when built for RTX. Keep that policy model-owned; ordinary TRT
+    # diffusion builds continue through build_components() below.
+    build_staged_bundle = getattr(plugin, "build_staged_bundle", None)
+    if rtx and callable(build_staged_bundle):
+        if fp8_scales or save_fp8_scales:
+            raise ValueError("Staged TensorRT-RTX builds do not support FP8 calibration")
+        staged_t0 = time.monotonic()
+        build_staged_bundle(
+            str(model_dir_path),
+            output_path,
+            config,
+            weights,
+            precision=precision,
+            verbose=verbose,
+            parallel_config=parallel,
+            max_batch_size=max_batch_size,
+        )
+        staged_elapsed = time.monotonic() - staged_t0
+        _add_build_timing(build_timing, "trt_compile_diffusion_components_s", staged_elapsed)
+        build_timing["total_s"] = time.monotonic() - t0
+        _write_build_timing(build_timing)
+        print(
+            f"[trtmc build] Staged RTX bundle saved: {output_path} "
+            f"[{staged_elapsed:.1f}s]",
+            file=sys.stderr,
+        )
+        return
+
     # Prefer a family-provided scale asset before running live calibration.
     if fp8_scales == "auto":
         precomputed_fn = getattr(plugin, "fp8_precomputed_scales", None)

python/tensorrt_model_connect/engine_builder.py

@@ -12,6 +12,7 @@
 
 import gc
 import sys
+from pathlib import Path
 
 from tensorrt_model_connect import trt_compat
 
@@ -44,20 +45,23 @@ def checkpoint_keys(
     return tuple(names)
 
 
+@op.cleanup_failed_build
 def build_adaln_precompute_engine(
     weights: dict,
     profile: MiniMaxH3Config,
     *,
     verbose: bool = False,
     consume_weights: bool = False,
     workspace_bytes: int | None = None,
-) -> bytes:
+    weight_streaming: bool = False,
+    output_path: str | Path | None = None,
+) -> bytes | dict[str, int | str]:
     profile.validate()
     logger = trt.Logger(trt.Logger.VERBOSE if verbose else trt.Logger.WARNING)
     builder = trt.Builder(logger)
     network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.STRONGLY_TYPED))
     config = builder.create_builder_config()
-    op.configure_builder(config)
+    op.configure_builder(config, weight_streaming=weight_streaming)
     op.configure_workspace(
         config,
         workspace_bytes,
@@ -128,14 +132,21 @@ def build_adaln_precompute_engine(
         f"timesteps={profile.max_timestep_count}",
         file=sys.stderr,
     )
+    plan = None
+    record = None
     try:
-        plan = builder.build_serialized_network(network, config)
+        if output_path is None:
+            plan = builder.build_serialized_network(network, config)
+        else:
+            record = trt_compat.build_serialized_network_to_file(
+                builder, network, config, output_path
+            )
     finally:
         op.release_weight_buffers(network)
         if consume_weights:
             weights.clear()
-    if plan is None:
+    if output_path is None and plan is None:
         raise RuntimeError("TensorRT failed to build MiniMax-H3 AdaLN precompute engine")
     del network, config, builder
     gc.collect()
-    return bytes(plan)
+    return record if record is not None else bytes(plan)

python/tensorrt_model_connect/families/minimax_h3/adaln_builder.py

@@ -18,6 +18,13 @@
 DENOISER_DEFAULT_WORKSPACE_BYTES = 96 << 30
 VAE_TILE_DECODER_DEFAULT_WORKSPACE_BYTES = 96 << 30
 
+# The RTX path builds each plan in a fresh process, so one conservative
+# workspace and runtime budget cover every stage without coupling the public
+# artifact to a particular workstation identity.
+RTX_STAGED_WORKSPACE_BYTES = 16 << 30
+RTX_WEIGHT_STREAMING_BUDGET_BYTES = 32 << 30
+RTX_CUDA_MAJOR = 12
+
 DEFAULT_WORKSPACE_LIMIT_BYTES = {
     "text_encoder.plan": TEXT_ENCODER_DEFAULT_WORKSPACE_BYTES,
     "adaln_precompute.plan": ADALN_PRECOMPUTE_DEFAULT_WORKSPACE_BYTES,