Add files using upload-large-folder tool

FlowCache/FlowCache4MAGI-1-dev-V1/downloads/_hf_raw/ckpt/t5/t5-v1_1-xxl/tokenizer_config.json

@@ -0,0 +1 @@
+{"eos_token": "</s>", "unk_token": "<unk>", "pad_token": "<pad>", "extra_ids": 100, "additional_special_tokens": ["<extra_id_0>", "<extra_id_1>", "<extra_id_2>", "<extra_id_3>", "<extra_id_4>", "<extra_id_5>", "<extra_id_6>", "<extra_id_7>", "<extra_id_8>", "<extra_id_9>", "<extra_id_10>", "<extra_id_11>", "<extra_id_12>", "<extra_id_13>", "<extra_id_14>", "<extra_id_15>", "<extra_id_16>", "<extra_id_17>", "<extra_id_18>", "<extra_id_19>", "<extra_id_20>", "<extra_id_21>", "<extra_id_22>", "<extra_id_23>", "<extra_id_24>", "<extra_id_25>", "<extra_id_26>", "<extra_id_27>", "<extra_id_28>", "<extra_id_29>", "<extra_id_30>", "<extra_id_31>", "<extra_id_32>", "<extra_id_33>", "<extra_id_34>", "<extra_id_35>", "<extra_id_36>", "<extra_id_37>", "<extra_id_38>", "<extra_id_39>", "<extra_id_40>", "<extra_id_41>", "<extra_id_42>", "<extra_id_43>", "<extra_id_44>", "<extra_id_45>", "<extra_id_46>", "<extra_id_47>", "<extra_id_48>", "<extra_id_49>", "<extra_id_50>", "<extra_id_51>", "<extra_id_52>", "<extra_id_53>", "<extra_id_54>", "<extra_id_55>", "<extra_id_56>", "<extra_id_57>", "<extra_id_58>", "<extra_id_59>", "<extra_id_60>", "<extra_id_61>", "<extra_id_62>", "<extra_id_63>", "<extra_id_64>", "<extra_id_65>", "<extra_id_66>", "<extra_id_67>", "<extra_id_68>", "<extra_id_69>", "<extra_id_70>", "<extra_id_71>", "<extra_id_72>", "<extra_id_73>", "<extra_id_74>", "<extra_id_75>", "<extra_id_76>", "<extra_id_77>", "<extra_id_78>", "<extra_id_79>", "<extra_id_80>", "<extra_id_81>", "<extra_id_82>", "<extra_id_83>", "<extra_id_84>", "<extra_id_85>", "<extra_id_86>", "<extra_id_87>", "<extra_id_88>", "<extra_id_89>", "<extra_id_90>", "<extra_id_91>", "<extra_id_92>", "<extra_id_93>", "<extra_id_94>", "<extra_id_95>", "<extra_id_96>", "<extra_id_97>", "<extra_id_98>", "<extra_id_99>"], "model_max_length": 512, "name_or_path": "t5-small"}

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/__init__.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .common_utils import divide, env_is_true, set_random_seed
+from .config import EngineConfig, MagiConfig, ModelConfig, RuntimeConfig
+from .dataclass import InferenceParams, ModelMetaArgs, PackedCoreAttnParams, PackedCrossAttnParams
+from .logger import magi_logger, print_per_rank, print_rank_0
+from .timer import event_path_timer
+
+__all__ = [
+    "MagiConfig",
+    "ModelConfig",
+    "EngineConfig",
+    "RuntimeConfig",
+    "magi_logger",
+    "print_per_rank",
+    "print_rank_0",
+    "event_path_timer",
+    "divide",
+    "env_is_true",
+    "set_random_seed",
+    "PackedCoreAttnParams",
+    "PackedCrossAttnParams",
+    "ModelMetaArgs",
+    "InferenceParams",
+]

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/common_utils.py

@@ -0,0 +1,42 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import random
+
+import numpy as np
+import torch
+
+
+def env_is_true(env_name: str) -> bool:
+    return str(os.environ.get(env_name, "0")).lower() in {"1", "true", "yes", "y", "on", "enabled"}
+
+
+def divide(numerator, denominator):
+    assert numerator % denominator == 0, "{} is not divisible by {}".format(numerator, denominator)
+    return numerator // denominator
+
+
+def set_random_seed(seed):
+    """Set random seed.
+
+    Args:
+        seed (int): Seed to be used.
+    """
+    assert seed is not None, "Please provide a seed in config.json"
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    return seed

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/config.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import dataclasses
+import json
+import os
+
+import torch
+
+
+@dataclasses.dataclass
+class ModelConfig:
+    model_name: str
+
+    # Transformer
+    num_layers: int = None  # Number of transformer layers.
+    hidden_size: int = None  # Transformer hidden size.
+    ffn_hidden_size: int = None  # Transformer Feed-Forward Network hidden size
+    num_attention_heads: int = None  # Number of transformer attention heads.
+    num_query_groups: int = 1  # Number of query groups, which used for GQA
+    kv_channels: int = None  # Projection weights dimension in multi-head attention
+    layernorm_epsilon: float = 1e-6  # Epsilon for layer norm and RMS norm.
+    apply_layernorm_1p: bool = False  # Adjust LayerNorm weights which improves numerical stability.
+    x_rescale_factor: float = 1.0
+    half_channel_vae: bool = False
+    params_dtype: torch.dtype = None
+
+    # Embedding
+    patch_size: int = 2  # (latent) patch size for DiT patch embedding layer
+    t_patch_size: int = 1  # (latent) patch size for t dim patch embedding layer
+    in_channels: int = 4  # latent input channel for DiT
+    out_channels: int = 4  # latent output channel for DiT
+    cond_hidden_ratio: float = 0.25
+    caption_channels: int = 4096
+    caption_max_length: int = 800
+    xattn_cond_hidden_ratio: float = 1.0
+    cond_gating_ratio: float = 1.0
+    gated_linear_unit: bool = False
+
+
+@dataclasses.dataclass
+class RuntimeConfig:
+    # Inference settings such as cfg, kv range, clean t, etc.
+    cfg_number: int = None  # Number of CFG
+    cfg_t_range: list = dataclasses.field(
+        default_factory=lambda: [0, 0.0217, 0.1000, 0.3, 0.999]
+    )  # CFG t-range of each scales
+    prev_chunk_scales: list = dataclasses.field(
+        default_factory=lambda: [1.5, 1.5, 1.5, 1.5, 1.5]
+    )  # CFG scales of previous chunks
+    text_scales: list = dataclasses.field(default_factory=lambda: [7.5, 7.5, 7.5, 7.5, 7.5])  # CFG scales of text
+
+    noise2clean_kvrange: list = dataclasses.field(default_factory=list)  # Range of kv for noise2clean chunks
+    clean_chunk_kvrange: int = -1  # Range of kv for clean chunks
+    clean_t: float = 1.0  # timestep for clean chunks
+
+    # Video settings
+    seed: int = 1234  # Random seed used for python, numpy, pytorch, and cuda.
+    num_frames: int = 128
+    video_size_h: int = None
+    video_size_w: int = None
+    num_steps: int = 64  # Number of steps for the diffusion model
+    window_size: int = 4  # Window size for the diffusion model
+    fps: int = 24  # Frames per second
+    chunk_width: int = 6  # Clip width for the diffusion model
+
+    # Checkpoint, includes t5, vae, dit, etc.
+    t5_pretrained: str = None  # Path to load pretrained T5 model.
+    t5_device: str = "cuda"  # Device for T5 model to run on.
+    vae_pretrained: str = None  # Path to load pretrained VAE model.
+    scale_factor: float = 0.18215  # Scale factor for the vae
+    temporal_downsample_factor: int = 4  # Temporal downsample factor for the vae
+    load: str = None  # Directory containing a model checkpoint.
+
+
+@dataclasses.dataclass
+class EngineConfig:
+    # Parallism strategy
+    distributed_backend: str = "nccl"  # Choices: ["nccl", "gloo"]
+    distributed_timeout_minutes: int = 10  # Timeout minutes for torch.distributed.
+    pp_size: int = 1  # Degree of pipeline model parallelism.
+    cp_size: int = 1  # Degree of context parallelism.
+    cp_strategy: str = "none"  # Choices: ["none", "cp_ulysses", "cp_shuffle_overlap"]
+    ulysses_overlap_degree: int = 1  # Overlap degree for Ulysses
+
+    # Quantization
+    fp8_quant: bool = False  # Enable 8-bit floating point quantization for model weights.
+
+    # Distillation
+    distill_nearly_clean_chunk_threshold: float = 0.3  # Threshold for distilling nearly clean chunks
+    shortcut_mode: str = "8,16,16"  # Parameters for shortcut mode
+    distill: bool = False  # Use distill mode
+
+    # Optimization
+    kv_offload: bool = False  # Use kv-offload algorithm
+    enable_cuda_graph: bool = False  # Enable CUDA graph for video generation
+
+
+@dataclasses.dataclass
+class MagiConfig:
+    model_config: ModelConfig
+    runtime_config: RuntimeConfig
+    engine_config: EngineConfig
+
+    @classmethod
+    def _check_missing_fields(cls, config_dict: dict, required_fields: list):
+        actual_fields = set(config_dict.keys())
+        missing_fields = set(required_fields) - actual_fields
+        if missing_fields:
+            raise ValueError(f"Missing fields in the configuration file: {', '.join(missing_fields)}")
+
+    @classmethod
+    def _create_nested_config(cls, config_dict: dict, config_name: str, config_cls):
+        nested_config_dict = config_dict.get(config_name, {})
+        cls._check_missing_fields(nested_config_dict, config_cls.__dataclass_fields__.keys())
+        return config_cls(**nested_config_dict)
+
+    @classmethod
+    def _create_config_from_dict(cls, config_dict: dict):
+        cls._check_missing_fields(config_dict, cls.__dataclass_fields__.keys())
+
+        # Create nested configs
+        model_config = cls._create_nested_config(config_dict, "model_config", ModelConfig)
+        runtime_config = cls._create_nested_config(config_dict, "runtime_config", RuntimeConfig)
+        engine_config = cls._create_nested_config(config_dict, "engine_config", EngineConfig)
+
+        return cls(model_config=model_config, runtime_config=runtime_config, engine_config=engine_config)
+
+    @classmethod
+    def from_json(cls, json_path: str):
+        def simple_json_decoder(dct):
+            dtype_map = {"torch.bfloat16": torch.bfloat16, "torch.float16": torch.float16, "torch.float32": torch.float32}
+            if 'params_dtype' in dct:
+                dct['params_dtype'] = dtype_map[dct['params_dtype']]
+            return dct
+
+        with open(json_path, "r") as f:
+            config_dict = json.load(f, object_hook=simple_json_decoder)
+        magi_config = cls._create_config_from_dict(config_dict)
+
+        def post_validation(magi_config):
+            if magi_config.engine_config.fp8_quant or magi_config.engine_config.distill:
+                assert (
+                    magi_config.runtime_config.cfg_number == 1
+                ), "Please set `cfg_number: 1` in config.json for distill or quant model"
+            else:
+                assert magi_config.runtime_config.cfg_number == 3, "Please set `cfg_number: 3` in config.json for base model"
+
+        post_validation(magi_config)
+
+        return magi_config
+
+    def to_json(self, json_path: str):
+        class SimpleJSONEncoder(json.JSONEncoder):
+            def default(self, obj):
+                if isinstance(obj, torch.dtype):
+                    return str(obj)
+                return super().default(obj)
+
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(json_path), exist_ok=True)
+
+        config_dict = {
+            "model_config": dataclasses.asdict(self.model_config),
+            "runtime_config": dataclasses.asdict(self.runtime_config),
+            "engine_config": dataclasses.asdict(self.engine_config),
+        }
+        with open(json_path, "w") as f:
+            json.dump(config_dict, f, indent=4, cls=SimpleJSONEncoder)

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/dataclass.py

@@ -0,0 +1,97 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from dataclasses import dataclass
+from typing import List
+
+import numpy as np
+import torch
+
+
+@dataclass(frozen=True)
+class PackedCoreAttnParams:
+    # Packed sequence parameters for core_attn
+    q_range: torch.Tensor
+    k_range: torch.Tensor
+    np_q_range: np.ndarray
+    np_k_range: np.ndarray
+    max_seqlen_q: int
+    max_seqlen_k: int
+
+
+@dataclass(frozen=True)
+class PackedCrossAttnParams:
+    # Packed sequence parameters for cross_attn
+    q_ranges: torch.Tensor = None
+    kv_ranges: torch.Tensor = None
+    cu_seqlens_q: torch.Tensor = None
+    cu_seqlens_kv: torch.Tensor = None
+    max_seqlen_q: int = None
+    max_seqlen_kv: int = None
+
+
+@dataclass(frozen=True)
+class ModelMetaArgs:
+    H: int
+    W: int
+    cp_pad_size: int
+    cp_split_sizes: List[int]
+    slice_point: int
+    denoising_range_num: int
+    range_num: int
+    extract_prefix_video_feature: bool
+    fwd_extra_1st_chunk: bool
+    distill_nearly_clean_chunk: bool
+    clip_token_nums: int
+    enable_cuda_graph: bool
+    core_attn_params: PackedCoreAttnParams
+    cross_attn_params: PackedCrossAttnParams
+    timestep: torch.Tensor
+    get_attn_weights_layer_num: int
+    save_kvcache_every_forward: bool
+    cur_denoise_step: int
+    # Includes all chunks of the current sequence
+    start_chunk_id: int
+    end_chunk_id: int
+    compress_kv: bool    # use kv cache compression or not
+    total_cache_len: int
+    budget_cache_len: int
+    chunk_num: int
+    debug: bool
+    near_clean_chunk_idx: int
+
+class InferenceParams:
+    """Inference parameters that are passed to the main model in order
+    to efficienly calculate and store the context during inference."""
+
+    def __init__(self, max_batch_size, max_sequence_length):
+        self.max_sequence_length = max_sequence_length
+        self.max_batch_size = max_batch_size
+        self.sequence_len_offset = 0
+        self.key_value_memory_dict = {}
+        self.update_kv_cache = False
+
+        self.kv_compressed = False
+
+    def swap_key_value_dict(self, batch_idx):
+        "swap between batches"
+        if len(self.key_value_memory_dict) == 0:
+            raise ValueError("should not swap when dict in empty")
+
+        for layer_number in self.key_value_memory_dict.keys():
+            inference_key_memory, inference_value_memory = self.key_value_memory_dict[layer_number]
+            assert len(batch_idx) == inference_key_memory.shape[1]  # make sure batch size is the same
+            new_inference_key_memory = inference_key_memory[:, batch_idx]
+            new_inference_value_memory = inference_value_memory[:, batch_idx]
+            self.key_value_memory_dict[layer_number] = (new_inference_key_memory, new_inference_value_memory)

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/logger.py

