feat(gemma): build one dual-profile plan when a split pair cannot fit, and qualify gemma-3-27b

apps/benchmark/performance/release.yaml

@@ -92,6 +92,8 @@ excluded_profiles:
     reason: *gemma3_performance_exclusion
   - model: gemma-3-12b
     reason: *gemma3_performance_exclusion
+  - model: gemma-3-27b
+    reason: *gemma3_performance_exclusion
   - model: gemma-3-1b
     reason: >-
       Functional and Hugging Face reference-parity qualification is present,

families/gemma/model.py

@@ -359,6 +359,36 @@ def _runtime_config(model_dir: Path, config: ModelConfig, **updates) -> dict:
     return runtime
 
 
+# The split layout stores the weights twice: a prefill engine with a dynamic
+# sequence axis plus a decode engine with a static Sq=1 graph. That duplication
+# buys decode throughput - measured with apps/benchmark at about 6% on
+# gemma-3-4b - and it is worth paying while the pair fits.
+#
+# It stops being a trade when the pair cannot be loaded at all. gemma-3-27b at
+# bf16 needs about 50 GiB per engine, and TensorRT fails deserializing the
+# second one on an 80 GiB H100 with
+# "OutOfMemory (Requested size was 56842909440 bytes.)".
+#
+# 28 GiB per engine keeps every qualified Gemma on the split pair. Measured with
+# this estimator: gemma-3-4b 8.9 GiB, gemma-3-12b 25.0 GiB, gemma-3-27b
+# 55.6 GiB. Erring low is safe and erring high is not - a model that falls back
+# unnecessarily is about 6% slower to decode, while a model that stays on split
+# and does not fit cannot be loaded at all.
+_MAX_SPLIT_ENGINE_BYTES = 28 * 1024**3
+
+# A serialized plan runs a little over the raw weights. Checked against two
+# measured points: gemma-3-4b's engines are 8.5 GiB each and this returns
+# 8.9 GiB; TensorRT asked 52.9 GiB for gemma-3-27b and this returns 55.6 GiB.
+_PLAN_OVERHEAD = 1.05
+
+
+def _decoder_engine_bytes(weights: "WeightDict", precision: str) -> int:
+    """Roughly what one decoder engine will occupy on the device."""
+    element = 2 if str(precision).lower() in {"fp16", "bf16"} else 4
+    parameters = sum(int(getattr(value, "size", 0)) for value in weights.values())
+    return int(parameters * element * _PLAN_OVERHEAD)
+
+
 def build(request: "BuildRequest", writer: "BundleWriter") -> None:
     """Build one Gemma bundle through family-owned code only."""
     if request.dynamic_kv_cache:
@@ -441,6 +471,21 @@ def build(request: "BuildRequest", writer: "BundleWriter") -> None:
             )
             writer.add_bytes(f"engine.rank{rank}.plan", plan)
         layout = "dual_profile"
+    elif _decoder_engine_bytes(weights, precision) > _MAX_SPLIT_ENGINE_BYTES:
+        # One plan carrying both profiles, so the weights are stored once.
+        config.raw["_decoder_engine_role"] = "dual_profile"
+        plan = model.build_engine(
+            config,
+            weights,
+            max_sequence_length,
+            precision=precision,
+            quant_ctx=None,
+            verbose=bool(request.verbose),
+            parallel_config=parallel,
+        )
+        config.raw.pop("_decoder_engine_role", None)
+        writer.add_bytes("engine.plan", plan)
+        layout = "dual_profile"
     else:
         config.raw["_decoder_engine_role"] = "prefill"
         prefill = model.build_engine(

families/gemma/tests/manifests/gemma-3-27b.json

@@ -0,0 +1,22 @@
+{
+  "name": "gemma-3-27b",
+  "hf_id": "google/gemma-3-27b-it",
+  "bundle": "gemma-3-27b.bundle",
+  "family": "gemma",
+  "task": "text_generation",
+  "precision": "bf16",
+  "trust_remote_code": false,
+  "testcases": [
+    {
+      "name": "gemma-3-27b",
+      "premerge": true,
+      "reference_precision": "fp32",
+      "prompt": "What is the capital of France? Answer with just the name.",
+      "max_new_tokens": 8,
+      "use_chat_template": true,
+      "enable_thinking": false
+    }
+  ],
+  "max_sequence_length": 256,
+  "tensor_parallel_size": 1
+}

families/gemma/tests/test_split_engine_budget.py

@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""A Gemma too large for a split pair must build one dual-profile plan instead.
+
+The split layout keeps a separate decode engine with a static Sq=1 graph, which
+costs a second full copy of the weights on the device. gemma-3-27b at bf16 needs
+about 50 GiB per engine, so the pair cannot be deserialized on an 80 GiB device.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from families.gemma.model import (
+    _MAX_SPLIT_ENGINE_BYTES,
+    _decoder_engine_bytes,
+)
+
+
+def _weights(parameters: int) -> dict:
+    return {"w": np.zeros(parameters, dtype=np.float32)}
+
+
+def test_bytes_follow_the_build_precision():
+    half = _decoder_engine_bytes(_weights(1_000_000), "bf16")
+    full = _decoder_engine_bytes(_weights(1_000_000), "fp32")
+
+    assert full == 2 * half
+    # 1e6 parameters at 2 bytes, plus the measured plan overhead.
+    assert half == int(1_000_000 * 2 * 1.05)
+
+
+def test_the_qualified_widths_stay_on_split():
+    # Parameter counts of the shipped text decoders.
+    for parameters in (0.27e9, 1.00e9, 2.61e9, 3.88e9, 11.77e9):
+        assert _decoder_engine_bytes(_weights(int(parameters)), "bf16") <= _MAX_SPLIT_ENGINE_BYTES
+
+
+def test_27b_exceeds_the_split_budget():
+    assert _decoder_engine_bytes(_weights(int(27.01e9)), "bf16") > _MAX_SPLIT_ENGINE_BYTES
+
+
+def test_the_budget_leaves_room_for_a_pair_on_an_80_gib_device():
+    """Both engines plus working memory have to fit, not just the weights."""
+    assert 2 * _MAX_SPLIT_ENGINE_BYTES < 80 * 1024**3