"""Structural and configuration guards for the opt-in backward graph rewrite. The pattern fixtures isolate graph safety; actual compiled model numerical and continuation checks live in the separate integration validation harness. """ import copy import hashlib import operator import os from pathlib import Path import pytest import torch from torch._inductor import config from ops import backward_layout_execution as layout from warpstate.config import WarpStateConfig @pytest.fixture(autouse=True) def restore_configuration(monkeypatch): monkeypatch.setattr(layout, "_ACTIVE_PASS", None) monkeypatch.setattr(layout, "_ACTIVE_MODE", "baseline") monkeypatch.setattr(layout, "_COUNTS", layout.Counter()) monkeypatch.setattr(layout, "_MISSES", layout.Counter()) with config.patch({"post_grad_custom_post_pass": None, "emulate_precision_casts": False, "triton.codegen_upcast_to_fp32": True, "eager_numerics.disable_ftz": False}): yield def candidate_graph(): """Attach explicit native GEMM and ordered Flash VJP boundary producers.""" gm = copy.deepcopy(layout._pattern()) graph = gm.graph placeholders = [node for node in graph.nodes if node.op == "placeholder"] values = dict(zip(layout._NAMES, placeholders, strict=True)) first = next(node for node in graph.nodes if node.op == "call_function") with graph.inserting_before(first): flash = graph.call_function(torch.ops.aten._scaled_dot_product_flash_attention_backward.default, (None, None, None, None, values["local"], None, None, None, 128, 128, 0.0, True, None, None), {"scale": 0.125}) for name, index in (("q_local", 0), ("k_local", 1), ("v_local", 2)): old = values[name] new = graph.call_function(operator.getitem, (flash, index)) new.meta = dict(old.meta) old.replace_all_uses_with(new) for name in ("q_memory", "k_write", "u_write", "grad_y"): old = values[name] users = list(old.users) target = torch.ops.aten.mm.default if name == "grad_y" else torch.ops.aten.bmm.default new = graph.call_function(target, (old, old)) new.meta = dict(old.meta) for user in users: user.replace_input_with(old, new) graph.lint() root = next(node for node in graph.nodes if node.op == "output").args[0] return gm, root, flash def test_pattern_is_independent_of_node_names_and_preserves_native_inputs(): gm, root, _ = candidate_graph() for index, node in enumerate(gm.graph.nodes): node.name = f"renamed_{index}" inputs, interior = layout._match(root, layout._pattern()) assert len(inputs) == 14 assert len(interior) > 70 assert tuple(inputs[4].meta["val"].shape) == (2048, 64, 128) assert tuple(inputs[8].meta["val"].shape) == (8192, 2048) def test_inspection_retains_graph_and_replacement_is_pure(): gm, root, _ = candidate_graph() original = str(gm.graph) layout.BackwardLayoutPass("inspect", "inspect-test")(gm.graph) assert str(gm.graph) == original assert layout.backward_layout_stats()["matches"] == 1 layout.BackwardLayoutPass("paired", "paired-test")(gm.graph) gm.graph.lint() calls = [node for node in gm.graph.nodes if node.target == torch.ops.warpstate.paired_backward_layout.default] assert len(calls) == 1 assert root not in gm.graph.nodes assert len(calls[0].args) == 14 assert layout.backward_layout_stats()["replacements"] == 1 assert layout.backward_layout_stats()["runtime_calls"] == 0 @pytest.mark.parametrize("mutation", ["gate_scale", "projection_order", "rotary_lane", "rounding", "dtype", "stride", "dropout", "flash_scale", "flash_order", "input_producer", "missing_meta", "mixed_devices"]) def test_unsupported_graph_is_left_unchanged(mutation): gm, root, flash = candidate_graph() nodes = list(gm.graph.nodes) if mutation == "gate_scale": node = next(n for n in nodes if n.target == torch.ops.aten.div.Tensor) node.args = (node.args[0], 16.0) elif mutation == "projection_order": projections = list(root.args[0]); projections[0], projections[1] = projections[1], projections[0] root.args = (projections, 2) elif mutation == "rotary_lane": node = next(n for n in nodes if n.target == torch.ops.aten.select.int) node.args = (*node.args[:-1], 1 - node.args[-1]) elif mutation == "rounding": node = next(n for n in nodes if n.target == torch.ops.prims.convert_element_type.default) node.args = (node.args[0], torch.float32) elif mutation in ("dtype", "stride", "missing_meta"): if mutation == "missing_meta": root.meta.pop("val") elif mutation == "dtype": root.meta["val"] = root.meta["val"].float() else: root.meta["val"] = root.meta["val"].transpose(1, 2).contiguous().transpose(1, 2) assert tuple(root.meta["val"].shape) == (4, 2048, 10240) elif mutation == "mixed_devices": from torch._subclasses.fake_tensor import FakeTensor node = next(n for n in nodes if n.target == torch.ops.aten.bmm.default) value = node.meta["val"] node.meta["val"] = FakeTensor(value.fake_mode, torch.empty_strided(value.shape, value.stride(), dtype=value.dtype, device="meta"), torch.device("cuda:1")) elif mutation == "dropout": args = list(flash.args); args[10] = 0.1; flash.args = tuple(args) elif mutation == "flash_scale": flash.kwargs = {"scale": 0.25} elif mutation == "flash_order": node = next(n for n in nodes if n.target is operator.getitem) node.args = (flash, 2) else: node = next(n for n in nodes if n.target == torch.ops.aten.bmm.default) node.target = torch.ops.aten.mm.default original = str(gm.graph) layout.BackwardLayoutPass("paired", "test")(gm.graph) assert str(gm.graph) == original assert layout.backward_layout_stats()["replacements"] == 0 assert sum(layout.backward_layout_stats()["miss_reasons"].values()) == 1 def test_external_arithmetic_consumer_rejected(): gm, root, _ = candidate_graph() node = next(n for n in gm.graph.nodes if n.target == torch.ops.aten.add.Tensor) with gm.graph.inserting_before(root): gm.graph.call_function(torch.ops.aten.neg.default, (node,)) with pytest.raises(layout._Mismatch, match="external intermediate consumer"): layout._match(root, layout._pattern()) def test_shared_gradient_view_retained_without_copy(): gm, root, _ = candidate_graph() node = next(n for n in gm.graph.nodes if n.target == torch.ops.aten.permute.default and tuple(n.meta["val"].stride()) == (4194304, 262144, 64, 2048, 1)) with gm.graph.inserting_before(root): external = gm.graph.call_function(torch.ops.aten.neg.default, (node,)) _, interior = layout._match(root, layout._pattern()) assert node not in interior layout.BackwardLayoutPass("paired", "test")(gm.graph) assert external.args[0] is node gm.graph.lint() def test_cse_shared_exact_zero_across_two_regions(): from torch._functorch.compile_utils import fx_graph_cse graph = torch.fx.Graph() regions = [candidate_graph(), candidate_graph()] mappings = [] for index, (gm, _, _) in enumerate(regions): mapping = {} for node in gm.graph.nodes: if node.op == "placeholder": new = graph.placeholder(f"core_{index}_{node.name}") new.meta = dict(node.meta) mapping[node] = new mappings.append(mapping) roots = [] for (gm, root, _), mapping in zip(regions, mappings, strict=True): for node in gm.graph.nodes: if node.op not in ("placeholder", "output"): mapping[node] = graph.node_copy(node, lambda value: mapping[value]) roots.append(mapping[root]) graph.output(tuple(roots)) graph = fx_graph_cse(graph) zeros = [node for node in graph.nodes if node.target == torch.ops.aten.full.default] assert len(zeros) == 1 and len(zeros[0].users) == 8 layout.BackwardLayoutPass("paired", "test")(graph) graph.lint() assert sum(node.target == torch.ops.warpstate.paired_backward_layout.default for node in graph.nodes) == 2 assert not any(node.target == torch.ops.aten.full.default for node in graph.nodes) assert layout.backward_layout_stats()["replacements"] == 2 def test_configuration_identity_covers_sources(): result = layout.configure_backward_layout("paired") assert config.post_grad_custom_post_pass.uuid() == result["identity"] for name, digest in result["source_sha256"].items(): assert hashlib.sha256((Path(__file__).parent / name).read_bytes()).hexdigest() == digest with pytest.raises(RuntimeError, match="already configured"): layout.configure_backward_layout("paired") def test_configuration_rejects_existing_pass_and_precision_changes(): existing = lambda graph: None with config.patch(post_grad_custom_post_pass=existing): with pytest.raises(RuntimeError, match="already exists"): layout.configure_backward_layout("paired") assert config.post_grad_custom_post_pass is existing for setting, value in (("emulate_precision_casts", True), ("triton.codegen_upcast_to_fp32", False), ("eager_numerics.disable_ftz", True)): with config.patch({setting: value}): with pytest.raises(ValueError, match="FP32 pointwise"): layout.configure_backward_layout("paired") def test_baseline_has_no_compiler_hook_or_metadata(): assert layout.configure_backward_layout() is None assert config.post_grad_custom_post_pass is None def test_dispatch_evidence_requires_actual_runtime_calls(): layout.configure_backward_layout("paired") layout._COUNTS["replacements"] = 100 with pytest.raises(RuntimeError, match="runtime calls"): layout.require_backward_layout_dispatch() layout._COUNTS["runtime_calls"] = 2 assert layout.require_backward_layout_dispatch(2)["runtime_calls"] == 2 with pytest.raises(RuntimeError, match="at least 3"): layout.require_backward_layout_dispatch(3) with pytest.raises(ValueError): layout.require_backward_layout_dispatch(True) def test_native_entry_rejects_unsupported_inputs_before_launch(): with pytest.raises(ValueError, match="q_memory"): layout._validate_native_inputs([torch.empty(1)] * 14) @pytest.mark.skipif(os.environ.get("WARPSTATE_TEST_CUDA") != "1" or not torch.cuda.is_available(), reason="requires an explicitly reserved CUDA device") def test_opaque_boundary_schema_and_fake_registration(): from ops.backward_layout import make_inputs saved = make_inputs(device="cuda", seed=9221) native = tuple(value.view(shape) for value, shape in zip(saved, layout._NATIVE_SHAPES, strict=True)) # This is a backward-only internal operator; schema purity and accurate fake # metadata apply, whereas registering another autograd VJP would be wrong. result = torch.library.opcheck(torch.ops.warpstate.paired_backward_layout.default, native, test_utils=("test_schema", "test_faketensor")) assert set(result.values()) == {"SUCCESS"} @pytest.mark.parametrize("field,value", [("d_model", 1024), ("n_heads", 16), ("chunk_size", 64), ("parallel_memory", False), ("dropout", 0.1)]) def test_model_configuration_guard(field, value): cfg = WarpStateConfig(d_model=2048, n_heads=32, chunk_size=128, parallel_memory=True) layout.validate_backward_layout_config(cfg) setattr(cfg, field, value) with pytest.raises(ValueError, match=field): layout.validate_backward_layout_config(cfg)