@@ -0,0 +1,51 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+
+import torch
+
+
+class GlobalLogger:
+    _logger = None
+
+    @classmethod
+    def get_logger(cls, name=__name__, level=logging.INFO):
+        if cls._logger is None:
+            cls._logger = logging.getLogger("magi_logger")
+            cls._logger.setLevel(logging.INFO)
+
+            cls._logger.propagate = False
+            cls._logger.handlers.clear()
+            formatter = logging.Formatter("[%(asctime)s - %(levelname)s] %(message)s")
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            cls._logger.addHandler(handler)
+
+        return cls._logger
+
+
+magi_logger = GlobalLogger.get_logger()
+
+
+def print_per_rank(message):
+    magi_logger.info(message)
+
+
+def print_rank_0(message):
+    if torch.distributed.is_initialized():
+        if torch.distributed.get_rank() == 0:
+            magi_logger.info(message)
+    else:
+        magi_logger.info(message)

FlowCache/FlowCache4MAGI-1-dev-V1/inference/common/timer.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from datetime import datetime
+
+import torch
+
+from .logger import print_rank_0
+
+
+class EventPathTimer:
+    """
+    A lightweight class for recording time without any distributed barrier.
+
+    This class allows for recording elapsed time between events without requiring
+    synchronization across distributed processes. It maintains the previous message
+    and time to calculate the duration between consecutive records.
+    """
+
+    def __init__(self):
+        """
+        Initialize the EventPathTimer.
+
+        This constructor sets the previous message and time to None, preparing
+        the instance for recording events.
+        """
+        self.prev_message: str = None
+        self.prev_time: datetime = None
+
+    def reset(self):
+        """
+        Reset the recorded message and time.
+
+        This method clears the previous message and time, allowing for a fresh
+        start in recording new events.
+        """
+        self.prev_message = None
+        self.prev_time = None
+
+    def synced_record(self, message):
+        """
+        Record the current time with a message.
+
+        Args:
+            message (str): A message to log along with the current time.
+
+        This method synchronizes the CUDA operations, records the current time,
+        and calculates the elapsed time since the last recorded message, if any.
+        It then logs the elapsed time along with the previous and current messages.
+        """
+        torch.cuda.synchronize()
+        current_time = datetime.now()
+        if self.prev_message is not None:
+            print_rank_0(
+                f"\nTime Elapsed: [{current_time - self.prev_time}] From [{self.prev_message} ({self.prev_time})] To [{message} ({current_time})]"
+            )
+        self.prev_message = message
+        self.prev_time = current_time
+
+
+_GLOBAL_LIGHT_TIMER = EventPathTimer()
+
+
+def event_path_timer() -> EventPathTimer:
+    """Get the current EventPathTimer instance.
+
+    Returns:
+        EventPathTimer: The current EventPathTimer instance.
+
+    Raises:
+        AssertionError: If the EventPathTimer has not been initialized.
+    """
+    assert _GLOBAL_LIGHT_TIMER is not None, "light time recorder is not initialized"
+    return _GLOBAL_LIGHT_TIMER

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/checkpoint/__init__.py

@@ -0,0 +1,17 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .checkpointing import load_checkpoint
+
+__all__ = ["load_checkpoint"]

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/checkpoint/checkpointing.py

@@ -0,0 +1,180 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import io
+import json
+import os
+import re
+import subprocess
+from collections import OrderedDict
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+
+import numpy as np
+import torch
+import torch.distributed
+from safetensors.torch import load as load_from_bytes
+from safetensors.torch import load_file
+from tqdm.auto import tqdm
+
+import inference.infra.distributed.parallel_state as mpu
+from inference.common import EngineConfig, ModelConfig, RuntimeConfig, print_per_rank, print_rank_0
+
+
+def _load_shard(shard_path, param_names, num_threads=None):
+    zstd_path = shard_path + ".zst"
+    if os.path.exists(zstd_path):
+        start_time = datetime.now()
+        print_per_rank(f"Decompressing {zstd_path} with {num_threads} threads")
+        cmd = ["zstd", "-d"]
+        if num_threads:
+            cmd.extend(["-T", str(num_threads)])
+
+        process = subprocess.Popen(cmd + ["-c", zstd_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE, bufsize=-1)
+
+        decompressed_data = process.stdout.read()
+        process.stdout.close()
+
+        retcode = process.wait()
+        if retcode != 0:
+            raise RuntimeError(f"Decompression failed: {process.stderr.read().decode()}")
+        print_per_rank(
+            f"Decompressed {zstd_path} with {num_threads} threads, duration: {(datetime.now() - start_time).total_seconds()}s"
+        )
+
+        buffer = io.BytesIO(decompressed_data)
+        start_time = datetime.now()
+        print_per_rank(f"Loading {shard_path} from zstd file, start time: {start_time}")
+        weights = load_from_bytes(buffer.getvalue())
+        print_per_rank(f"Loaded {shard_path} from zstd file, duration: {(datetime.now() - start_time).total_seconds()}s")
+        buffer.close()
+    else:
+        weights = load_file(shard_path)
+
+    return {name: weights[name] for name in param_names}
+
+
+def load_sharded_safetensors_parallel_with_progress(checkpoint_dir):
+    index_path = os.path.join(checkpoint_dir, "model.safetensors.index.json")
+    if not os.path.exists(index_path):
+        model_file_path = os.path.join(checkpoint_dir, "model.safetensors")
+        state_dict = load_file(model_file_path)
+        return state_dict
+
+    with open(index_path, "r") as f:
+        index = json.load(f)
+
+    state_dict = {}
+    shard_map = {}
+
+    # Group parameters by shard file
+    for param_name, shard_file in index["weight_map"].items():
+        shard_path = os.path.join(checkpoint_dir, shard_file)
+        if shard_path not in shard_map:
+            shard_map[shard_path] = []
+        shard_map[shard_path].append(param_name)
+
+    # Load shards in parallel with a progress bar
+    with ThreadPoolExecutor() as executor:
+        futures = {
+            executor.submit(_load_shard, shard_path, param_names): shard_path for shard_path, param_names in shard_map.items()
+        }
+        pbar = tqdm(futures, desc="Loading shards", total=len(futures))
+        for future in pbar:
+            result = future.result()
+            state_dict.update(result)
+
+    return state_dict
+
+
+def unwrap_model(model):
+    return_list = True
+    if not isinstance(model, list):
+        model = [model]
+        return_list = False
+    unwrapped_model = []
+    for model_module in model:
+        while hasattr(model_module, "module"):
+            model_module = model_module.module
+        unwrapped_model.append(model_module)
+    if not return_list:
+        return unwrapped_model[0]
+    return unwrapped_model
+
+
+def _split_state_dict_for_pp(weight_dict: OrderedDict, model_config: ModelConfig):
+    num_layers = model_config.num_layers
+    partition = mpu.get_pp_world_size()
+
+    ## use partition and num_layers to get current rank layer order
+    layers_for_each_stage = np.array_split(range(num_layers), partition)
+    current_stage = mpu.get_pp_rank()
+    allow_layer_num = layers_for_each_stage[current_stage]
+    layer_offset = allow_layer_num[0]
+    new_weight_dict = {}
+    for k, v in weight_dict.items():
+        if "videodit_blocks.layers" in k:
+            layer_num = int(re.search(r"videodit_blocks\.layers\.(\d+)", k).group(1))
+            if layer_num not in allow_layer_num:
+                continue
+            ## replace the old key name by new layer number
+            new_layer_num = layer_num - layer_offset
+            new_k = k.replace(f"videodit_blocks.layers.{layer_num}", f"videodit_blocks.layers.{new_layer_num}")
+            new_weight_dict[new_k] = v
+        else:
+            new_weight_dict[k] = v
+    return new_weight_dict
+
+
+def load_state_dict(runtime_config: RuntimeConfig, engine_config: EngineConfig):
+    load_dir = runtime_config.load
+
+    default_subdir = "inference_weight"
+    if engine_config.fp8_quant:
+        default_subdir = f"{default_subdir}.fp8"
+    if engine_config.distill:
+        default_subdir = f"{default_subdir}.distill"
+    inference_weight_dir = os.path.join(load_dir, default_subdir)
+
+    print_rank_0(f"load {default_subdir} weight from {inference_weight_dir}")
+    assert (
+        os.path.exists(inference_weight_dir) and len(os.listdir(inference_weight_dir)) > 0
+    ), f"Ckpt directory {inference_weight_dir} does not exist or empty. If you are using fp8_quant, please run calibration first."
+    state_dict = load_sharded_safetensors_parallel_with_progress(inference_weight_dir)
+    return state_dict
+
+
+def load_checkpoint(model):
+    state_dict = load_state_dict(model.runtime_config, model.engine_config)
+
+    model = unwrap_model(model)
+    # if we use pipeline parallelism, we need to load the state dict for each stage
+    # as it always record layer from 0 -> num_layers//pipeline_parallel_size
+    # so we need to choose correct layer weight when load_state_dict
+    if mpu.get_pp_world_size() > 1:
+        state_dict = _split_state_dict_for_pp(state_dict, model.model_config)
+
+    missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False, assign=True)
+    model.cuda(torch.cuda.current_device())   # bottleneck for loading
+
+    if mpu.get_pp_world_size() > 1:
+        rank_msg = f"CP_rank={mpu.get_cp_rank()} PP_rank={mpu.get_pp_rank()}"
+        print_per_rank(
+            f"""[{rank_msg}] Load Weight Missing Keys: {missing_keys} Load Weight Unexpected Keys: {unexpected_keys} You should see message [missing fianl layer norm weight] except the final pipeline stage"""
+        )
+    else:
+        print_rank_0(f"Load Weight Missing Keys: {missing_keys}")
+        print_rank_0(f"Load Weight Unexpected Keys: {unexpected_keys}")
+
+    return model

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/distributed/__init__.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .dist_utils import dist_init, get_device, get_world_size, is_last_rank, is_last_tp_cp_rank
+from .parallel_state import (
+    destroy_model_parallel,
+    get_cp_group,
+    get_cp_rank,
+    get_cp_world_size,
+    get_dp_group,
+    get_dp_group_gloo,
+    get_dp_rank,
+    get_dp_world_size,
+    get_pipeline_model_parallel_first_rank,
+    get_pipeline_model_parallel_last_rank,
+    get_pipeline_model_parallel_next_rank,
+    get_pipeline_model_parallel_prev_rank,
+    get_pp_group,
+    get_pp_rank,
+    get_pp_world_size,
+    get_tensor_model_parallel_last_rank,
+    get_tensor_model_parallel_ranks,
+    get_tensor_model_parallel_src_rank,
+    get_tp_group,
+    get_tp_rank,
+    get_tp_world_size,
+    is_initialized,
+    is_pipeline_first_stage,
+    is_pipeline_last_stage,
+)
+
+__all__ = [
+    "dist_init",
+    "is_initialized",
+    "get_tp_group",
+    "get_pp_group",
+    "get_dp_group",
+    "get_dp_group_gloo",
+    "get_cp_group",
+    "get_tp_world_size",
+    "get_pp_world_size",
+    "get_dp_world_size",
+    "get_cp_world_size",
+    "get_tp_rank",
+    "get_pp_rank",
+    "get_dp_rank",
+    "get_cp_rank",
+    "is_pipeline_first_stage",
+    "is_pipeline_last_stage",
+    "get_tensor_model_parallel_src_rank",
+    "get_tensor_model_parallel_ranks",
+    "get_tensor_model_parallel_last_rank",
+    "get_pipeline_model_parallel_first_rank",
+    "get_pipeline_model_parallel_last_rank",
+    "get_pipeline_model_parallel_next_rank",
+    "get_pipeline_model_parallel_prev_rank",
+    "destroy_model_parallel",
+    "is_last_rank",
+    "is_last_tp_cp_rank",
+    "get_world_size",
+    "get_device",
+]

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/distributed/dist_utils.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+from datetime import timedelta
+
+import torch
+
+import inference.infra.distributed.parallel_state as mpu
+from inference.common import print_rank_0
+from inference.infra.parallelism.pipeline_parallel import init_pp_scheduler
+
+from . import parallel_state as mpu
+
+
+def dist_init(config):
+    """Initialize torch.distributed and core model parallel."""
+
+    assert torch.cuda.is_available()
+    device_count = torch.cuda.device_count()
+    if torch.distributed.is_initialized():
+        print_rank_0("Torch distribution already initialized, skipping initialization ...")
+    else:
+        rank = int(os.getenv("RANK", "0"))
+        world_size = int(os.getenv("WORLD_SIZE", "1"))
+        # Manually set the device ids.
+        if device_count > 0:
+            device = rank % device_count
+            torch.cuda.set_device(device)
+        # Call the init process
+        torch.distributed.init_process_group(
+            backend=config.engine_config.distributed_backend,
+            world_size=world_size,
+            rank=rank,
+            timeout=timedelta(minutes=config.engine_config.distributed_timeout_minutes),
+        )
+    assert config.engine_config.cp_size * config.engine_config.pp_size == torch.distributed.get_world_size()
+    if device_count > 0:
+        if mpu.model_parallel_is_initialized():
+            print_rank_0("Model parallel is already initialized")
+        else:
+            mpu.initialize_model_parallel(
+                cp_size=config.engine_config.cp_size,
+                pp_size=config.engine_config.pp_size,
+                nccl_communicator_config_path=None,
+                distributed_timeout_minutes=config.engine_config.distributed_timeout_minutes,
+                order="tp-cp-pp-dp",
+            )
+    if mpu.get_pp_world_size() > 1:
+        init_pp_scheduler()
+    print_rank_0("Initialize torch distribution and model parallel successfully")
+
+
+def is_last_rank():
+    return torch.distributed.get_rank() == (torch.distributed.get_world_size() - 1)
+
+
+def is_last_tp_cp_rank():
+    return mpu.get_tp_rank(with_context_parallel=True) == mpu.get_tp_world_size(with_context_parallel=True) - 1
+
+
+def get_world_size():
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        world_size = torch.distributed.get_world_size()
+    else:
+        world_size = 1
+    return world_size
+
+
+def get_device(local_rank=None):
+    backend = torch.distributed.get_backend()
+    if backend == "nccl":
+        if local_rank is None:
+            device = torch.device("cuda")
+        else:
+            device = torch.device(f"cuda:{local_rank}")
+    elif backend == "gloo":
+        device = torch.device("cpu")
+    else:
+        raise RuntimeError
+    return device

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/distributed/parallel_state.py

