Promote latest kernel artifacts to main

README.md

@@ -1,9 +1,62 @@
-# flashrt/transformer-fused-ops
+# transformer-fused-ops
 
-This repository is a compatibility mirror for older `kernels` clients
-that resolve repositories through the default Hugging Face model repo API.
+FlashRT native CUDA fused helper kernels for transformer hot paths.
 
-Canonical Kernel Hub repo: https://huggingface.co/kernels/flashrt/transformer-fused-ops
+## Functions
 
-Do not edit this mirror by hand. It is generated from the Kernel Hub
-`vN` branches and contains the same `build/**` artifacts.
+- `rms_norm_gated_silu_bf16`
+- `silu_mul_bf16`
+- `sigmoid_mul_bf16`
+- `embedding_lookup_bf16`
+- `partial_rope_qk_bf16`
+- `argmax_bf16`
+- `spec_accept_greedy_bf16`
+- `nexn2_lin_split_qkv_broadcast_bf16`
+- `nexn2_split_q_gate_bf16`
+- `nexn2_router_topk_bf16`
+- `router_topk_bf16`
+- `moe_weighted_sum_bf16_to_fp32`
+- `relu2_quantize_fp8_static_bf16(input, scale, out=None)`
+- `rms_norm_fp16(x, weight, eps=1e-6, out=None)`
+- `layer_norm_fp16(x, weight, bias, eps=1e-6, out=None)`
+- `layer_norm_quant_fp8_static_fp16(x, weight, bias, scale, eps=1e-6, out=None)`
+- `rope_rotate_half_fp16_(x, cos, sin)`
+- `quantize_fp8_static_fp16(x, scale, out=None)`
+- `quantize_fp8_static_bf16(x, scale, out=None)`
+- `layer_norm_quant_fp8_static_bf16(x, weight, bias, scale, eps=1e-6, out=None)`
+- `gate_geglu_merged_quant_fp8_static_bf16(merged, scale, out=None)`
+- `residual_add_fp16_(residual, x)`
+- `repeat_interleave_heads_fp16(x, repeat, out=None)`
+
+These are Tensor APIs meant for static-buffer runtimes and CUDA Graph friendly
+model demos. Unsupported shapes fail explicitly.
+
+`relu2_quantize_fp8_static_bf16` fuses ReLU-squared and static-scale FP8 E4M3
+quantization. Pass `out=` for static-buffer and CUDA Graph runtimes.
+
+`router_topk_bf16` is the model-neutral alias for the existing deterministic
+router contract. `moe_weighted_sum_bf16_to_fp32` gathers routed expert rows and
+accumulates router-weighted BF16 expert outputs into an FP32 token output.
+
+The FP16 vector family is the native GROOT N1.7 Thor hot path. It covers
+ViT/LLM normalization, split-half RoPE, FP8 production, residual update, and
+GQA head expansion. These entries require SM110 and CUDA 13; unsupported
+architectures fail before launch. Static `out=` buffers and the in-place
+entries are suitable for CUDA Graph replay.
+
+The additive SM110 BF16 producer family covers PI0.5 prefill and SigLIP hot
+paths. `quantize_fp8_static_bf16` computes
+`clamp(x / scale, -448, 448)` into FP8 E4M3. The LayerNorm entry performs FP32
+statistics, rounds the normalized value to BF16, and emits FP8 without an
+intermediate tensor. The merged GeGLU entry splits `(M,2H)` into gate/up,
+applies the native tanh-GELU approximation, multiplies by up, and emits static
+FP8 `(M,H)`. All three require SM110 and support static `out=` buffers.
+
+## Validation
+
+```bash
+python transformer-fused-ops/tests/test_transformer_fused_ops.py --backend source --mode full
+```
+
+The full SM110 grid includes non-vector-aligned tails and PI0.5/SigLIP shapes,
+plus `torch.compile(fullgraph=True)` and CUDA Graph replay gates.

build/torch211-cxx11-cu128-x86_64-linux/__init__.py