@@ -0,0 +1,672 @@
+# Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Model and data parallel groups."""
+
+import warnings
+from datetime import timedelta
+from typing import List, Optional
+
+import torch
+
+# Intra-layer model parallel group that the current rank belongs to.
+_TENSOR_MODEL_PARALLEL_GROUP = None
+# Tensor parallel group information with context parallel combined.
+_TENSOR_MODEL_PARALLEL_GROUP_WITH_CP = None
+_TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP = None
+# Inter-layer model parallel group that the current rank belongs to.
+_PIPELINE_MODEL_PARALLEL_GROUP = None
+# Model parallel group (both intra- and pipeline) that the current rank belongs to.
+_MODEL_PARALLEL_GROUP = None
+# Data parallel group that the current rank belongs to.
+_DATA_PARALLEL_GROUP = None
+_DATA_PARALLEL_GROUP_GLOO = None
+# tensor model parallel group and data parallel group combined
+# used for fp8 and moe training
+_TENSOR_AND_DATA_PARALLEL_GROUP = None
+
+# A list of global ranks for each pipeline group to ease calculation of the source
+# rank when broadcasting from the first or last pipeline stage.
+_PIPELINE_GLOBAL_RANKS = None
+
+# A list of global ranks for each data parallel group to ease calculation of the source
+# rank when broadcasting weights from src to all other data parallel ranks
+_DATA_PARALLEL_GLOBAL_RANKS = None
+
+# A list of global ranks for each tensor model parallel group to ease calculation of
+# the first local rank in the tensor model parallel group
+_TENSOR_MODEL_PARALLEL_GLOBAL_RANKS = None
+
+# Context parallel group that the current rank belongs to
+_CONTEXT_PARALLEL_GROUP = None
+# A list of global ranks for each context parallel group to ease calculation of the
+# destination rank when exchanging KV/dKV between context parallel_ranks
+_CONTEXT_PARALLEL_GLOBAL_RANKS = None
+
+# Data parallel group information with context parallel combined.
+_DATA_PARALLEL_GROUP_WITH_CP = None
+_DATA_PARALLEL_GROUP_WITH_CP_GLOO = None
+_DATA_PARALLEL_GLOBAL_RANKS_WITH_CP = None
+
+# combined parallel group of TP, DP, and CP used for fp8
+_TENSOR_AND_DATA_PARALLEL_GROUP_WITH_CP = None
+
+
+def get_nccl_options(pg_name, nccl_comm_cfgs):
+    """Set the NCCL process group options.
+
+    Args:
+        pg_name (str): process group name
+        nccl_comm_cfgs (dict): nccl communicator configurations
+
+    When an option (e.g., max_ctas) is not found in the config, use the NCCL default setting.
+    """
+    if pg_name in nccl_comm_cfgs:
+        nccl_options = torch.distributed.ProcessGroupNCCL.Options()
+        nccl_options.config.cga_cluster_size = nccl_comm_cfgs[pg_name].get("cga_cluster_size", 4)
+        nccl_options.config.max_ctas = nccl_comm_cfgs[pg_name].get("max_ctas", 32)
+        nccl_options.config.min_ctas = nccl_comm_cfgs[pg_name].get("min_ctas", 1)
+        return nccl_options
+    else:
+        return None
+
+
+def generate_masked_orthogonal_rank_groups(world_size: int, parallel_size: List[int], mask: List[bool]) -> List[List[int]]:
+    """Generate orthogonal parallel groups based on the parallel size and mask.
+
+    Arguments:
+        world_size (int): world size
+
+        parallel_size (List[int]):
+            The parallel size of each orthogonal parallel type. For example, if
+            tensor_parallel_size = 2, pipeline_model_parallel_group = 3, data_parallel_size = 4,
+            and the parallel mapping order is tp-pp-dp, then the parallel_size = [2, 3, 4].
+
+        mask (List[bool]):
+            The mask controls which parallel methods the generated groups represent. If mask[i] is
+            True, it means the generated group contains the i-th parallelism method. For example,
+            if parallel_size = [tp_size, pp_size, dp_size], and mask = [True, False , True], then
+            the generated group is the `tp-dp` group, if the mask = [False, True, False], then the
+            generated group is the `pp` group.
+
+    Algorithm:
+        For orthogonal parallelism, such as tp/dp/pp/cp, the global_rank and
+        local_rank satisfy the following equation:
+            global_rank = tp_rank + dp_rank * tp_size + pp_rank * tp_size * dp_size (1)
+                tp_rank \in [0, tp_size)
+                dp_rank \in [0, dp_size)
+                pp_rank \in [0, pp_size)
+
+        If we want to get the `dp_group` (tp_size * pp_size groups of dp_size ranks each.
+        For example,  if the gpu size is 8 and order is 'tp-pp-dp', size is '2-2-2', and the
+        dp_group here is [[0, 4], [1, 5], [2, 6], [3, 7]].)
+        The tp_rank and pp_rank will be combined to form the `dp_group_index`.
+            dp_group_index = tp_rank + pp_rank * tp_size (2)
+
+        So, Given that tp_rank and pp_rank satisfy equation (2), and dp_rank in
+        range(0, dp_size), the ranks in dp_group[dp_group_index] satisfies the
+        equation (1).
+
+        This function solve this math problem.
+
+    For example, if the parallel_size = [tp_size, dp_size, pp_size] = [2, 3, 4],
+    and the mask = [False, True, False]. Then,
+        dp_group_index(0) = tp_rank(0) + pp_rank(0) * 2
+        dp_group_index(1) = tp_rank(1) + pp_rank(0) * 2
+        ...
+        dp_group_index(7) = tp_rank(1) + pp_rank(3) * 2
+
+        dp_group[0] = 0 + range(0, 3) * 2 + 0 = [0, 2, 4]
+        dp_group[1] = 1 + range(0, 3) * 2 + 0 = [1, 3, 5]
+        ...
+        dp_group[7] = 1 + range(0, 3) * 2 + 3 * 2 * 3 = [19, 21, 23]
+    """
+
+    def prefix_product(a: List[int], init=1) -> List[int]:
+        r = [init]
+        for v in a:
+            init = init * v
+            r.append(init)
+        return r
+
+    def inner_product(a: List[int], b: List[int]) -> int:
+        return sum([x * y for x, y in zip(a, b)])
+
+    def decompose(index, shape, stride=None):
+        """
+        This function solve the math problem below:
+            There is an equation:
+                index = sum(idx[i] * stride[i])
+            And given the value of index, stride.
+            Return the idx.
+        This function will used to get the pp/dp/pp_rank
+        from group_index and rank_in_group.
+        """
+        if stride is None:
+            stride = prefix_product(shape)
+        idx = [(index // d) % s for s, d in zip(shape, stride)]
+        # stride is a prefix_product result. And the value of stride[-1]
+        # is not used.
+        assert (
+            sum([x * y for x, y in zip(idx, stride[:-1])]) == index
+        ), "idx {} with shape {} mismatch the return idx {}".format(index, shape, idx)
+        return idx
+
+    masked_shape = [s for s, m in zip(parallel_size, mask) if m]
+    unmasked_shape = [s for s, m in zip(parallel_size, mask) if not m]
+
+    global_stride = prefix_product(parallel_size)
+    masked_stride = [d for d, m in zip(global_stride, mask) if m]
+    unmasked_stride = [d for d, m in zip(global_stride, mask) if not m]
+
+    group_size = prefix_product(masked_shape)[-1]
+    num_of_group = world_size // group_size
+
+    ranks = []
+    for group_index in range(num_of_group):
+        # get indices from unmaksed for group_index.
+        decomposed_group_idx = decompose(group_index, unmasked_shape)
+        rank = []
+        for rank_in_group in range(group_size):
+            # get indices from masked for rank_in_group.
+            decomposed_rank_idx = decompose(rank_in_group, masked_shape)
+            rank.append(
+                inner_product(decomposed_rank_idx, masked_stride) + inner_product(decomposed_group_idx, unmasked_stride)
+            )
+        ranks.append(rank)
+    return ranks
+
+
+class RankGenerator(object):
+    def __init__(self, tp: int, dp: int, pp: int, cp: int, order: str) -> None:
+        self.tp = tp
+        self.dp = dp
+        self.pp = pp
+        self.cp = cp
+        self.world_size = tp * dp * pp * cp
+
+        self.name_to_size = {"tp": self.tp, "pp": self.pp, "dp": self.dp, "cp": self.cp}
+        order = order.lower()
+        for name in self.name_to_size.keys():
+            if name not in order and self.name_to_size[name] != 1:
+                raise RuntimeError(
+                    f"The size of ({name}) is ({self.name_to_size[name]}), but you haven't specified the order ({self.order})."
+                )
+            elif name not in order:
+                order = order + "-" + name
+
+        self.order = order
+        self.ordered_size = [self.name_to_size[token] for token in order.split("-")]
+
+    def get_mask(self, order: str, token: str):
+        ordered_token = order.split("-")
+        token = token.split("-")
+        mask = [False] * len(ordered_token)
+        for t in token:
+            mask[ordered_token.index(t)] = True
+        return mask
+
+    def get_ranks(self, token):
+        """Get rank group by input token.
+
+        Arguments:
+            token (str):
+                Specify the ranks type that want to get. If we want
+                to obtain multiple parallel types, we can use a hyphen
+                '-' to separate them. For example, if we want to obtain
+                the TP_DP group, the token should be 'tp-dp'.
+        """
+        mask = self.get_mask(self.order, token)
+        ranks = generate_masked_orthogonal_rank_groups(self.world_size, self.ordered_size, mask)
+        return ranks
+
+
+def initialize_model_parallel(
+    tp_size: int = 1,
+    pp_size: int = 1,
+    cp_size: int = 1,
+    nccl_communicator_config_path: Optional[str] = None,
+    distributed_timeout_minutes: int = 30,
+    order: str = "tp-cp-pp-dp",
+) -> None:
+    """Initialize model data parallel groups.
+    Borrow from: https://github.com/NVIDIA/Megatron-LM/blob/main/megatron/core/parallel_state.py
+
+    Args:
+        tp_size (int, default = 1):
+            The number of GPUs to split individual tensors across.
+
+        pp_size (int, default = 1):
+            The number of tensor parallel GPU groups to split the
+            Transformer layers across. For example, if tp_size is 4 and
+            pp_size is 2, the model will be split into 2 groups of 4 GPUs.
+
+        cp_size (int, default = 1):
+            The number of tensor parallel GPU groups to split the
+            network input sequence length across. Compute of attention
+            module requires tokens of full sequence length, so GPUs
+            in a context parallel group need to communicate with each
+            other to exchange information of other sequence chunks.
+            Each GPU and its counterparts in other tensor parallel
+            groups compose a context parallel group.
+
+            For example, assume we have 8 GPUs, if tensor model parallel
+            size is 4 and context parallel size is 2, the network input
+            will be split into two sequence chunks, which are processed
+            by 2 different groups of 4 GPUs. One chunk is processed by
+            GPU0-3, the other chunk is processed by GPU4-7. Four groups
+            are build to do context parallel communications: [GPU0, GPU4],
+            [GPU1, GPU5], [GPU2, GPU6], and [GPU3, GPU7].
+
+            Context parallelism partitions sequence length, so it has no
+            impact on weights, which means weights are duplicated among
+            GPUs in a context parallel group. Hence, weight gradients
+            all-reduce is required in backward. For simplicity, we piggyback
+            GPUs of context parallelism on data parallel group for
+            weight gradient all-reduce.
+
+        nccl_communicator_config_path (str, default = None):
+            Path to the yaml file of NCCL communicator configurations.
+            `min_ctas`, `max_ctas`, and `cga_cluster_size` can be set
+            for each communicator.
+
+        distributed_timeout_minutes (int, default = 30): Timeout, in
+            minutes,for operations executed against distributed
+            process groups. See PyTorch documentation at
+            https://pytorch.org/docs/stable/distributed.html for
+            caveats.
+
+        order (str, default=tp-dp-pp):
+            The rank initialization order of parallelism. Now we support
+            tp-dp-pp and tp-pp-dp orders.
+
+    Let's say we have a total of 16 GPUs denoted by g0 ... g15 and we
+    use 2 GPUs to parallelize the model tensor, and 4 GPUs to parallelize
+    the model pipeline. The present function will
+    create 8 tensor model-parallel groups, 4 pipeline model-parallel groups
+    and 8 data-parallel groups as:
+        8 data_parallel groups:
+            [g0, g2], [g1, g3], [g4, g6], [g5, g7], [g8, g10], [g9, g11], [g12, g14], [g13, g15]
+        8 tensor model-parallel groups:
+            [g0, g1], [g2, g3], [g4, g5], [g6, g7], [g8, g9], [g10, g11], [g12, g13], [g14, g15]
+        4 pipeline model-parallel groups:
+            [g0, g4, g8, g12], [g1, g5, g9, g13], [g2, g6, g10, g14], [g3, g7, g11, g15]
+    Note that for efficiency, the caller should make sure adjacent ranks
+    are on the same DGX box. For example if we are using 2 DGX-1 boxes
+    with a total of 16 GPUs, rank 0 to 7 belong to the first box and
+    ranks 8 to 15 belong to the second box.
+
+    """
+    # Get world size and rank. Ensure some consistencies.
+    assert torch.distributed.is_initialized()
+    world_size: int = torch.distributed.get_world_size()
+    if world_size % (tp_size * pp_size * cp_size) != 0:
+        raise RuntimeError(
+            f"world_size ({world_size}) is not divisible by tp_size "
+            f"({tp_size}) x pp_size ({pp_size}) "
+            f"x cp_size ({cp_size})"
+        )
+
+    nccl_comm_cfgs = {}
+    if nccl_communicator_config_path is not None:
+        try:
+            import yaml
+        except ImportError:
+            raise RuntimeError("Cannot import `yaml`. Setting custom nccl communicator configs " "requires the yaml package.")
+
+        with open(nccl_communicator_config_path, "r") as stream:
+            nccl_comm_cfgs = yaml.safe_load(stream)
+
+    dp_size: int = world_size // (tp_size * pp_size * cp_size)
+    rank = torch.distributed.get_rank()
+    rank_generator = RankGenerator(tp=tp_size, dp=dp_size, pp=pp_size, cp=cp_size, order=order)
+    timeout = timedelta(minutes=distributed_timeout_minutes)
+
+    # Build the data-parallel groups.
+    global _DATA_PARALLEL_GROUP
+    global _DATA_PARALLEL_GROUP_GLOO
+    global _DATA_PARALLEL_GLOBAL_RANKS
+    global _DATA_PARALLEL_GROUP_WITH_CP
+    global _DATA_PARALLEL_GROUP_WITH_CP_GLOO
+    global _DATA_PARALLEL_GLOBAL_RANKS_WITH_CP
+    assert _DATA_PARALLEL_GROUP is None, "data parallel group is already initialized"
+
+    for ranks in rank_generator.get_ranks("dp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("dp", nccl_comm_cfgs))
+        group_gloo = torch.distributed.new_group(ranks, timeout=timeout, backend="gloo")
+        if rank in ranks:
+            _DATA_PARALLEL_GROUP = group
+            _DATA_PARALLEL_GROUP_GLOO = group_gloo
+            _DATA_PARALLEL_GLOBAL_RANKS = ranks
+    for ranks_with_cp in rank_generator.get_ranks("dp-cp"):
+        group_with_cp = torch.distributed.new_group(
+            ranks_with_cp, timeout=timeout, pg_options=get_nccl_options("dp_cp", nccl_comm_cfgs)
+        )
+        group_with_cp_gloo = torch.distributed.new_group(ranks_with_cp, timeout=timeout, backend="gloo")
+        if rank in ranks_with_cp:
+            _DATA_PARALLEL_GROUP_WITH_CP = group_with_cp
+            _DATA_PARALLEL_GROUP_WITH_CP_GLOO = group_with_cp_gloo
+            _DATA_PARALLEL_GLOBAL_RANKS_WITH_CP = ranks_with_cp
+
+    # Build the context-parallel groups.
+    global _CONTEXT_PARALLEL_GROUP
+    global _CONTEXT_PARALLEL_GLOBAL_RANKS
+    assert _CONTEXT_PARALLEL_GROUP is None, "context parallel group is already initialized"
+    for ranks in rank_generator.get_ranks("cp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("cp", nccl_comm_cfgs))
+        if rank in ranks:
+            _CONTEXT_PARALLEL_GROUP = group
+            _CONTEXT_PARALLEL_GLOBAL_RANKS = ranks
+
+    # Build the model-parallel groups.
+    global _MODEL_PARALLEL_GROUP
+    assert _MODEL_PARALLEL_GROUP is None, "model parallel group is already initialized"
+    for ranks in rank_generator.get_ranks("tp-pp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("mp", nccl_comm_cfgs))
+        if rank in ranks:
+            _MODEL_PARALLEL_GROUP = group
+
+    # Build the tensor model-parallel groups.
+    global _TENSOR_MODEL_PARALLEL_GROUP
+    global _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS
+    assert _TENSOR_MODEL_PARALLEL_GROUP is None, "tensor model parallel group is already initialized"
+    for ranks in rank_generator.get_ranks("tp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("tp", nccl_comm_cfgs))
+        if rank in ranks:
+            _TENSOR_MODEL_PARALLEL_GROUP = group
+            _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS = ranks
+
+    # Build the tensor + context parallel groups.
+    global _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP
+    global _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP
+    assert (
+        _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP is None
+    ), "tensor model parallel group with context parallel is already initialized"
+    for ranks in rank_generator.get_ranks("tp-cp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("tp_cp", nccl_comm_cfgs))
+        if rank in ranks:
+            _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP = group
+            _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP = ranks
+
+    # Build the pipeline model-parallel groups
+    global _PIPELINE_MODEL_PARALLEL_GROUP
+    global _PIPELINE_GLOBAL_RANKS
+    assert _PIPELINE_MODEL_PARALLEL_GROUP is None, "pipeline model parallel group is already initialized"
+    for ranks in rank_generator.get_ranks("pp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("pp", nccl_comm_cfgs))
+        if rank in ranks:
+            _PIPELINE_MODEL_PARALLEL_GROUP = group
+            _PIPELINE_GLOBAL_RANKS = ranks
+
+    # Build the tensor + data parallel groups.
+    global _TENSOR_AND_DATA_PARALLEL_GROUP
+    global _TENSOR_AND_DATA_PARALLEL_GROUP_WITH_CP
+    assert _TENSOR_AND_DATA_PARALLEL_GROUP is None, "Tensor + data parallel group is already initialized"
+    for ranks in rank_generator.get_ranks("tp-cp-dp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("tp_cp_dp", nccl_comm_cfgs))
+        if rank in ranks:
+            _TENSOR_AND_DATA_PARALLEL_GROUP_WITH_CP = group
+    for ranks in rank_generator.get_ranks("tp-dp"):
+        group = torch.distributed.new_group(ranks, timeout=timeout, pg_options=get_nccl_options("tp_dp", nccl_comm_cfgs))
+        if rank in ranks:
+            _TENSOR_AND_DATA_PARALLEL_GROUP = group
+
+
+def is_initialized():
+    """Useful for code segments that may be accessed with or without mpu initialization"""
+    return _DATA_PARALLEL_GROUP is not None
+
+
+def is_unitialized() -> bool:
+    """Check if parallel state has been initialized
+
+    Deprecated. Use is_initialized instead.
+
+    """
+    warnings.warn("is_unitialized is deprecated, use is_initialized instead", DeprecationWarning)
+    return not is_initialized()
+
+
+def model_parallel_is_initialized():
+    """Check if model and data parallel groups are initialized."""
+    if _TENSOR_MODEL_PARALLEL_GROUP is None or _PIPELINE_MODEL_PARALLEL_GROUP is None or _DATA_PARALLEL_GROUP is None:
+        return False
+    return True
+
+
+def get_model_parallel_group():
+    """Get the model parallel group the caller rank belongs to."""
+    assert _MODEL_PARALLEL_GROUP is not None, "model parallel group is not initialized"
+    return _MODEL_PARALLEL_GROUP
+
+
+def get_tp_group(check_initialized=True, with_context_parallel=False):
+    """Get the tensor model parallel group the caller rank belongs to."""
+    if check_initialized:
+        assert _TENSOR_MODEL_PARALLEL_GROUP is not None, "tensor model parallel group is not initialized"
+    if with_context_parallel:
+        assert (
+            _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP is not None
+        ), "tensor model parallel group with context parallel combined is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP
+    else:
+        assert _TENSOR_MODEL_PARALLEL_GROUP is not None, "tensor model parallel group is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GROUP
+
+
+def get_pp_group():
+    """Get the pipeline model parallel group the caller rank belongs to."""
+    assert _PIPELINE_MODEL_PARALLEL_GROUP is not None, "pipeline_model parallel group is not initialized"
+    return _PIPELINE_MODEL_PARALLEL_GROUP
+
+
+def get_dp_group(with_context_parallel=False):
+    """Get the data parallel group the caller rank belongs to."""
+    if with_context_parallel:
+        assert (
+            _DATA_PARALLEL_GROUP_WITH_CP is not None
+        ), "data parallel group with context parallel combined is not initialized"
+        return _DATA_PARALLEL_GROUP_WITH_CP
+    else:
+        assert _DATA_PARALLEL_GROUP is not None, "data parallel group is not initialized"
+        return _DATA_PARALLEL_GROUP
+
+
+def get_dp_group_gloo(with_context_parallel=False):
+    """Get the data parallel group-gloo the caller rank belongs to."""
+    if with_context_parallel:
+        assert (
+            _DATA_PARALLEL_GROUP_WITH_CP_GLOO is not None
+        ), "data parallel group-gloo with context parallel combined is not initialized"
+        return _DATA_PARALLEL_GROUP_WITH_CP_GLOO
+    else:
+        assert _DATA_PARALLEL_GROUP_GLOO is not None, "data parallel group-gloo is not initialized"
+        return _DATA_PARALLEL_GROUP_GLOO
+
+
+def get_cp_group(check_initialized=True):
+    """Get the context parallel group the caller rank belongs to."""
+    if check_initialized:
+        assert _CONTEXT_PARALLEL_GROUP is not None, "context parallel group is not initialized"
+    return _CONTEXT_PARALLEL_GROUP
+
+
+def get_tp_world_size(with_context_parallel=False):
+    """Return world size for the tensor model parallel group."""
+    return torch.distributed.get_world_size(group=get_tp_group(with_context_parallel=with_context_parallel))
+
+
+def get_pp_world_size():
+    """Return world size for the pipeline model parallel group."""
+    return torch.distributed.get_world_size(group=get_pp_group())
+
+
+def get_tp_rank(with_context_parallel=False):
+    """Return my rank for the tensor model parallel group."""
+    return torch.distributed.get_rank(group=get_tp_group(with_context_parallel=with_context_parallel))
+
+
+def get_pp_rank():
+    """Return my rank for the pipeline model parallel group."""
+    return torch.distributed.get_rank(group=get_pp_group())
+
+
+def is_pipeline_first_stage():
+    """Return True if in the first pipeline model-parallel stage, False otherwise."""
+    return get_pp_rank() == 0
+
+
+def is_pipeline_last_stage():
+    """Return True if in the last pipeline model-parallel stage, False otherwise."""
+    return get_pp_rank() == (get_pp_world_size() - 1)
+
+
+def get_tensor_model_parallel_src_rank(with_context_parallel=False):
+    """Calculate the global rank corresponding to the first local rank
+    in the tensor model parallel group."""
+    assert _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS is not None, "Tensor model parallel group is not initialized"
+    if with_context_parallel:
+        assert (
+            _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP is not None
+        ), "Tensor model parallel group with context parallel combined is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP[0]
+    else:
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS[0]
+
+
+def get_tensor_model_parallel_ranks(with_context_parallel=False):
+    """Return all global ranks for the tensor model parallel group."""
+    if with_context_parallel:
+        assert (
+            _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP is not None
+        ), "Tensor model parallel group with context parallel combined is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP
+    else:
+        assert _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS is not None, "Tensor model parallel group is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS
+
+
+def get_tensor_model_parallel_last_rank(with_context_parallel=False):
+    """Calculate the global rank corresponding to the first local rank
+    in the tensor model parallel group."""
+    assert _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS is not None, "Tensor model parallel group is not initialized"
+    if with_context_parallel:
+        assert (
+            _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP is not None
+        ), "Tensor model parallel group with context parallel combined is not initialized"
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP[-1]
+    else:
+        return _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS[-1]
+
+
+def get_pipeline_model_parallel_first_rank():
+    """Return the global rank of the first process in the pipeline for the
+    current tensor parallel group"""
+    assert _PIPELINE_GLOBAL_RANKS is not None, "Pipeline parallel group is not initialized"
+    return _PIPELINE_GLOBAL_RANKS[0]
+
+
+def get_pipeline_model_parallel_last_rank():
+    """Return the global rank of the last process in the pipeline for the
+    current tensor parallel group"""
+    assert _PIPELINE_GLOBAL_RANKS is not None, "Pipeline parallel group is not initialized"
+    last_rank_local = get_pp_world_size() - 1
+    return _PIPELINE_GLOBAL_RANKS[last_rank_local]
+
+
+def get_pipeline_model_parallel_next_rank():
+    """Return the global rank that follows the caller in the pipeline"""
+    assert _PIPELINE_GLOBAL_RANKS is not None, "Pipeline parallel group is not initialized"
+    rank_in_pipeline = get_pp_rank()
+    world_size = get_pp_world_size()
+    return _PIPELINE_GLOBAL_RANKS[(rank_in_pipeline + 1) % world_size]
+
+
+def get_pipeline_model_parallel_prev_rank():
+    """Return the global rank that preceeds the caller in the pipeline"""
+    assert _PIPELINE_GLOBAL_RANKS is not None, "Pipeline parallel group is not initialized"
+    rank_in_pipeline = get_pp_rank()
+    world_size = get_pp_world_size()
+    return _PIPELINE_GLOBAL_RANKS[(rank_in_pipeline - 1) % world_size]
+
+
+def get_dp_world_size(with_context_parallel=False):
+    """Return world size for the data parallel group."""
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        return torch.distributed.get_world_size(group=get_dp_group(with_context_parallel=with_context_parallel))
+    else:
+        return 0
+
+
+def get_dp_rank(with_context_parallel=False):
+    """Return my rank for the data parallel group."""
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        return torch.distributed.get_rank(group=get_dp_group(with_context_parallel=with_context_parallel))
+    else:
+        return 0
+
+
+def get_cp_world_size():
+    """Return world size for the context parallel group."""
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        return torch.distributed.get_world_size(group=get_cp_group())
+    else:
+        return 0
+
+
+def get_cp_rank():
+    """Return my rank for the context parallel group."""
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        return torch.distributed.get_rank(group=get_cp_group())
+    else:
+        return 0
+
+
+def destroy_model_parallel():
+    """Set the groups to none."""
+    global _MODEL_PARALLEL_GROUP
+    _MODEL_PARALLEL_GROUP = None
+    global _TENSOR_MODEL_PARALLEL_GROUP
+    _TENSOR_MODEL_PARALLEL_GROUP = None
+    global _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP
+    _TENSOR_MODEL_PARALLEL_GROUP_WITH_CP = None
+    global _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP
+    _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS_WITH_CP = None
+    global _PIPELINE_MODEL_PARALLEL_GROUP
+    _PIPELINE_MODEL_PARALLEL_GROUP = None
+    global _DATA_PARALLEL_GROUP
+    _DATA_PARALLEL_GROUP = None
+    global _DATA_PARALLEL_GROUP_GLOO
+    _DATA_PARALLEL_GROUP_GLOO = None
+    global _TENSOR_AND_DATA_PARALLEL_GROUP
+    _TENSOR_AND_DATA_PARALLEL_GROUP = None
+    global _PIPELINE_GLOBAL_RANKS
+    _PIPELINE_GLOBAL_RANKS = None
+    global _DATA_PARALLEL_GLOBAL_RANKS
+    _DATA_PARALLEL_GLOBAL_RANKS = None
+    global _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS
+    _TENSOR_MODEL_PARALLEL_GLOBAL_RANKS = None
+    global _CONTEXT_PARALLEL_GROUP
+    _CONTEXT_PARALLEL_GROUP = None
+    global _CONTEXT_PARALLEL_GLOBAL_RANKS
+    _CONTEXT_PARALLEL_GLOBAL_RANKS = None
+    global _DATA_PARALLEL_GROUP_WITH_CP
+    _DATA_PARALLEL_GROUP_WITH_CP = None
+    global _DATA_PARALLEL_GROUP_WITH_CP_GLOO
+    _DATA_PARALLEL_GROUP_WITH_CP_GLOO = None
+    global _DATA_PARALLEL_GLOBAL_RANKS_WITH_CP
+    _DATA_PARALLEL_GLOBAL_RANKS_WITH_CP = None
+    global _TENSOR_AND_DATA_PARALLEL_GROUP_WITH_CP
+    _TENSOR_AND_DATA_PARALLEL_GROUP_WITH_CP = None

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/parallelism/__init__.py

@@ -0,0 +1,27 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .context_parallel import CSOHelper, UlyssesScheduler, cp_post_process, cp_pre_process, cso_communication
+from .pipeline_parallel import pp_scheduler
+from .tile_parallel import TileProcessor
+
+__all__ = [
+    "CSOHelper",
+    "cso_communication",
+    "UlyssesScheduler",
+    "pp_scheduler",
+    "TileProcessor",
+    "cp_pre_process",
+    "cp_post_process",
+]

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/parallelism/context_parallel.py

@@ -0,0 +1,673 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from typing import Callable, List, Tuple, Union
+
+import torch
+import torch.distributed
+from einops import rearrange
+
+from inference.common import ModelMetaArgs, PackedCoreAttnParams, PackedCrossAttnParams, divide
+from inference.infra.distributed import parallel_state as mpu
+
+
+#####################################################
+# Common Primitives
+#####################################################
+def scatter_to_context_parallel_region(input_, cp_split_sizes, cp_shuffle_num=1, cp_pad_size=0):
+    """Split the tensor along its first dimension and keep the
+    corresponding slice."""
+
+    world_size = mpu.get_cp_world_size()
+    # Bypass the function if we are using only 1 GPU.
+    if world_size == 1:
+        return input_
+
+    # Split along first dimension with padding.
+    rank = mpu.get_cp_rank()
+    if cp_shuffle_num > 1:
+        cp_pad_size = divide(cp_pad_size, cp_shuffle_num)
+        cp_split_sizes = [divide(s, cp_shuffle_num) for s in cp_split_sizes]
+        dim_offset = sum(cp_split_sizes[:rank])
+        xs = []
+        for x in torch.chunk(input_, cp_shuffle_num, dim=0):
+            x = torch.nn.functional.pad(x, [0, 0] * (x.dim() - 1) + [0, cp_pad_size], mode="constant", value=0)
+            xs.append(x[dim_offset : dim_offset + cp_split_sizes[rank]])
+        output = torch.concat(xs, dim=0)
+    else:
+        dim_offset = sum(cp_split_sizes[:rank])
+        x = torch.nn.functional.pad(input_, [0, 0] * (input_.dim() - 1) + [0, cp_pad_size], mode="constant", value=0)
+        output = x[dim_offset : dim_offset + cp_split_sizes[rank]].contiguous()
+    return output
+
+
+def gather_from_context_parallel_region(input_, cp_split_sizes, cp_shuffle_num=1, cp_pad_size=0):
+    """Gather tensors and concatinate along the first dimension."""
+
+    world_size = mpu.get_cp_world_size()
+    # Bypass the function if we are using only 1 GPU.
+    if world_size == 1:
+        return input_
+
+    input_ = input_.contiguous()
+    total_seq_len = sum(cp_split_sizes)
+    dim_size = list(input_.size())
+    dim_size[0] = total_seq_len
+
+    output = torch.empty(dim_size, dtype=input_.dtype, device=input_.device)
+    outputs = list(torch.split(output, cp_split_sizes, dim=0))
+    torch.distributed.all_gather(outputs, input_, group=mpu.get_cp_group())
+    if cp_shuffle_num > 1:
+        total_seq_len = divide(total_seq_len, cp_shuffle_num)
+        cp_pad_size = divide(cp_pad_size, cp_shuffle_num)
+        chunks = [torch.chunk(o, cp_shuffle_num, dim=0) for o in outputs]
+        output = torch.concat(
+            [
+                torch.concat([chunk[i] for chunk in chunks], dim=0)[: total_seq_len - cp_pad_size]
+                for i in range(cp_shuffle_num)
+            ],
+            dim=0,
+        )
+    else:
+        output = torch.concat(outputs, dim=0)[: total_seq_len - cp_pad_size]
+
+    return output
+
+
+class FakeHandle:
+    def __init__(self):
+        pass
+
+    def wait(self):
+        pass
+
+
+#####################################################
+# Context Parallel Process
+#####################################################
+def update_packed_seq_params_for_cuda_graph(cross_attn_params: PackedCrossAttnParams, xattn_mask: torch.Tensor):
+    assert xattn_mask is not None
+    # xattn_mask: (N * denoising_range_num, L, 1, 1)
+    xattn_mask = xattn_mask.reshape(xattn_mask.shape[0], -1)
+    batch_size, static_caption_length = xattn_mask.shape
+
+    # Get index_map for kv_range injection, map y_index to static_caption_length
+    y_index = torch.sum(xattn_mask, dim=-1)
+    cu_seqlens_k = torch.cat([y_index.new_tensor([0]), y_index]).to(torch.int32).to(xattn_mask.device)
+    cu_seqlens_k = cu_seqlens_k.cumsum(-1).to(torch.int32)
+    static_cu_seqlens_k = torch.arange(0, (batch_size + 1) * static_caption_length, static_caption_length)
+    assert cu_seqlens_k.shape[0] == batch_size + 1 == static_cu_seqlens_k.shape[0]
+    start_index_map = dict(zip(cu_seqlens_k.flatten().tolist(), static_cu_seqlens_k.flatten().tolist()))
+
+    # Move kv_range to the right position
+    kv_range_start_list = cross_attn_params.kv_ranges[:, 0].flatten().tolist()
+    static_kv_range_start = [start_index_map[kv_range_start_list[i]] for i in range(len(kv_range_start_list))]
+    static_kv_range_start = torch.tensor(static_kv_range_start, dtype=torch.int32, device=xattn_mask.device)
+    assert static_kv_range_start.shape[0] == cross_attn_params.kv_ranges.shape[0]
+    static_kv_range_diff = cross_attn_params.kv_ranges[:, 1] - cross_attn_params.kv_ranges[:, 0]
+    static_kv_range_end = static_kv_range_start + static_kv_range_diff
+    static_kv_range = torch.stack((static_kv_range_start, static_kv_range_end), dim=1)
+
+    assert static_kv_range.shape == cross_attn_params.kv_ranges.shape
+    return PackedCrossAttnParams(
+        q_ranges=cross_attn_params.q_ranges,
+        kv_ranges=static_kv_range,
+        cu_seqlens_q=cross_attn_params.cu_seqlens_q,
+        cu_seqlens_kv=cross_attn_params.cu_seqlens_kv,
+        max_seqlen_q=cross_attn_params.max_seqlen_q,
+        max_seqlen_kv=cross_attn_params.max_seqlen_kv,
+    )
+
+
+def cp_update_cross_attn_qkv_range(
+    cross_attn_params: PackedCrossAttnParams,
+    batch_size: int,
+    cp_split_sizes: List[int],
+    device: torch.device,
+    cp_shuffle_num: int = 1,
+    cp_pad_size: int = 0,
+):
+    """
+    Update cross_attn_params for cross_attn in context parallel.
+
+    Input:
+        cross_attn_params: PackedCrossAttnParams. Packed sequence parameters for cross_atten
+        batch_size: int. Batch size
+        cp_split_sizes: List[int]. Split sizes for each rank
+        device: torch.device. Device
+
+    Output:
+        cross_attn_params: PackedCrossAttnParams. Updated packed parameters for cross_atten
+    """
+    # Update cu_seqlens_q and max_seqlen_q because split x maybe unbalanced
+    cp_rank = mpu.get_cp_rank()
+    seq_len_cur_rank = cp_split_sizes[cp_rank]
+    cp_split_sizes = [divide(x, cp_shuffle_num) for x in cp_split_sizes]
+    cp_split_sizes = torch.tensor(cp_split_sizes, dtype=torch.int32, device=device)
+    base_cp_boundaries = torch.cat((torch.zeros(1, dtype=torch.int32, device=device), cp_split_sizes.cumsum(0)))
+    total_seq_len = base_cp_boundaries[-1]
+
+    cu_seqlens_q = cross_attn_params.cu_seqlens_q
+    cu_seqlens_k = cross_attn_params.cu_seqlens_kv
+    cu_seqlens_pad = torch.arange(cu_seqlens_q.shape[0], dtype=torch.int32, device=device) * divide(
+        cp_pad_size, cp_shuffle_num
+    )
+    cu_seqlens_q = cu_seqlens_q + cu_seqlens_pad
+
+    q_seg_starts, q_seg_ends = cu_seqlens_q[:-1], cu_seqlens_q[1:]
+
+    xattn_q_ranges, xattn_k_ranges = [], []
+    for i in range(batch_size):
+        inner_xattn_q_ranges, inner_xattn_k_ranges = [], []
+        for j in range(cp_shuffle_num):
+            global_offset = i * total_seq_len * cp_shuffle_num + j * total_seq_len
+            cp_boundaries = base_cp_boundaries + global_offset
+            this_cp_start, this_cp_end = (cp_boundaries[cp_rank], cp_boundaries[cp_rank + 1])
+
+            q_inter_starts = torch.maximum(this_cp_start, q_seg_starts)
+            q_inter_ends = torch.minimum(this_cp_end, q_seg_ends)
+
+            q_mask = q_inter_starts < q_inter_ends
+            valid_q_starts = q_inter_starts[q_mask]
+            valid_q_ends = q_inter_ends[q_mask]
+
+            k_seg_starts, k_seg_ends = cu_seqlens_k[:-1], cu_seqlens_k[1:]
+            valid_indices = torch.nonzero(q_mask, as_tuple=True)[0]
+
+            valid_k_starts = k_seg_starts[valid_indices]
+            valid_k_ends = k_seg_ends[valid_indices]
+
+            part_xattn_q_rangs = torch.stack((valid_q_starts, valid_q_ends), dim=1)
+            offset = part_xattn_q_rangs[:, 0].min()
+            part_xattn_q_rangs = part_xattn_q_rangs - offset
+
+            inner_xattn_q_ranges.append(part_xattn_q_rangs)
+            inner_xattn_k_ranges.append(torch.stack((valid_k_starts, valid_k_ends), dim=1))
+        inner_end_values = torch.tensor([ranges[-1, -1] for ranges in inner_xattn_q_ranges], dtype=torch.int32)
+        inner_offsets = torch.cat((torch.zeros(1, dtype=inner_end_values.dtype), torch.cumsum(inner_end_values[:-1], dim=0)))
+        inner_xattn_q_ranges = [tensor + int(offset) for tensor, offset in zip(inner_xattn_q_ranges, inner_offsets)]
+        xattn_q_ranges.append(torch.cat(inner_xattn_q_ranges, dim=0))
+        xattn_k_ranges.append(torch.cat(inner_xattn_k_ranges, dim=0))
+
+    end_values = torch.tensor([ranges[-1, -1].item() for ranges in xattn_q_ranges], dtype=torch.int32)
+    offsets = torch.cat((torch.zeros(1, dtype=end_values.dtype), torch.cumsum(end_values[:-1], dim=0)))
+
+    shifted_tensors = [tensor + int(offset) for tensor, offset in zip(xattn_q_ranges, offsets)]
+    xattn_q_ranges_ts = torch.cat(shifted_tensors, dim=0)
+    xattn_k_ranges_ts = torch.cat(xattn_k_ranges, dim=0)
+
+    cu_seqlens_q = torch.unique(xattn_q_ranges_ts)
+    cu_seqlens_k = torch.unique(xattn_k_ranges_ts)
+    assert (
+        cu_seqlens_q.shape == cu_seqlens_k.shape
+    ), f"cu_seqlens_q.shape: {cu_seqlens_q.shape}, cu_seqlens_k.shape: {cu_seqlens_k.shape}, "
+
+    return PackedCrossAttnParams(
+        q_ranges=xattn_q_ranges_ts,
+        kv_ranges=xattn_k_ranges_ts,
+        cu_seqlens_q=cu_seqlens_q,
+        cu_seqlens_kv=cu_seqlens_k,
+        max_seqlen_q=seq_len_cur_rank,
+        max_seqlen_kv=cross_attn_params.max_seqlen_kv,
+    )
+
+
+def cp_ulysses_process(
+    cp_size: int,
+    x: torch.Tensor,
+    condition_map: torch.Tensor,
+    rope: torch.Tensor,
+    xattn_mask_for_cuda_graph: Union[torch.Tensor, None],
+    cross_attn_params: PackedCrossAttnParams,
+):
+    seq_len, N, D = x.shape
+    assert seq_len == rope.size(0), f"seq_len: {seq_len} != rope.size(0): {rope.size(0)}"
+    assert condition_map.size(0) == seq_len, f"condition_map.size(0): {condition_map.size(0)} != seq_len: {seq_len}"
+
+    # Part1: split for CP
+    cp_split_sizes = [seq_len // cp_size] * cp_size
+    for i in range(seq_len % cp_size):
+        cp_split_sizes[i] += 1
+
+    # Part2: scatter to CP
+    x = scatter_to_context_parallel_region(x, cp_split_sizes)
+    condition_map = scatter_to_context_parallel_region(condition_map, cp_split_sizes)
+    rope = scatter_to_context_parallel_region(rope, cp_split_sizes)
+
+    # Part3: update cross_attn cross_attn_params
+    cross_attn_params = cp_update_cross_attn_qkv_range(cross_attn_params, N, cp_split_sizes, x.device)
+    if xattn_mask_for_cuda_graph is not None:
+        cross_attn_params = update_packed_seq_params_for_cuda_graph(cross_attn_params, xattn_mask_for_cuda_graph)
+
+    return x, condition_map, rope, cp_split_sizes, cross_attn_params
+
+
+def cp_shuffle_overlap_process(
+    cp_size: int,
+    x: torch.Tensor,
+    condition_map: torch.Tensor,
+    rope: torch.Tensor,
+    xattn_mask_for_cuda_graph: Union[torch.Tensor, None],
+    ardf_meta: dict,
+    core_attn_params: PackedCoreAttnParams,
+    cross_attn_params: PackedCrossAttnParams,
+):
+    seq_len, N, D = x.shape
+    assert seq_len == rope.size(0), f"seq_len: {seq_len} != rope.size(0): {rope.size(0)}"
+    assert condition_map.size(0) == seq_len, f"condition_map.size(0): {condition_map.size(0)} != seq_len: {seq_len}"
+    cp_shuffle_num = ardf_meta["denoising_range_num"]
+
+    # Part1: calculate cp_pad_size and cp_split_sizes
+    cp_pad_size = 0
+    if divide(seq_len, cp_shuffle_num) % cp_size != 0:
+        cp_pad_size = (cp_size - divide(seq_len, cp_shuffle_num) % cp_size) * cp_shuffle_num
+    cp_split_sizes = [(seq_len + cp_pad_size) // cp_size] * cp_size
+
+    # Part2: scatter to CP
+    x = scatter_to_context_parallel_region(x, cp_split_sizes, cp_shuffle_num, cp_pad_size)
+    condition_map = scatter_to_context_parallel_region(condition_map, cp_split_sizes, cp_shuffle_num, cp_pad_size)
+    rope = scatter_to_context_parallel_region(rope, cp_split_sizes, cp_shuffle_num, cp_pad_size)
+
+    # Part3: update core_attn_params
+    gcd = math.gcd(seq_len, seq_len + cp_pad_size)
+    _sq = seq_len // gcd
+    _psq = (seq_len + cp_pad_size) // gcd
+    q_range = ardf_meta["q_range"] * _psq // _sq
+    max_seqlen_q = ardf_meta["max_seqlen_q"] * _psq // _sq
+    core_attn_params = PackedCoreAttnParams(
+        q_range=q_range,
+        k_range=ardf_meta["k_range"],
+        np_q_range=q_range.cpu().numpy(),
+        np_k_range=ardf_meta["k_range"].cpu().numpy(),
+        max_seqlen_q=max_seqlen_q,
+        max_seqlen_k=ardf_meta["max_seqlen_k"],
+    )
+
+    # Part4: update cross_attn cross_attn_params
+    cross_attn_params = cp_update_cross_attn_qkv_range(
+        cross_attn_params, N, cp_split_sizes, x.device, cp_shuffle_num, cp_pad_size
+    )
+    if xattn_mask_for_cuda_graph is not None:
+        cross_attn_params = update_packed_seq_params_for_cuda_graph(cross_attn_params, xattn_mask_for_cuda_graph)
+
+    return x, condition_map, rope, cp_pad_size, cp_split_sizes, core_attn_params, cross_attn_params
+
+
+def cp_pre_process(
+    cp_size: int,
+    cp_strategy: str,
+    x: torch.Tensor,
+    condition_map: torch.Tensor,
+    rope: torch.Tensor,
+    xattn_mask_for_cuda_graph: Union[torch.Tensor, None],
+    ardf_meta: dict,
+    core_attn_params: PackedCoreAttnParams,
+    cross_attn_params: PackedCrossAttnParams,
+):
+    """
+    This function is used to handle context parallel behavior,
+    split input tensors into multiple parts and scatter them to different GPUs.
+
+    Input:
+        cp_strategy: str. cp_ulysses for hopper or newer, cp_shuffle_overlap for 4090 or older
+        x: (S, N, D). torch.Tensor of inputs embedding (images or latent representations of images)
+        condition_map: (N * S). torch.Tensor determine which condition to use for each token
+        rope: (S, 96). torch.Tensor of rope
+        xattn_mask_for_cuda_graph: (N * denoising_range_num, L, 1, 1). torch.Tensor of xattn mask for cuda graph, None means no cuda graph
+        core_attn_params: PackedCoreAttnParams. Packed sequence parameters for core_atten
+        cross_attn_params: PackedCrossAttnParams. Packed sequence parameters for cross_atten
+
+    Output:
+        x: (S', N, D). torch.Tensor of inputs embedding (images or latent representations of images)
+        condition_map: (N * S'). torch.Tensor determine which condition to use for each token
+        rope: (S', 96). torch.Tensor of rope
+        cp_split_sizes: List[int]. Split sizes for each rank
+        core_attn_params: PackedCoreAttnParams
+        cross_attn_params: PackedCrossAttnParams
+    """
+    if cp_size == 1:
+        return x, condition_map, rope, None, None, core_attn_params, cross_attn_params
+    if cp_strategy == "cp_ulysses":
+        (x, condition_map, rope, cp_split_sizes, cross_attn_params) = cp_ulysses_process(
+            cp_size, x, condition_map, rope, xattn_mask_for_cuda_graph, cross_attn_params
+        )
+        return (x, condition_map, rope, 0, cp_split_sizes, core_attn_params, cross_attn_params)
+    elif cp_strategy == "cp_shuffle_overlap":
+        (
+            x,
+            condition_map,
+            rope,
+            cp_pad_size,
+            cp_split_sizes,
+            core_attn_params,
+            cross_attn_params,
+        ) = cp_shuffle_overlap_process(
+            cp_size, x, condition_map, rope, xattn_mask_for_cuda_graph, ardf_meta, core_attn_params, cross_attn_params
+        )
+        return (x, condition_map, rope, cp_pad_size, cp_split_sizes, core_attn_params, cross_attn_params)
+    else:
+        raise ValueError(f"Invalid CP strategy: {cp_strategy}, expected cp_ulysses or cp_shuffle_overlap")
+
+
+def cp_post_process(cp_size: int, cp_strategy: str, x: torch.Tensor, meta_args: ModelMetaArgs) -> torch.Tensor:
+    if cp_size == 1:
+        return x
+    if cp_strategy == "cp_shuffle_overlap":
+        x = gather_from_context_parallel_region(
+            x, meta_args.cp_split_sizes, meta_args.denoising_range_num, meta_args.cp_pad_size
+        )
+    elif cp_strategy == "cp_ulysses":
+        x = gather_from_context_parallel_region(x, meta_args.cp_split_sizes)
+    else:
+        raise ValueError(f"Invalid CP strategy: {cp_strategy}, expected cp_ulysses or cp_shuffle_overlap")
+    return x
+
+
+#####################################################
+# Ulysses Attention Pipeline
+#####################################################
+def all_to_all_input_split(tensor: torch.Tensor, cp_split_sizes: List[int]) -> Tuple[torch.Tensor, torch.distributed.Work]:
+    """
+    Scatter head_number and gather seq_len, for example:
+    input: (seq_len, cp * hn, hd)
+    output: (seq_len * cp, hn, hd)
+    NOTE: seq_len of input maybe not equal, which depends on cp_split_sizes[mpu.get_cp_rank()]
+    """
+    cp_world_size = mpu.get_cp_world_size()
+    if cp_world_size == 1:
+        return tensor, FakeHandle()
+    assert cp_split_sizes is not None
+    _, hn, _ = tensor.shape
+    if cp_world_size % hn == 0 and cp_world_size != hn:
+        tensor = torch.repeat_interleave(tensor, repeats=divide(cp_world_size, hn), dim=1).contiguous()
+    assert tensor.is_contiguous()
+    input = rearrange(tensor, "seq (cp hn) hd -> (cp seq) hn hd", cp=cp_world_size).contiguous()
+    output = torch.empty([sum(cp_split_sizes), *input.shape[1:]], device=input.device, dtype=input.dtype)
+    handle = torch.distributed.all_to_all_single(
+        output, input, output_split_sizes=cp_split_sizes, group=mpu.get_cp_group(), async_op=True
+    )
+    return output, handle
+
+
+def all_to_all_output_split(tensor: torch.Tensor, cp_split_sizes: List[int]) -> Tuple[torch.Tensor, torch.distributed.Work]:
+    """
+    Scatter seq_len and gather head_number, for example:
+    input: (seq_len * cp, hn, hd)
+    output: (seq_len, cp * hn, hd)
+    NOTE: seq_len of output maybe not equal, which depends on cp_split_sizes[mpu.get_cp_rank()]
+    """
+    cp_world_size = mpu.get_cp_world_size()
+    if cp_world_size == 1:
+        return tensor, FakeHandle()
+    assert cp_split_sizes is not None
+    assert tensor.is_contiguous()
+    _, hn, _ = tensor.shape
+    output = torch.empty(
+        [cp_split_sizes[mpu.get_cp_rank()] * cp_world_size, *tensor.shape[1:]], device=tensor.device, dtype=tensor.dtype
+    )
+    handle = torch.distributed.all_to_all_single(
+        output, tensor, input_split_sizes=cp_split_sizes, group=mpu.get_cp_group(), async_op=True
+    )
+    return output, handle
+
+
+def fused_qkv_communication(
+    q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, cp_split_sizes: List[int]
+) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+    cp_world_size = mpu.get_cp_world_size()
+    if cp_world_size == 1:
+        return q, k, v
+    assert cp_split_sizes is not None
+    _, k_head, _ = k.shape
+    if cp_world_size % k_head == 0 and cp_world_size != k_head:
+        k = torch.repeat_interleave(k, repeats=divide(cp_world_size, k_head), dim=1)
+        v = torch.repeat_interleave(v, repeats=divide(cp_world_size, k_head), dim=1)
+
+    q = rearrange(q, "seq (cp hn) hd -> (cp seq) hn hd", cp=cp_world_size).contiguous()
+    k = rearrange(k, "seq (cp hn) hd -> (cp seq) hn hd", cp=cp_world_size).contiguous()
+    v = rearrange(v, "seq (cp hn) hd -> (cp seq) hn hd", cp=cp_world_size).contiguous()
+    head_split_number = [q.shape[1], k.shape[1], v.shape[1]]
+    qkv = torch.cat([q, k, v], dim=1).contiguous()
+
+    qkv_output = torch.empty([sum(cp_split_sizes), *qkv.shape[1:]], device=qkv.device, dtype=qkv.dtype)
+    torch.distributed.all_to_all_single(
+        qkv_output, qkv, output_split_sizes=cp_split_sizes, group=mpu.get_cp_group(), async_op=False
+    )
+    q, k, v = torch.split(qkv_output, head_split_number, dim=1)
+    return q, k, v
+
+
+class UlyssesScheduler:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_attn_and_xattn_with_comm_overlap(
+        get_q_func: Callable,  # [seq hn hd]
+        get_k_func: Callable,  # [seq hn hd]
+        get_v_func: Callable,  # [seq hn hd]
+        kv_cache_func: Callable,
+        core_attn_func: Callable,
+        cross_attn_func: Callable,
+        overlap_degree: int,
+        batch_size: int,
+        cp_size: int,
+        cp_split_sizes: List[int] = None,
+    ):
+        """
+        Get Q, K, V with communication overlap.
+        Input:
+            get_q: Callable, function to get q, shape [b, sq, hn, hd]
+            get_k: Callable, function to get k, shape [sq, b, hn, hd]
+            get_v: Callable, function to get v, shape [sq, b, hn, hd]
+        NOTE: Why follow such compute and comm order?
+        1. v_compute
+        2. k_compute(overlap with v_comm)
+        3. q_compute(overlap with k_comm)
+        4. kv_cache_func(overlap with q_comm)
+        Follow the principle: We need to begin comm as soon as possible to hide the comm latency.
+        The computation flops and commnunication order is:
+        flops order: q_compute (larger hidden_size + layernorm) > k_compute (layernorm) > v_compute
+        comm order: q_compute (larger hidden_size) > k_compute = v_compute
+        """
+        value = get_v_func()
+        value, handle_v = all_to_all_input_split(value, cp_split_sizes)
+        key = get_k_func()
+        key, handle_k = all_to_all_input_split(key, cp_split_sizes)
+        query = get_q_func()
+        query, handle_q = all_to_all_input_split(query, cp_split_sizes)
+
+        handle_v.wait()
+        handle_k.wait()
+        kv = torch.concat([key, value], dim=-1)
+
+        key, value = kv_cache_func(kv)
+        handle_q.wait()
+        return UlyssesScheduler.get_attn_and_xattn_base(
+            query, key, value, core_attn_func, cross_attn_func, overlap_degree, batch_size, cp_size, cp_split_sizes
+        )
+
+    @staticmethod
+    def get_attn_and_xattn_with_fused_kv_comm(
+        get_q_func: Callable,
+        get_kv_func: Callable,
+        kv_cache_func: Callable,
+        core_attn_func: Callable,
+        cross_attn_func: Callable,
+        overlap_degree: int,
+        batch_size: int,
+        cp_size: int,
+        cp_split_sizes: List[int] = None,
+    ):
+        """
+        When seq_len is very small, CPU-bound issues are severe. By fusing kv communication,
+        CPU operations and the number of kernel launches are reduced.
+        """
+        kv = get_kv_func()
+        kv, handle_kv = all_to_all_input_split(kv, cp_split_sizes)
+        query = get_q_func()
+        query, handle_q = all_to_all_input_split(query, cp_split_sizes)
+        handle_kv.wait()
+        key, value = kv_cache_func(kv)
+        handle_q.wait()
+        return UlyssesScheduler.get_attn_and_xattn_base(
+            query, key, value, core_attn_func, cross_attn_func, overlap_degree, batch_size, cp_size, cp_split_sizes
+        )
+
+    def get_attn_and_xattn_with_fused_qkv_comm(
+        get_qkv_func: Callable,
+        kv_cache_func: Callable,
+        core_attn_func: Callable,
+        cross_attn_func: Callable,
+        overlap_degree: int,
+        batch_size: int,
+        cp_size: int,
+        cp_split_sizes: List[int] = None,
+    ):
+        """
+        By fusing the communication of q, k, and v together, further optimize CPU-bound issues.
+        """
+        q, k, v = get_qkv_func()
+        q, k, v = fused_qkv_communication(q, k, v, cp_split_sizes)
+        k, v = kv_cache_func(torch.cat([k, v], dim=-1))
+        return UlyssesScheduler.get_attn_and_xattn_base(
+            q, k, v, core_attn_func, cross_attn_func, overlap_degree, batch_size, cp_size, cp_split_sizes
+        )
+
+    @staticmethod
+    def get_attn_and_xattn_base(
+        query: torch.Tensor,
+        key: torch.Tensor,
+        value: torch.Tensor,
+        core_attn_func: Callable,
+        cross_attn_func: Callable,
+        overlap_degree: int,
+        batch_size: int,
+        cp_size: int,
+        cp_split_sizes: List[int] = None,
+    ):
+        # Split Query, Key, Value into multiple parts
+        # k/v may have different sequence length with q due to kv cache
+        q_seq, q_head, q_hidden = query.shape
+        kv_seq, kv_head, kv_hidden = key.shape
+        if overlap_degree == -1:
+            overlap_degree = q_head // kv_head
+        else:
+            assert overlap_degree <= q_head
+
+        if overlap_degree == 1:
+            query = [query]
+        elif kv_head == 1:  # MQA
+            query = query.chunk(overlap_degree, dim=1)
+        else:  # GQA
+            assert q_head % (overlap_degree * kv_head) == 0
+            query = query.reshape(q_seq, kv_head, -1, q_hidden)
+            query = query.chunk(overlap_degree, dim=2)
+            query = [q.reshape(q_seq, -1, q_hidden) for q in query]
+
+        # Compute Core Attention
+        handle_attn = None
+        core_attn_out = None
+        core_attn_outs = []
+        for i in range(overlap_degree):
+            core_attn_out_new = core_attn_func(query[i], key, value)
+            if not torch.isfinite(core_attn_out_new).all():
+                import pdb; pdb.set_trace()
+            if handle_attn is not None:
+                handle_attn.wait()
+                core_attn_outs.append(core_attn_out)
+            core_attn_out, handle_attn = all_to_all_output_split(core_attn_out_new, cp_split_sizes)
+            if not torch.isfinite(core_attn_out).all():
+                import pdb; pdb.set_trace()
+
+        xattn_out = cross_attn_func()
+        handle_attn.wait()
+        if not torch.isfinite(core_attn_out).all():
+            import pdb; pdb.set_trace()
+        core_attn_outs.append(core_attn_out)
+        core_attn_out = torch.cat(core_attn_outs, dim=1)
+
+        if not torch.isfinite(core_attn_out).all():
+            import pdb; pdb.set_trace()
+
+        core_attn_out = rearrange(core_attn_out, "(cp sq b) hn hd -> (sq) b (cp hn hd)", cp=cp_size, b=batch_size)
+        return core_attn_out, xattn_out
+
+
+#####################################################
+# CSO(context shuffle overlap) Attention Pipeline
+#####################################################
+def cso_communication(
+    input: torch.Tensor, cp_world_size: int, cp_split_sizes: List[int], comm_type: str = None
+) -> Tuple[torch.Tensor, torch.distributed.Work]:
+    if cp_world_size == 1:
+        return input, FakeHandle()
+    assert cp_split_sizes is not None
+    _, hn, _ = input.shape
+    if comm_type == "kv":
+        if cp_world_size % hn == 0 and cp_world_size != hn:
+            input = torch.repeat_interleave(input, repeats=divide(cp_world_size, hn), dim=1)
+        input = rearrange(input, "spb (cp hn) hd -> (cp spb) hn hd", cp=cp_world_size).contiguous()
+    output = torch.empty(input.shape, device=input.device, dtype=input.dtype)
+
+    handle = torch.distributed.all_to_all_single(
+        output, input, input_split_sizes=cp_split_sizes, group=mpu.get_cp_group(), async_op=True
+    )
+
+    return output, handle
+
+
+class CSOHelper:
+    def __init__(self, cp_shuffle_num, cp_world_size, cp_split_sizes):
+        self.cp_shuffle_num = cp_shuffle_num
+        self.cp_world_size = cp_world_size
+        self.cp_split_sizes = [divide(x, self.cp_shuffle_num) for x in cp_split_sizes]
+
+    def split_query_for_overlap(self, query):
+        query = rearrange(
+            query, "(dn spb) (cp hn) hd -> (dn cp spb) hn hd", cp=self.cp_world_size, dn=self.cp_shuffle_num
+        ).contiguous()
+        querys = list(torch.chunk(query, self.cp_shuffle_num, dim=0))
+        querys[0], handle_q = cso_communication(querys[0], self.cp_world_size, self.cp_split_sizes)
+        return querys, handle_q
+
+    def overlap(self, fattn, qs, k, v):
+        core_attn_outs = []
+        for i in range(self.cp_shuffle_num):
+            if self.cp_shuffle_num == 1:
+                q = qs[0]
+            elif i == 0:
+                q = qs[0]
+                loop_var, loop_handle = cso_communication(qs[i + 1], self.cp_world_size, self.cp_split_sizes)
+            else:
+                loop_handle.wait()
+                if loop_var.numel() == qs[0].numel():
+                    q = loop_var
+                else:
+                    assert loop_var.numel() == qs[0].numel() * 2
+                    q, ready_o = torch.chunk(loop_var, 2, dim=-1)
+                    core_attn_outs.append(ready_o)
+                loop_var = torch.concat([qs[i + 1], o], dim=-1) if i < self.cp_shuffle_num - 1 else o
+                loop_var, loop_handle = cso_communication(loop_var, self.cp_world_size, self.cp_split_sizes)
+
+            o = fattn(q, k, v, i)
+            if i == self.cp_shuffle_num - 1:
+                if i != 0:
+                    loop_handle.wait()
+                    assert loop_var.numel() == qs[0].numel()
+                    core_attn_outs.append(loop_var)
+                last_o, handle_attn = cso_communication(o, self.cp_world_size, self.cp_split_sizes)
+                core_attn_outs.append(last_o)
+        return core_attn_outs, handle_attn

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/parallelism/pipeline_parallel.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import queue
+from dataclasses import dataclass
+from typing import Optional
+
+import torch
+
+from inference.infra.distributed import parallel_state as mpu
+
+
+@dataclass
+class TensorAndHandler:
+    tensor: torch.Tensor
+    handler: torch.distributed.Work
+
+
+class PPScheduler:
+    def __init__(self):
+        """Initialize an instance of the PPScheduler class"""
+
+        self.device: torch.device = torch.device(f"cuda:{torch.cuda.current_device()}")
+        self.recv_queue: queue.Queue = queue.Queue()
+
+    def isend_next(self, tensor: torch.Tensor) -> torch.distributed.Work:
+        """Asynchronously send a tensor to the next pipeline and return the send handle.
+
+        Args:
+            tensor (torch.Tensor): The tensor to be sent.
+
+        Returns:
+            torch.distributed.Work: The handle for the send operation.
+        """
+        handle = torch.distributed.isend(
+            tensor.contiguous(), dst=mpu.get_pipeline_model_parallel_next_rank(), group=mpu.get_pp_group()
+        )
+        return handle
+
+    def irecv_prev(self, buffer: torch.Tensor) -> torch.distributed.Work:
+        """Asynchronously receive a tensor from the previous pipeline and return the receive handle.
+
+        Args:
+            buffer (torch.Tensor): The buffer tensor for receiving data.
+
+        Returns:
+            torch.distributed.Work: The handle for the receive operation.
+        """
+        handle = torch.distributed.irecv(buffer, src=mpu.get_pipeline_model_parallel_prev_rank(), group=mpu.get_pp_group())
+        return handle
+
+    def recv_prev_data(self, shape: torch.Size, dtype: torch.dtype) -> torch.Tensor:
+        """Receive data from the previous pipeline and return the received tensor.
+
+        Args:
+            shape (torch.Size): The shape of the tensor to receive.
+            dtype (torch.dtype): The data type of the tensor to receive.
+
+        Returns:
+            torch.Tensor: The received tensor.
+        """
+        recv_tensor = torch.empty(shape, dtype=dtype, device=self.device)
+        self.irecv_prev(recv_tensor).wait()
+        return recv_tensor
+
+    def queue_irecv_prev(self, shape: torch.Size, dtype: torch.dtype) -> None:
+        """Put the asynchronously received tensor and handle into the receive queue.
+
+        Args:
+            shape (torch.Size): The shape of the tensor to receive.
+            dtype (torch.dtype): The data type of the tensor to receive.
+        """
+        recv_tensor = torch.empty(shape, dtype=dtype, device=self.device)
+        handle = self.irecv_prev(recv_tensor)
+        self.recv_queue.put(TensorAndHandler(tensor=recv_tensor, handler=handle))
+
+    def queue_irecv_prev_data(self) -> torch.Tensor:
+        """Get a tensor from the receive queue and wait for the receive operation to complete.
+
+        Returns:
+            torch.Tensor: The received tensor obtained from the queue.
+        """
+        tensor_and_handler = self.recv_queue.get()
+        tensor_and_handler.handler.wait()
+        return tensor_and_handler.tensor
+
+
+_PP_SCHEDULER: Optional[PPScheduler] = None
+
+
+def init_pp_scheduler():
+    """Initialize the PPScheduler instance.
+
+    Raises:
+        AssertionError: If the PPScheduler is already initialized.
+    """
+    global _PP_SCHEDULER
+    assert _PP_SCHEDULER is None, "pipeline model parallel group is already initialized"
+    _PP_SCHEDULER = PPScheduler()
+
+
+def pp_scheduler() -> PPScheduler:
+    """Get the current PPScheduler instance.
+
+    Returns:
+        PPScheduler: The current PPScheduler instance.
+
+    Raises:
+        AssertionError: If the PPScheduler has not been initialized.
+    """
+    assert _PP_SCHEDULER is not None, "pipeline model parallel group is not initialized"
+    return _PP_SCHEDULER

FlowCache/FlowCache4MAGI-1-dev-V1/inference/infra/parallelism/tile_parallel.py

@@ -0,0 +1,448 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from collections import OrderedDict
+from typing import List
+
+import torch
+from tqdm import tqdm
+
+
+class ParallelHelper:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def split_tile_list(
+        tile_numel_dict: OrderedDict[int, int], parallel_group: torch.distributed.ProcessGroup = None
+    ) -> List[int]:
+        """
+        Splits the given tile size into a list of sizes that each rank should handle.
+
+        This method takes into account the number of ranks in a distributed setting.
+        If the distributed environment is not initialized, it returns a list of
+        integers from 0 to tile_size - 1, representing each tile index.
+
+        If the distributed environment is initialized, it calculates the base tile size
+        for each rank and distributes any remaining tiles among the ranks.
+
+        Args:
+            tile_numel_dict (OrderedDict[int, int]): Dict of index and numel of tiles.
+            parallel_group (torch.distributed.ProcessGroup, optional):
+                Distributed decoding group. Defaults to None.
+
+        Returns:
+            List[int]: A list of tile indices assigned to the current rank.
+            List[int]: A list of global tile indices.
+        """
+        if not torch.distributed.is_initialized():
+            return list(range(len(tile_numel_dict))), list(range(len(tile_numel_dict)))
+        else:
+            tile_idxs = list(OrderedDict(sorted(tile_numel_dict.items(), key=lambda x: x[1], reverse=True)).keys())
+            world_size = torch.distributed.get_world_size(group=parallel_group)
+            cur_rank = torch.distributed.get_rank(group=parallel_group)
+            global_tile_idxs = []
+            cur_rank_tile_idxs = []
+            for rank in range(world_size):
+                rank_tile_idxs = [tile_idxs[rank + world_size * i] for i in range(len(tile_idxs) // world_size)]
+                if rank < len(tile_idxs) % world_size:
+                    rank_tile_idxs.append(tile_idxs[len(tile_idxs) // world_size * world_size + rank])
+                if rank == cur_rank:
+                    cur_rank_tile_idxs = rank_tile_idxs
+                global_tile_idxs = global_tile_idxs + rank_tile_idxs
+            return cur_rank_tile_idxs, global_tile_idxs
+
+    @staticmethod
+    def gather_frames(
+        frames: List[torch.Tensor], global_tile_idxs: List[int], parallel_group: torch.distributed.ProcessGroup = None
+    ) -> List[torch.Tensor]:
+        """
+        Gathers frame data from all ranks in a distributed environment.
+
+        This method collects frames from all ranks and combines them into a single list.
+        If the distributed environment is not initialized, it simply returns the input frames.
+
+        Args:
+            frames (List[torch.Tensor]): A list of frames (tensors) from the current rank.
+            global_tile_idxs (List[int]): A list of global tile indices.
+            parallel_group (torch.distributed.ProcessGroup, optional):
+                Distributed decoding group. Defaults to None.
+
+        Returns:
+            List[torch.Tensor]: A list of frames (tensors) from all ranks.
+        """
+        if not torch.distributed.is_initialized():
+            return frames
+        else:
+            #  assert len(frames) > 0
+            # Communicate shapes
+            if len(frames) == 0:
+                cur_rank_shapes = []
+            else:
+                cur_rank_shapes = [frame.shape for frame in frames]
+            all_rank_shapes = [None] * torch.distributed.get_world_size(group=parallel_group)
+            torch.distributed.all_gather_object(all_rank_shapes, cur_rank_shapes, group=parallel_group)
+
+            all_rank_sizes = []
+            total_size = []
+            for per_rank_shapes in all_rank_shapes:
+                per_rank_sizes = []
+                per_rank_total_size = 0
+                for shape in per_rank_shapes:
+                    per_rank_sizes.append(shape[0] * shape[1] * shape[2] * shape[3] * shape[4])
+                    per_rank_total_size += shape[0] * shape[1] * shape[2] * shape[3] * shape[4]
+                all_rank_sizes.append(per_rank_sizes)
+                total_size.append(per_rank_total_size)
+
+            # Gather all frames
+            if len(frames) == 0:
+                flattened_frames = torch.zeros([0], dtype=torch.bfloat16, device="cuda")
+            else:
+                flattened_frames = torch.cat([frame.flatten().contiguous() for frame in frames], dim=0)
+                assert flattened_frames.dtype == torch.bfloat16
+            gather_tensors = [
+                torch.zeros(total_size[i], dtype=torch.bfloat16, device="cuda")
+                for i in range(torch.distributed.get_world_size(group=parallel_group))
+            ]
+            torch.distributed.all_gather(gather_tensors, flattened_frames, group=parallel_group)
+
+            result_frames = []
+            for idx, per_rank_shapes in enumerate(all_rank_shapes):
+                offset = 0
+                for j, shape in enumerate(per_rank_shapes):
+                    result_frames.append(gather_tensors[idx][offset : offset + all_rank_sizes[idx][j]].view(shape))
+                    offset += all_rank_sizes[idx][j]
+            result_frames_dict = OrderedDict((idx, frame) for idx, frame in zip(global_tile_idxs, result_frames))
+            result_frames = list(OrderedDict(sorted(result_frames_dict.items())).values())
+            return result_frames
+
+    @staticmethod
+    def index_undot(index: int, loop_size: List[int]) -> List[int]:
+        """
+        Converts a single index into a list of indices, representing the position in a multi-dimensional space.
+
+        This method takes an integer index and a list of loop sizes, and converts the index into a list of indices
+        that correspond to the position in a multi-dimensional space.
+
+        Args:
+            index (int): The single index to be converted.
+            loop_size (List[int]): A list of integers representing the size of each dimension in the multi-dimensional space.
+
+        Returns:
+            List[int]: A list of integers representing the position in the multi-dimensional space.
+        """
+        undotted_index = []
+        for i in range(len(loop_size) - 1, -1, -1):
+            undotted_index.append(index % loop_size[i])
+            index = index // loop_size[i]
+        undotted_index.reverse()
+        assert len(undotted_index) == len(loop_size)
+        return undotted_index
+
+    @staticmethod
+    def index_dot(index: List[int], loop_size: List[int]) -> int:
+        """
+        Converts a list of indices into a single index, representing the position in a multi-dimensional space.
+
+        This method takes a list of indices and a list of loop sizes, and converts the list of indices into a single index
+        that corresponds to the position in a multi-dimensional space.
+
+        Args:
+            index (List[int]): A list of integers representing the position in the multi-dimensional space.
+            loop_size (List[int]): A list of integers representing the size of each dimension in the multi-dimensional space.
+
+        Returns:
+            int: A single integer representing the position in the multi-dimensional space.
+        """
+        assert len(index) == len(loop_size)
+        dot_index = 0
+        strides = [1]
+        for i in range(len(loop_size) - 1, -1, -1):
+            strides.append(strides[-1] * loop_size[i])
+        strides.reverse()
+        strides = strides[1:]
+        assert len(index) == len(strides)
+        for i in range(len(index)):
+            dot_index += index[i] * strides[i]
+        return dot_index
+
+
+class TileProcessor:
+    def __init__(
+        self,
+        encode_fn,
+        decode_fn,
+        tile_sample_min_height: int = 256,
+        tile_sample_min_width: int = 256,
+        tile_sample_min_length: int = 16,
+        spatial_downsample_factor: int = 8,
+        temporal_downsample_factor: int = 1,
+        spatial_tile_overlap_factor: float = 0.25,
+        temporal_tile_overlap_factor: float = 0,
+        sr_ratio=1,
+        first_frame_as_image: bool = False,
+        parallel_group: torch.distributed.ProcessGroup = None,
+    ):
+        """
+        Initializes an instance of the class.
+
+        Args:
+            encode_fn (function): The encoding function used for tile sampling.
+            decode_fn (function): The decoding function used for tile reconstruction.
+            tile_sample_min_size (int, optional): The minimum size of the sampled tiles. Defaults to 256.
+            tile_sample_min_length (int, optional): The minimum length of the sampled tiles. Defaults to 16.
+            spatial_downsample_factor (int, optional): The actual spataial downsample factor of given encode_fn. Defaults to 8.
+            temporal_downsample_factor (int, optional): The actual temporal downsample factor of the latent space tiles. Defaults to 1.
+            tile_overlap_factor (float, optional): The overlap factor between adjacent tiles. Defaults to 0.25.
+            parallel_group (torch.distributed.ProcessGroup, optional): Distributed decoding group. Defaults to None.
+        """
+        self.encode_fn = encode_fn
+        self.decode_fn = decode_fn
+
+        self.spatial_downsample_factor = spatial_downsample_factor
+        self.temporal_downsample_factor = temporal_downsample_factor
+        self.tile_sample_min_height = tile_sample_min_height
+        self.tile_sample_min_width = tile_sample_min_width
+        self.tile_sample_min_length = tile_sample_min_length
+        self.tile_latent_min_height = tile_sample_min_height // spatial_downsample_factor
+        self.tile_latent_min_width = tile_sample_min_width // spatial_downsample_factor
+
+        self.tile_latent_min_length = tile_sample_min_length // temporal_downsample_factor
+        if first_frame_as_image:
+            self.tile_latent_min_length += 1
+
+        self.spatial_tile_overlap_factor = spatial_tile_overlap_factor
+        self.temporal_tile_overlap_factor = temporal_tile_overlap_factor
+        self.sr_ratio = sr_ratio
+        self.parallel_group = parallel_group
+
+    def blend_t(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor:
+        blend_extent = min(a.shape[2], b.shape[2], blend_extent)
+        for t in range(blend_extent):
+            b[:, :, t, :, :] = a[:, :, -blend_extent + t, :, :] * (1 - t / blend_extent) + b[:, :, t, :, :] * (
+                t / blend_extent
+            )
+        return b
+
+    def blend_v(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor:
+        blend_extent = min(a.shape[3], b.shape[3], blend_extent)
+        for y in range(blend_extent):
+            b[:, :, :, y, :] = a[:, :, :, -blend_extent + y, :] * (1 - y / blend_extent) + b[:, :, :, y, :] * (
+                y / blend_extent
+            )
+        return b
+
+    def blend_h(self, a: torch.Tensor, b: torch.Tensor, blend_extent: int) -> torch.Tensor:
+        blend_extent = min(a.shape[4], b.shape[4], blend_extent)
+        for x in range(blend_extent):
+            b[:, :, :, :, x] = a[:, :, :, :, -blend_extent + x] * (1 - x / blend_extent) + b[:, :, :, :, x] * (
+                x / blend_extent
+            )
+        return b
+
+    def tiled_encode(self, x: torch.FloatTensor, verbose: bool = False):
+        overlap_height = int(self.tile_sample_min_height * (1 - self.spatial_tile_overlap_factor))
+        overlap_width = int(self.tile_sample_min_width * (1 - self.spatial_tile_overlap_factor))
+        overlap_length = int(self.tile_sample_min_length * (1 - self.temporal_tile_overlap_factor))
+        blend_extent_h = int(self.tile_latent_min_height * self.spatial_tile_overlap_factor)
+        blend_extent_w = int(self.tile_latent_min_width * self.spatial_tile_overlap_factor)
+        blend_extent_t = int(self.tile_latent_min_length * self.temporal_tile_overlap_factor)
+        height_limit = self.tile_latent_min_height - blend_extent_h
+        width_limit = self.tile_latent_min_width - blend_extent_w
+        frame_limit = self.tile_latent_min_length - blend_extent_t
+
+        length_tile_size = (x.shape[2] + overlap_length - 1) // overlap_length
+        height_tile_size = (x.shape[3] + overlap_height - 1) // overlap_height
+        width_tile_size = (x.shape[4] + overlap_width - 1) // overlap_width
+        total_tile_size = length_tile_size * height_tile_size * width_tile_size
+        for_loop_size = [length_tile_size, height_tile_size, width_tile_size]
+
+        tiles = []
+        tile_numel_dict = OrderedDict()
+        for tile_index in range(total_tile_size):
+            undot_tile_index = ParallelHelper.index_undot(tile_index, for_loop_size)
+            f_idx, i_idx, j_idx = undot_tile_index
+            f = f_idx * overlap_length
+            i = i_idx * overlap_height
+            j = j_idx * overlap_width
+
+            # Extract the tile from the latent representation and decode it
+            tile = x[
+                :,
+                :,
+                f : f + self.tile_sample_min_length,
+                i : i + self.tile_sample_min_height,
+                j : j + self.tile_sample_min_width,
+            ]
+            tiles.append(tile)
+            tile_numel_dict[tile_index] = tile.numel()
+        tile_index_list, global_tile_index_list = ParallelHelper.split_tile_list(
+            tile_numel_dict, parallel_group=self.parallel_group
+        )
+        progress_bar = tqdm(
+            total=len(tile_index_list),
+            desc=f"[Rank {torch.distributed.get_rank(group=self.parallel_group)}] Encoding Tiles",
+            disable=not verbose,
+        )
+
+        frames = []
+        # Encode each tile based on the tile index list
+        for tile_index in tile_index_list:
+            tile = tiles[tile_index]
+            encoded = self.encode_fn(tile)
+            frames.append(encoded)
+            progress_bar.update(1)
+
+        # Gather all decoded frames from different ranks
+        frames = ParallelHelper.gather_frames(frames, global_tile_index_list, parallel_group=self.parallel_group)
+        assert len(frames) == total_tile_size
+        progress_bar.close()
+
+        result_frames = []
+        # Blend the encoded tiles to create the final output
+        for tile_index in range(total_tile_size):
+            undot_tile_index = ParallelHelper.index_undot(tile_index, for_loop_size)
+            f, i, j = undot_tile_index
+
+            tile = frames[tile_index]
+            # Blend with previous tiles if applicable
+            if f > 0:
+                idx = ParallelHelper.index_dot([f - 1, i, j], for_loop_size)
+                tile = self.blend_t(frames[idx], tile, blend_extent_t)
+            if i > 0:
+                idx = ParallelHelper.index_dot([f, i - 1, j], for_loop_size)
+                tile = self.blend_v(frames[idx], tile, blend_extent_h)
+            if j > 0:
+                idx = ParallelHelper.index_dot([f, i, j - 1], for_loop_size)
+                tile = self.blend_h(frames[idx], tile, blend_extent_w)
+            result_frames.append(tile[:, :, :frame_limit, :height_limit, :width_limit])
+
+        assert len(result_frames) == total_tile_size
+
+        concat_frames = []
+        for f in range(length_tile_size):
+            result_rows = []
+            for i in range(height_tile_size):
+                result_row = []
+                for j in range(width_tile_size):
+                    idx = ParallelHelper.index_dot([f, i, j], for_loop_size)
+                    result_row.append(result_frames[idx])
+                result_rows.append(torch.cat(result_row, dim=4))
+            concat_frames.append(torch.cat(result_rows, dim=3))
+
+        # Concatenate all result frames along the temporal dimension
+        result = torch.cat(concat_frames, dim=2)
+        return result
+
+    def tiled_decode(self, z: torch.FloatTensor, verbose: bool = False):
+        overlap_height = int(self.tile_latent_min_height * (1 - self.spatial_tile_overlap_factor))
+        overlap_width = int(self.tile_latent_min_width * (1 - self.spatial_tile_overlap_factor))
+        overlap_length = int(self.tile_latent_min_length * (1 - self.temporal_tile_overlap_factor))
+
+        real_tile_sample_min_height = int(self.tile_latent_min_height * self.spatial_downsample_factor * self.sr_ratio)
+        real_tile_sample_min_width = int(self.tile_latent_min_width * self.spatial_downsample_factor * self.sr_ratio)
+        real_tile_sample_min_length = int(self.tile_latent_min_length * self.temporal_downsample_factor)
+
+        blend_extent_h = int(real_tile_sample_min_height * self.spatial_tile_overlap_factor)
+        blend_extent_w = int(real_tile_sample_min_width * self.spatial_tile_overlap_factor)
+        blend_extent_t = int(real_tile_sample_min_length * self.temporal_tile_overlap_factor)
+
+        height_limit = real_tile_sample_min_height - blend_extent_h
+        width_limit = real_tile_sample_min_width - blend_extent_w
+        frame_limit = real_tile_sample_min_length - blend_extent_t
+
+        length_tile_size = (z.shape[2] + overlap_length - 1) // overlap_length
+        height_tile_size = (z.shape[3] + overlap_height - 1) // overlap_height
+        width_tile_size = (z.shape[4] + overlap_width - 1) // overlap_width
+        total_tile_size = length_tile_size * height_tile_size * width_tile_size
+        for_loop_size = [length_tile_size, height_tile_size, width_tile_size]
+
+        tiles = []
+        tile_numel_dict = OrderedDict()
+        for tile_index in range(total_tile_size):
+            undot_tile_index = ParallelHelper.index_undot(tile_index, for_loop_size)
+            f_idx, i_idx, j_idx = undot_tile_index
+            f = f_idx * overlap_length
+            i = i_idx * overlap_height
+            j = j_idx * overlap_width
+
+            # Extract the tile from the latent representation and decode it
+            tile = z[
+                :,
+                :,
+                f : f + self.tile_latent_min_length,
+                i : i + self.tile_latent_min_height,
+                j : j + self.tile_latent_min_width,
+            ]
+            tiles.append(tile)
+            tile_numel_dict[tile_index] = tile.numel()
+        tile_index_list, global_tile_index_list = ParallelHelper.split_tile_list(
+            tile_numel_dict, parallel_group=self.parallel_group
+        )
+        progress_bar = tqdm(
+            total=len(tile_index_list),
+            desc=f"[Rank {torch.distributed.get_rank(group=self.parallel_group)}] Decoding Tiles",
+            disable=not verbose,
+        )
+
+        frames = []
+        # Decode each tile based on the tile index list
+        for tile_index in tile_index_list:
+            tile = tiles[tile_index]
+            decoded = self.decode_fn(tile)
+            frames.append(decoded)
+            progress_bar.update(1)
+
+        progress_bar.close()
+        # Gather all decoded frames from different ranks
+        frames = ParallelHelper.gather_frames(frames, global_tile_index_list, parallel_group=self.parallel_group)
+        assert len(frames) == total_tile_size
+
+        result_frames = []
+        # Blend the decoded tiles to create the final output
+        for tile_index in tile_index_list:
+            undot_tile_index = ParallelHelper.index_undot(tile_index, for_loop_size)
+            f, i, j = undot_tile_index
+
+            tile = frames[tile_index].clone()
+            # Blend with previous tiles if applicable
+            if f > 0:
+                idx = ParallelHelper.index_dot([f - 1, i, j], for_loop_size)
+                tile = torch.compile(self.blend_t, dynamic=False)(frames[idx], tile, blend_extent_t)
+            if i > 0:
+                idx = ParallelHelper.index_dot([f, i - 1, j], for_loop_size)
+                tile = torch.compile(self.blend_v, dynamic=False)(frames[idx], tile, blend_extent_h)
+            if j > 0:
+                idx = ParallelHelper.index_dot([f, i, j - 1], for_loop_size)
+                tile = torch.compile(self.blend_h, dynamic=False)(frames[idx], tile, blend_extent_w)
+            result_frames.append(tile[:, :, :frame_limit, :height_limit, :width_limit])
+
+        # Gather and concatenate the final result frames
+        result_frames = ParallelHelper.gather_frames(result_frames, global_tile_index_list, parallel_group=self.parallel_group)
+        assert len(result_frames) == total_tile_size
+
+        concat_frames = []
+        for f in range(length_tile_size):
+            result_rows = []
+            for i in range(height_tile_size):
+                result_row = []
+                for j in range(width_tile_size):
+                    idx = ParallelHelper.index_dot([f, i, j], for_loop_size)
+                    result_row.append(result_frames[idx])
+                result_rows.append(torch.cat(result_row, dim=4))
+            concat_frames.append(torch.cat(result_rows, dim=3))
+
+        # Concatenate all result frames along the temporal dimension
+        result = torch.cat(concat_frames, dim=2)
+        return result

FlowCache/FlowCache4MAGI-1-dev-V1/inference/model/dit/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2025 SandAI. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .dit_model import get_dit, VideoDiTModel
+from .dit_module import FullyParallelAttention
+
+__all__ = ["get_dit", "VideoDiTModel", "FullyParallelAttention"]