@@ -143,18 +143,21 @@ def _relu2_quantize_fp8_static_fake(
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16_vec"))
 def _rms_norm_fp16_fake(x, weight, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16_vec"))
 def _layer_norm_fp16_fake(x, weight, bias, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp8_static_fp16_vec"))
 def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
@@ -163,24 +166,50 @@ def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, o
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_vec"))
 def _rope_rotate_half_fp16_fake(x, cos, sin) -> None:
     if x.dim() != 3 or cos.shape != (x.shape[0], x.shape[2]) or sin.shape != cos.shape:
         raise RuntimeError("expected x (sequence,heads,head_dim), cos/sin (sequence,head_dim)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16_vec"))
 def _quantize_fp8_static_fp16_fake(x, scale, out) -> None:
     if scale.numel() != 1 or out.shape != x.shape:
         raise RuntimeError("output must match x and scale must contain one value")
 
 
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_bf16"))
+def _quantize_fp8_static_bf16_fake(x, scale, out) -> None:
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_bf16"))
+def _layer_norm_quant_fp8_static_bf16_fake(x, weight, bias, scale, eps: float, out) -> None:
+    if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape:
+        raise RuntimeError("expected x (rows,dim), weight/bias (dim,)")
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("gate_geglu_merged_quant_fp8_static_bf16"))
+def _gate_geglu_merged_quant_fp8_static_bf16_fake(merged, scale, out) -> None:
+    if merged.dim() != 2 or merged.shape[1] % 2:
+        raise RuntimeError("merged must have shape (rows, 2 * hidden)")
+    if scale.numel() != 1 or out.shape != (merged.shape[0], merged.shape[1] // 2):
+        raise RuntimeError("output must have shape (rows, hidden) and scale must be scalar")
+
+
 @torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_vec"))
 def _residual_add_fp16_fake(residual, x) -> None:
     if residual.shape != x.shape:
         raise RuntimeError("residual and x must have the same shape")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("repeat_interleave_heads_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("gpu_repeat_interleave_heads_vec"))
 def _repeat_interleave_heads_fp16_fake(x, repeat: int, out) -> None:
     if x.dim() != 3 or out.shape != (x.shape[0], x.shape[1] * repeat, x.shape[2]):
         raise RuntimeError("output shape must be (sequence, heads * repeat, head_dim)")
@@ -322,6 +351,13 @@ def rms_norm_fp16(x, weight, *, eps: float = 1e-6, out=None):
     return out
 
 
+def rms_norm_fp16_vec(x, weight, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.rms_norm_fp16_vec(x, weight, float(eps), out)
+    return out
+
+
 def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     if out is None:
         out = torch.empty_like(x)
@@ -329,6 +365,13 @@ def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     return out
 
 
+def layer_norm_fp16_vec(x, weight, bias, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.layer_norm_fp16_vec(x, weight, bias, float(eps), out)
+    return out
+
+
 def layer_norm_quant_fp8_static_fp16(
     x, weight, bias, scale, *, eps: float = 1e-6, out=None
 ):
@@ -340,11 +383,27 @@ def layer_norm_quant_fp8_static_fp16(
     return out
 
 
+def layer_norm_fp8_static_fp16_vec(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_fp8_static_fp16_vec(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
 def rope_rotate_half_fp16_(x, cos, sin):
     ops.rope_rotate_half_fp16_(x, cos, sin)
     return x
 
 
+def rope_rotate_half_fp16_vec(x, cos, sin):
+    ops.rope_rotate_half_fp16_vec(x, cos, sin)
+    return x
+
+
 def quantize_fp8_static_fp16(x, scale, *, out=None):
     if out is None:
         out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
@@ -352,11 +411,55 @@ def quantize_fp8_static_fp16(x, scale, *, out=None):
     return out
 
 
+def quantize_fp8_static_fp16_vec(x, scale, *, out=None):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_fp16_vec(x, scale, out)
+    return out
+
+
+def quantize_fp8_static_bf16(x, scale, *, out=None):
+    """Quantize contiguous BF16 input with a static FP32 scale."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_bf16(x, scale, out)
+    return out
+
+
+def layer_norm_quant_fp8_static_bf16(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    """LayerNorm BF16 input and emit static-scale FP8 without an intermediate."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_quant_fp8_static_bf16(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
+def gate_geglu_merged_quant_fp8_static_bf16(merged, scale, *, out=None):
+    """Apply tanh-approximate GeGLU to merged BF16 gate/up and emit FP8."""
+    if out is None:
+        out = torch.empty(
+            (merged.shape[0], merged.shape[1] // 2),
+            device=merged.device,
+            dtype=torch.float8_e4m3fn,
+        )
+    ops.gate_geglu_merged_quant_fp8_static_bf16(merged, scale, out)
+    return out
+
+
 def residual_add_fp16_(residual, x):
     ops.residual_add_fp16_(residual, x)
     return residual
 
 
+def residual_add_fp16_vec(residual, x):
+    ops.residual_add_fp16_vec(residual, x)
+    return residual
+
+
 def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     if out is None:
         out = torch.empty(
@@ -368,6 +471,17 @@ def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     return out
 
 
+def gpu_repeat_interleave_heads_vec(x, repeat: int, *, out=None):
+    if out is None:
+        out = torch.empty(
+            (x.shape[0], x.shape[1] * repeat, x.shape[2]),
+            device=x.device,
+            dtype=x.dtype,
+        )
+    ops.gpu_repeat_interleave_heads_vec(x, int(repeat), out)
+    return out
+
+
 __all__ = [
     "argmax_bf16",
     "embedding_lookup_bf16",
@@ -383,10 +497,20 @@ __all__ = [
     "router_topk_bf16",
     "moe_weighted_sum_bf16_to_fp32",
     "layer_norm_fp16",
+    "layer_norm_fp16_vec",
+    "layer_norm_fp8_static_fp16_vec",
     "layer_norm_quant_fp8_static_fp16",
     "quantize_fp8_static_fp16",
+    "quantize_fp8_static_fp16_vec",
+    "quantize_fp8_static_bf16",
+    "layer_norm_quant_fp8_static_bf16",
+    "gate_geglu_merged_quant_fp8_static_bf16",
     "repeat_interleave_heads_fp16",
+    "gpu_repeat_interleave_heads_vec",
     "residual_add_fp16_",
+    "residual_add_fp16_vec",
     "rms_norm_fp16",
+    "rms_norm_fp16_vec",
     "rope_rotate_half_fp16_",
+    "rope_rotate_half_fp16_vec",
 ]

build/torch211-cxx11-cu128-x86_64-linux/_ops.py

@@ -1,9 +1,9 @@
 import torch
-from . import _transformer_fused_ops_cuda_8a66d8b
-ops = torch.ops._transformer_fused_ops_cuda_8a66d8b
+from . import _transformer_fused_ops_cuda_6ab0803
+ops = torch.ops._transformer_fused_ops_cuda_6ab0803
 
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_transformer_fused_ops_cuda_8a66d8b::{op_name}"
+    return f"_transformer_fused_ops_cuda_6ab0803::{op_name}"

build/torch211-cxx11-cu128-x86_64-linux/{_transformer_fused_ops_cuda_8a66d8b.abi3.so → _transformer_fused_ops_cuda_6ab0803.abi3.so}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0a57fd82524162fdc6ba902b3c66a23fc781b94abd8d7908dcbc6ca1bb76d57d
-size 1334184
+oid sha256:03e9157b8c1f8cdd1d3df022da2c813f03e1846393fb4a80395cd0dea041952e
+size 1344152

build/torch211-cxx11-cu128-x86_64-linux/metadata.json

@@ -1,6 +1,6 @@
 {
   "name": "transformer-fused-ops",
-  "id": "_transformer_fused_ops_cuda_8a66d8b",
+  "id": "_transformer_fused_ops_cuda_6ab0803",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],

build/torch211-cxx11-cu130-x86_64-linux/__init__.py

@@ -143,18 +143,21 @@ def _relu2_quantize_fp8_static_fake(
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16_vec"))
 def _rms_norm_fp16_fake(x, weight, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16_vec"))
 def _layer_norm_fp16_fake(x, weight, bias, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp8_static_fp16_vec"))
 def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
@@ -163,24 +166,50 @@ def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, o
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_vec"))
 def _rope_rotate_half_fp16_fake(x, cos, sin) -> None:
     if x.dim() != 3 or cos.shape != (x.shape[0], x.shape[2]) or sin.shape != cos.shape:
         raise RuntimeError("expected x (sequence,heads,head_dim), cos/sin (sequence,head_dim)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16_vec"))
 def _quantize_fp8_static_fp16_fake(x, scale, out) -> None:
     if scale.numel() != 1 or out.shape != x.shape:
         raise RuntimeError("output must match x and scale must contain one value")
 
 
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_bf16"))
+def _quantize_fp8_static_bf16_fake(x, scale, out) -> None:
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_bf16"))
+def _layer_norm_quant_fp8_static_bf16_fake(x, weight, bias, scale, eps: float, out) -> None:
+    if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape:
+        raise RuntimeError("expected x (rows,dim), weight/bias (dim,)")
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("gate_geglu_merged_quant_fp8_static_bf16"))
+def _gate_geglu_merged_quant_fp8_static_bf16_fake(merged, scale, out) -> None:
+    if merged.dim() != 2 or merged.shape[1] % 2:
+        raise RuntimeError("merged must have shape (rows, 2 * hidden)")
+    if scale.numel() != 1 or out.shape != (merged.shape[0], merged.shape[1] // 2):
+        raise RuntimeError("output must have shape (rows, hidden) and scale must be scalar")
+
+
 @torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_vec"))
 def _residual_add_fp16_fake(residual, x) -> None:
     if residual.shape != x.shape:
         raise RuntimeError("residual and x must have the same shape")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("repeat_interleave_heads_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("gpu_repeat_interleave_heads_vec"))
 def _repeat_interleave_heads_fp16_fake(x, repeat: int, out) -> None:
     if x.dim() != 3 or out.shape != (x.shape[0], x.shape[1] * repeat, x.shape[2]):
         raise RuntimeError("output shape must be (sequence, heads * repeat, head_dim)")
@@ -322,6 +351,13 @@ def rms_norm_fp16(x, weight, *, eps: float = 1e-6, out=None):
     return out
 
 
+def rms_norm_fp16_vec(x, weight, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.rms_norm_fp16_vec(x, weight, float(eps), out)
+    return out
+
+
 def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     if out is None:
         out = torch.empty_like(x)
@@ -329,6 +365,13 @@ def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     return out
 
 
+def layer_norm_fp16_vec(x, weight, bias, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.layer_norm_fp16_vec(x, weight, bias, float(eps), out)
+    return out
+
+
 def layer_norm_quant_fp8_static_fp16(
     x, weight, bias, scale, *, eps: float = 1e-6, out=None
 ):
@@ -340,11 +383,27 @@ def layer_norm_quant_fp8_static_fp16(
     return out
 
 
+def layer_norm_fp8_static_fp16_vec(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_fp8_static_fp16_vec(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
 def rope_rotate_half_fp16_(x, cos, sin):
     ops.rope_rotate_half_fp16_(x, cos, sin)
     return x
 
 
+def rope_rotate_half_fp16_vec(x, cos, sin):
+    ops.rope_rotate_half_fp16_vec(x, cos, sin)
+    return x
+
+
 def quantize_fp8_static_fp16(x, scale, *, out=None):
     if out is None:
         out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
@@ -352,11 +411,55 @@ def quantize_fp8_static_fp16(x, scale, *, out=None):
     return out
 
 
+def quantize_fp8_static_fp16_vec(x, scale, *, out=None):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_fp16_vec(x, scale, out)
+    return out
+
+
+def quantize_fp8_static_bf16(x, scale, *, out=None):
+    """Quantize contiguous BF16 input with a static FP32 scale."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_bf16(x, scale, out)
+    return out
+
+
+def layer_norm_quant_fp8_static_bf16(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    """LayerNorm BF16 input and emit static-scale FP8 without an intermediate."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_quant_fp8_static_bf16(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
+def gate_geglu_merged_quant_fp8_static_bf16(merged, scale, *, out=None):
+    """Apply tanh-approximate GeGLU to merged BF16 gate/up and emit FP8."""
+    if out is None:
+        out = torch.empty(
+            (merged.shape[0], merged.shape[1] // 2),
+            device=merged.device,
+            dtype=torch.float8_e4m3fn,
+        )
+    ops.gate_geglu_merged_quant_fp8_static_bf16(merged, scale, out)
+    return out
+
+
 def residual_add_fp16_(residual, x):
     ops.residual_add_fp16_(residual, x)
     return residual
 
 
+def residual_add_fp16_vec(residual, x):
+    ops.residual_add_fp16_vec(residual, x)
+    return residual
+
+
 def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     if out is None:
         out = torch.empty(
@@ -368,6 +471,17 @@ def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     return out
 
 
+def gpu_repeat_interleave_heads_vec(x, repeat: int, *, out=None):
+    if out is None:
+        out = torch.empty(
+            (x.shape[0], x.shape[1] * repeat, x.shape[2]),
+            device=x.device,
+            dtype=x.dtype,
+        )
+    ops.gpu_repeat_interleave_heads_vec(x, int(repeat), out)
+    return out
+
+
 __all__ = [
     "argmax_bf16",
     "embedding_lookup_bf16",
@@ -383,10 +497,20 @@ __all__ = [
     "router_topk_bf16",
     "moe_weighted_sum_bf16_to_fp32",
     "layer_norm_fp16",
+    "layer_norm_fp16_vec",
+    "layer_norm_fp8_static_fp16_vec",
     "layer_norm_quant_fp8_static_fp16",
     "quantize_fp8_static_fp16",
+    "quantize_fp8_static_fp16_vec",
+    "quantize_fp8_static_bf16",
+    "layer_norm_quant_fp8_static_bf16",
+    "gate_geglu_merged_quant_fp8_static_bf16",
     "repeat_interleave_heads_fp16",
+    "gpu_repeat_interleave_heads_vec",
     "residual_add_fp16_",
+    "residual_add_fp16_vec",
     "rms_norm_fp16",
+    "rms_norm_fp16_vec",
     "rope_rotate_half_fp16_",
+    "rope_rotate_half_fp16_vec",
 ]

build/torch211-cxx11-cu130-x86_64-linux/_ops.py

@@ -1,9 +1,9 @@
 import torch
-from . import _transformer_fused_ops_cuda_8a66d8b
-ops = torch.ops._transformer_fused_ops_cuda_8a66d8b
+from . import _transformer_fused_ops_cuda_6ab0803
+ops = torch.ops._transformer_fused_ops_cuda_6ab0803
 
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_transformer_fused_ops_cuda_8a66d8b::{op_name}"
+    return f"_transformer_fused_ops_cuda_6ab0803::{op_name}"

build/torch211-cxx11-cu130-x86_64-linux/{_transformer_fused_ops_cuda_8a66d8b.abi3.so → _transformer_fused_ops_cuda_6ab0803.abi3.so}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:cc056c44ce9eac90550ce8a453a48fb7c2fa4d415a6d9fded9781af19ba3831e
-size 1457632
+oid sha256:849e913f333d358de0aaf889e745c66909a2821a959872c3c1d3d76de1b969af
+size 1533912

build/torch211-cxx11-cu130-x86_64-linux/metadata.json

@@ -1,6 +1,6 @@
 {
   "name": "transformer-fused-ops",
-  "id": "_transformer_fused_ops_cuda_8a66d8b",
+  "id": "_transformer_fused_ops_cuda_6ab0803",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],

build/torch212-cxx11-cu130-x86_64-linux/__init__.py

@@ -143,18 +143,21 @@ def _relu2_quantize_fp8_static_fake(
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16_vec"))
 def _rms_norm_fp16_fake(x, weight, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16_vec"))
 def _layer_norm_fp16_fake(x, weight, bias, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp8_static_fp16_vec"))
 def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
@@ -163,24 +166,50 @@ def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, o
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_vec"))
 def _rope_rotate_half_fp16_fake(x, cos, sin) -> None:
     if x.dim() != 3 or cos.shape != (x.shape[0], x.shape[2]) or sin.shape != cos.shape:
         raise RuntimeError("expected x (sequence,heads,head_dim), cos/sin (sequence,head_dim)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16_vec"))
 def _quantize_fp8_static_fp16_fake(x, scale, out) -> None:
     if scale.numel() != 1 or out.shape != x.shape:
         raise RuntimeError("output must match x and scale must contain one value")
 
 
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_bf16"))
+def _quantize_fp8_static_bf16_fake(x, scale, out) -> None:
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_bf16"))
+def _layer_norm_quant_fp8_static_bf16_fake(x, weight, bias, scale, eps: float, out) -> None:
+    if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape:
+        raise RuntimeError("expected x (rows,dim), weight/bias (dim,)")
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("gate_geglu_merged_quant_fp8_static_bf16"))
+def _gate_geglu_merged_quant_fp8_static_bf16_fake(merged, scale, out) -> None:
+    if merged.dim() != 2 or merged.shape[1] % 2:
+        raise RuntimeError("merged must have shape (rows, 2 * hidden)")
+    if scale.numel() != 1 or out.shape != (merged.shape[0], merged.shape[1] // 2):
+        raise RuntimeError("output must have shape (rows, hidden) and scale must be scalar")
+
+
 @torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_vec"))
 def _residual_add_fp16_fake(residual, x) -> None:
     if residual.shape != x.shape:
         raise RuntimeError("residual and x must have the same shape")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("repeat_interleave_heads_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("gpu_repeat_interleave_heads_vec"))
 def _repeat_interleave_heads_fp16_fake(x, repeat: int, out) -> None:
     if x.dim() != 3 or out.shape != (x.shape[0], x.shape[1] * repeat, x.shape[2]):
         raise RuntimeError("output shape must be (sequence, heads * repeat, head_dim)")
@@ -322,6 +351,13 @@ def rms_norm_fp16(x, weight, *, eps: float = 1e-6, out=None):
     return out
 
 
+def rms_norm_fp16_vec(x, weight, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.rms_norm_fp16_vec(x, weight, float(eps), out)
+    return out
+
+
 def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     if out is None:
         out = torch.empty_like(x)
@@ -329,6 +365,13 @@ def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     return out
 
 
+def layer_norm_fp16_vec(x, weight, bias, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.layer_norm_fp16_vec(x, weight, bias, float(eps), out)
+    return out
+
+
 def layer_norm_quant_fp8_static_fp16(
     x, weight, bias, scale, *, eps: float = 1e-6, out=None
 ):
@@ -340,11 +383,27 @@ def layer_norm_quant_fp8_static_fp16(
     return out
 
 
+def layer_norm_fp8_static_fp16_vec(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_fp8_static_fp16_vec(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
 def rope_rotate_half_fp16_(x, cos, sin):
     ops.rope_rotate_half_fp16_(x, cos, sin)
     return x
 
 
+def rope_rotate_half_fp16_vec(x, cos, sin):
+    ops.rope_rotate_half_fp16_vec(x, cos, sin)
+    return x
+
+
 def quantize_fp8_static_fp16(x, scale, *, out=None):
     if out is None:
         out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
@@ -352,11 +411,55 @@ def quantize_fp8_static_fp16(x, scale, *, out=None):
     return out
 
 
+def quantize_fp8_static_fp16_vec(x, scale, *, out=None):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_fp16_vec(x, scale, out)
+    return out
+
+
+def quantize_fp8_static_bf16(x, scale, *, out=None):
+    """Quantize contiguous BF16 input with a static FP32 scale."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_bf16(x, scale, out)
+    return out
+
+
+def layer_norm_quant_fp8_static_bf16(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    """LayerNorm BF16 input and emit static-scale FP8 without an intermediate."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_quant_fp8_static_bf16(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
+def gate_geglu_merged_quant_fp8_static_bf16(merged, scale, *, out=None):
+    """Apply tanh-approximate GeGLU to merged BF16 gate/up and emit FP8."""
+    if out is None:
+        out = torch.empty(
+            (merged.shape[0], merged.shape[1] // 2),
+            device=merged.device,
+            dtype=torch.float8_e4m3fn,
+        )
+    ops.gate_geglu_merged_quant_fp8_static_bf16(merged, scale, out)
+    return out
+
+
 def residual_add_fp16_(residual, x):
     ops.residual_add_fp16_(residual, x)
     return residual
 
 
+def residual_add_fp16_vec(residual, x):
+    ops.residual_add_fp16_vec(residual, x)
+    return residual
+
+
 def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     if out is None:
         out = torch.empty(
@@ -368,6 +471,17 @@ def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     return out
 
 
+def gpu_repeat_interleave_heads_vec(x, repeat: int, *, out=None):
+    if out is None:
+        out = torch.empty(
+            (x.shape[0], x.shape[1] * repeat, x.shape[2]),
+            device=x.device,
+            dtype=x.dtype,
+        )
+    ops.gpu_repeat_interleave_heads_vec(x, int(repeat), out)
+    return out
+
+
 __all__ = [
     "argmax_bf16",
     "embedding_lookup_bf16",
@@ -383,10 +497,20 @@ __all__ = [
     "router_topk_bf16",
     "moe_weighted_sum_bf16_to_fp32",
     "layer_norm_fp16",
+    "layer_norm_fp16_vec",
+    "layer_norm_fp8_static_fp16_vec",
     "layer_norm_quant_fp8_static_fp16",
     "quantize_fp8_static_fp16",
+    "quantize_fp8_static_fp16_vec",
+    "quantize_fp8_static_bf16",
+    "layer_norm_quant_fp8_static_bf16",
+    "gate_geglu_merged_quant_fp8_static_bf16",
     "repeat_interleave_heads_fp16",
+    "gpu_repeat_interleave_heads_vec",
     "residual_add_fp16_",
+    "residual_add_fp16_vec",
     "rms_norm_fp16",
+    "rms_norm_fp16_vec",
     "rope_rotate_half_fp16_",
+    "rope_rotate_half_fp16_vec",
 ]

build/torch212-cxx11-cu130-x86_64-linux/_ops.py

@@ -1,9 +1,9 @@
 import torch
-from . import _transformer_fused_ops_cuda_8a66d8b
-ops = torch.ops._transformer_fused_ops_cuda_8a66d8b
+from . import _transformer_fused_ops_cuda_6ab0803
+ops = torch.ops._transformer_fused_ops_cuda_6ab0803
 
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_transformer_fused_ops_cuda_8a66d8b::{op_name}"
+    return f"_transformer_fused_ops_cuda_6ab0803::{op_name}"

build/torch212-cxx11-cu130-x86_64-linux/{_transformer_fused_ops_cuda_8a66d8b.abi3.so → _transformer_fused_ops_cuda_6ab0803.abi3.so}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:27473682b7fde9f2461947ad0730f6edd256282e2ff54f23681051993fcafba3
-size 1463960
+oid sha256:ed5c176316d0ef39d90cc677292c6d7f6ac772b5b51f52bd5e4deb3dcf6fb98c
+size 1544528

build/torch212-cxx11-cu130-x86_64-linux/metadata.json

@@ -1,6 +1,6 @@
 {
   "name": "transformer-fused-ops",
-  "id": "_transformer_fused_ops_cuda_8a66d8b",
+  "id": "_transformer_fused_ops_cuda_6ab0803",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],

build/torch212-cxx11-cu132-x86_64-linux/__init__.py

@@ -143,18 +143,21 @@ def _relu2_quantize_fp8_static_fake(
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("rms_norm_fp16_vec"))
 def _rms_norm_fp16_fake(x, weight, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp16_vec"))
 def _layer_norm_fp16_fake(x, weight, bias, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_fp8_static_fp16_vec"))
 def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, out) -> None:
     if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape or out.shape != x.shape:
         raise RuntimeError("expected x/out (rows,dim), weight/bias (dim,)")
@@ -163,24 +166,50 @@ def _layer_norm_quant_fp8_static_fp16_fake(x, weight, bias, scale, eps: float, o
 
 
 @torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("rope_rotate_half_fp16_vec"))
 def _rope_rotate_half_fp16_fake(x, cos, sin) -> None:
     if x.dim() != 3 or cos.shape != (x.shape[0], x.shape[2]) or sin.shape != cos.shape:
         raise RuntimeError("expected x (sequence,heads,head_dim), cos/sin (sequence,head_dim)")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_fp16_vec"))
 def _quantize_fp8_static_fp16_fake(x, scale, out) -> None:
     if scale.numel() != 1 or out.shape != x.shape:
         raise RuntimeError("output must match x and scale must contain one value")
 
 
+@torch.library.register_fake(add_op_namespace_prefix("quantize_fp8_static_bf16"))
+def _quantize_fp8_static_bf16_fake(x, scale, out) -> None:
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("layer_norm_quant_fp8_static_bf16"))
+def _layer_norm_quant_fp8_static_bf16_fake(x, weight, bias, scale, eps: float, out) -> None:
+    if x.dim() != 2 or weight.shape != (x.shape[1],) or bias.shape != weight.shape:
+        raise RuntimeError("expected x (rows,dim), weight/bias (dim,)")
+    if scale.numel() != 1 or out.shape != x.shape:
+        raise RuntimeError("output must match x and scale must contain one value")
+
+
+@torch.library.register_fake(add_op_namespace_prefix("gate_geglu_merged_quant_fp8_static_bf16"))
+def _gate_geglu_merged_quant_fp8_static_bf16_fake(merged, scale, out) -> None:
+    if merged.dim() != 2 or merged.shape[1] % 2:
+        raise RuntimeError("merged must have shape (rows, 2 * hidden)")
+    if scale.numel() != 1 or out.shape != (merged.shape[0], merged.shape[1] // 2):
+        raise RuntimeError("output must have shape (rows, hidden) and scale must be scalar")
+
+
 @torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_"))
+@torch.library.register_fake(add_op_namespace_prefix("residual_add_fp16_vec"))
 def _residual_add_fp16_fake(residual, x) -> None:
     if residual.shape != x.shape:
         raise RuntimeError("residual and x must have the same shape")
 
 
 @torch.library.register_fake(add_op_namespace_prefix("repeat_interleave_heads_fp16"))
+@torch.library.register_fake(add_op_namespace_prefix("gpu_repeat_interleave_heads_vec"))
 def _repeat_interleave_heads_fp16_fake(x, repeat: int, out) -> None:
     if x.dim() != 3 or out.shape != (x.shape[0], x.shape[1] * repeat, x.shape[2]):
         raise RuntimeError("output shape must be (sequence, heads * repeat, head_dim)")
@@ -322,6 +351,13 @@ def rms_norm_fp16(x, weight, *, eps: float = 1e-6, out=None):
     return out
 
 
+def rms_norm_fp16_vec(x, weight, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.rms_norm_fp16_vec(x, weight, float(eps), out)
+    return out
+
+
 def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     if out is None:
         out = torch.empty_like(x)
@@ -329,6 +365,13 @@ def layer_norm_fp16(x, weight, bias, *, eps: float = 1e-6, out=None):
     return out
 
 
+def layer_norm_fp16_vec(x, weight, bias, *, eps: float = 1e-6, out=None):
+    if out is None:
+        out = torch.empty_like(x)
+    ops.layer_norm_fp16_vec(x, weight, bias, float(eps), out)
+    return out
+
+
 def layer_norm_quant_fp8_static_fp16(
     x, weight, bias, scale, *, eps: float = 1e-6, out=None
 ):
@@ -340,11 +383,27 @@ def layer_norm_quant_fp8_static_fp16(
     return out
 
 
+def layer_norm_fp8_static_fp16_vec(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_fp8_static_fp16_vec(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
 def rope_rotate_half_fp16_(x, cos, sin):
     ops.rope_rotate_half_fp16_(x, cos, sin)
     return x
 
 
+def rope_rotate_half_fp16_vec(x, cos, sin):
+    ops.rope_rotate_half_fp16_vec(x, cos, sin)
+    return x
+
+
 def quantize_fp8_static_fp16(x, scale, *, out=None):
     if out is None:
         out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
@@ -352,11 +411,55 @@ def quantize_fp8_static_fp16(x, scale, *, out=None):
     return out
 
 
+def quantize_fp8_static_fp16_vec(x, scale, *, out=None):
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_fp16_vec(x, scale, out)
+    return out
+
+
+def quantize_fp8_static_bf16(x, scale, *, out=None):
+    """Quantize contiguous BF16 input with a static FP32 scale."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.quantize_fp8_static_bf16(x, scale, out)
+    return out
+
+
+def layer_norm_quant_fp8_static_bf16(
+    x, weight, bias, scale, *, eps: float = 1e-6, out=None
+):
+    """LayerNorm BF16 input and emit static-scale FP8 without an intermediate."""
+    if out is None:
+        out = torch.empty_like(x, dtype=torch.float8_e4m3fn)
+    ops.layer_norm_quant_fp8_static_bf16(
+        x, weight, bias, scale, float(eps), out
+    )
+    return out
+
+
+def gate_geglu_merged_quant_fp8_static_bf16(merged, scale, *, out=None):
+    """Apply tanh-approximate GeGLU to merged BF16 gate/up and emit FP8."""
+    if out is None:
+        out = torch.empty(
+            (merged.shape[0], merged.shape[1] // 2),
+            device=merged.device,
+            dtype=torch.float8_e4m3fn,
+        )
+    ops.gate_geglu_merged_quant_fp8_static_bf16(merged, scale, out)
+    return out
+
+
 def residual_add_fp16_(residual, x):
     ops.residual_add_fp16_(residual, x)
     return residual
 
 
+def residual_add_fp16_vec(residual, x):
+    ops.residual_add_fp16_vec(residual, x)
+    return residual
+
+
 def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     if out is None:
         out = torch.empty(
@@ -368,6 +471,17 @@ def repeat_interleave_heads_fp16(x, repeat: int, *, out=None):
     return out
 
 
+def gpu_repeat_interleave_heads_vec(x, repeat: int, *, out=None):
+    if out is None:
+        out = torch.empty(
+            (x.shape[0], x.shape[1] * repeat, x.shape[2]),
+            device=x.device,
+            dtype=x.dtype,
+        )
+    ops.gpu_repeat_interleave_heads_vec(x, int(repeat), out)
+    return out
+
+
 __all__ = [
     "argmax_bf16",
     "embedding_lookup_bf16",
@@ -383,10 +497,20 @@ __all__ = [
     "router_topk_bf16",
     "moe_weighted_sum_bf16_to_fp32",
     "layer_norm_fp16",
+    "layer_norm_fp16_vec",
+    "layer_norm_fp8_static_fp16_vec",
     "layer_norm_quant_fp8_static_fp16",
     "quantize_fp8_static_fp16",
+    "quantize_fp8_static_fp16_vec",
+    "quantize_fp8_static_bf16",
+    "layer_norm_quant_fp8_static_bf16",
+    "gate_geglu_merged_quant_fp8_static_bf16",
     "repeat_interleave_heads_fp16",
+    "gpu_repeat_interleave_heads_vec",
     "residual_add_fp16_",
+    "residual_add_fp16_vec",
     "rms_norm_fp16",
+    "rms_norm_fp16_vec",
     "rope_rotate_half_fp16_",
+    "rope_rotate_half_fp16_vec",
 ]

build/torch212-cxx11-cu132-x86_64-linux/_ops.py

@@ -1,9 +1,9 @@
 import torch
-from . import _transformer_fused_ops_cuda_8a66d8b
-ops = torch.ops._transformer_fused_ops_cuda_8a66d8b
+from . import _transformer_fused_ops_cuda_6ab0803
+ops = torch.ops._transformer_fused_ops_cuda_6ab0803
 
 def add_op_namespace_prefix(op_name: str):
     """
     Prefix op by namespace.
     """
-    return f"_transformer_fused_ops_cuda_8a66d8b::{op_name}"
+    return f"_transformer_fused_ops_cuda_6ab0803::{op_name}"

build/torch212-cxx11-cu132-x86_64-linux/{_transformer_fused_ops_cuda_8a66d8b.abi3.so → _transformer_fused_ops_cuda_6ab0803.abi3.so}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:0e61c0f0225f2d4a2698be8615950e0d1e328669b5575543a455307bf1b7a698
-size 1468056
+oid sha256:9a1c470ffbe525f3b95584f9be1045f690721cea885d41cb131ed8d50ad151eb
+size 1552720

build/torch212-cxx11-cu132-x86_64-linux/metadata.json

@@ -1,6 +1,6 @@
 {
   "name": "transformer-fused-ops",
-  "id": "_transformer_fused_ops_cuda_8a66d8b",
+  "id": "_transformer_fused_ops_cuda_6ab0803",
   "version": 1,
   "license": "Apache-2.0",
   "python-depends": [],