fix(redmule): lower bias-less Gemm to MatMul so CCT_train tiling stops crashing

The Siracusa+RedMulE CCT_train CI job (added in b682739) crashed during
tiling with KeyError 'C' inside RedmuleGEMMTileConstraint -- the constraint
unconditionally reads parseDict['C'] but GEMMRedmuleParser.parseNodeCtxt
only populates it when len(node.inputs) == 3 and noBiasHoisting is True
(the default). Backward-pass codegen for CCT (GradFusedMatMul rewrites)
emits a flurry of 2-input ONNX Gemm nodes (alpha=1, no bias), which match
the binding but never get a 'C' field -- hence the lookup blows up.

A bias-less Gemm with alpha=1 is mathematically just MatMul, and the
Redmule platform already routes ONNX MatMul through
MatMulRedmuleMapper / RedmuleMatMulTilingReadyBindings (no C operand
needed). So instead of papering over the parser, lower the op:

- Add RedMuleBiaslessGemmToMatMulPass in
  Targets/Redmule/TopologyOptimizationPasses/Passes.py. It matches Gemm
  nodes (the 2-input pattern reused from RedMuleGEMMTransposePass),
  guards on len(inputs) == 2 and alpha == 1, materializes any
  transA/transB (constants get folded, variables get a Transpose
  appended via the same _appendTranspose helper the transpose pass
  already uses), then rewrites op="MatMul" and clears attrs.
- Wire it into RedmuleDeployer.loweringOptimizer.passes BEFORE
  RedMuleGEMMTransposePass so the latter only ever sees real (3-input)
  Gemms; otherwise it would write transA/transB=0 onto what we just
  rewrote into a MatMul, and the stale Gemm op would still hit the
  bias-required tile constraint.

3-input Gemms (forward CCT FCs, the existing testFloatGEMM/testFloatGEMMtransB
kernel fixtures) are untouched: the new pass returns the graph
unchanged when len(inputs) != 2, and RedMuleGEMMTransposePass continues
to see them as before.

Local validation: pytest --collect-only -m "siracusa_redmule_tiled"
still yields the same 4 cases (3 kernel + 1 training); module import
of Deployer + the new pass class both succeed. Real run deferred to CI.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: runwangdl

Deeploy/Targets/Redmule/Deployer.py

@@ -31,7 +31,7 @@
 from Deeploy.DeeployTypes import DeploymentPlatform, TopologyOptimizer
 from Deeploy.Targets.PULPOpen.Deployer import PULPDeployer
 from Deeploy.Targets.Redmule.TopologyOptimizationPasses.Passes import RedMuleAdjustWeightMemoryLayoutPass, \
-    RedMuleGEMMTransposePass
+    RedMuleBiaslessGemmToMatMulPass, RedMuleGEMMTransposePass
 
 
 class RedmuleDeployer(PULPDeployer):
@@ -51,5 +51,9 @@ def __init__(self,
 
         self.loweringOptimizer.passes += [
             RedMuleAdjustWeightMemoryLayoutPass("Redmule"),
+            # Lower bias-less Gemm (e.g. backward GradFusedMatMul nodes in CCT
+            # training) to MatMul before GEMMTransposePass touches them; the
+            # bias-required tile constraint would otherwise crash.
+            RedMuleBiaslessGemmToMatMulPass("Redmule"),
             RedMuleGEMMTransposePass("Redmule")
         ]

Deeploy/Targets/Redmule/TopologyOptimizationPasses/Passes.py

@@ -148,3 +148,84 @@ def __init__(self, redmuleEngineName: str):
         super().__init__(pattern = pattern,
                          replacement_fn = _redmule_gemm_transpose_fun,
                          name = "_REDMULE_GEMM_TRANSPOSE_PASS")
+
+
+def _redmule_biasless_gemm_to_matmul_fun(graph: gs.Graph, match: Match, name: str):
+    """Rewrite a 2-input ONNX Gemm (no C / bias) into an equivalent MatMul.
+
+    Backward-pass codegen (e.g. the ``GradFusedMatMul`` rewrites that fall out
+    of the CCT training graph) emits ``Gemm`` nodes with only A and B and no
+    bias, which the ``GEMMRedmuleParser`` accepts but for which the
+    ``RedmuleGEMMTileConstraint`` then crashes (KeyError on ``parseDict['C']``).
+    A bias-less Gemm with alpha=1 is mathematically just a MatMul, and the
+    Redmule platform already maps ONNX ``MatMul`` to a kernel that doesn't
+    expect a C operand -- so we lower it here.
+
+    transA / transB are materialized as explicit ``Transpose`` nodes (or, for
+    constant operands, folded into the constant) before the op is rewritten,
+    because ``MatMul`` has no equivalent attributes.
+    """
+    gemm_node = list(match.nodes_map.values())[0]
+
+    # Pattern matcher may match Gemms with 3 inputs too; act only on the
+    # bias-less subset.
+    if len(gemm_node.inputs) != 2:
+        return graph
+
+    # Anything other than alpha=1 cannot be expressed as a plain MatMul.
+    if gemm_node.attrs.get('alpha', 1.0) != 1.0:
+        return graph
+
+    transA = gemm_node.attrs.get('transA', 0)
+    transB = gemm_node.attrs.get('transB', 0)
+
+    for inputIdx, transFlag in ((0, transA), (1, transB)):
+        if not transFlag:
+            continue
+        operand = gemm_node.inputs[inputIdx]
+        if isinstance(operand, gs.Constant):
+            if len(operand.values.shape) > 2:
+                perm = list(range(len(operand.values.shape)))
+                perm[-1], perm[-2] = perm[-2], perm[-1]
+                operand.values = np.transpose(operand.values, perm)
+            else:
+                operand.values = np.transpose(operand.values)
+        else:
+            perm = list(range(len(operand.shape)))
+            perm[-1], perm[-2] = perm[-2], perm[-1]
+            anchorTransposeNode = _appendTranspose(operand, gemm_node, perm)
+            graph.nodes.append(anchorTransposeNode)
+
+    gemm_node.op = "MatMul"
+    gemm_node.attrs.clear()
+
+    return graph
+
+
+@contextagnostic
+class RedMuleBiaslessGemmToMatMulPass(ReplaceSequentialPatternPass):
+    """Lower bias-less (2-input) ONNX Gemm nodes to MatMul on the Redmule path.
+
+    Must run before RedMuleGEMMTransposePass so the latter only sees the
+    real (3-input) Gemm nodes; otherwise its replacement_fn would write
+    ``transA`` / ``transB`` back to 0 on what is now a MatMul, and a stale
+    ``Gemm`` op type would still hit the bias-required tile constraint.
+    """
+
+    def __init__(self, redmuleEngineName: str):
+        pattern = gs.Graph()
+
+        input_a = gs.Variable(name = "input_a")
+        input_b = gs.Variable(name = "input_b")
+
+        gemm_output = pattern.layer(op = "Gemm",
+                                    name = "gemm_node",
+                                    inputs = [input_a, input_b],
+                                    outputs = ["gemm_output"])
+
+        pattern.inputs = [input_a, input_b]
+        pattern.outputs = [gemm_output]
+
+        super().__init__(pattern = pattern,
+                         replacement_fn = _redmule_biasless_gemm_to_matmul_fun,
+                         name = "_REDMULE_BIASLESS_GEMM_TO_MATMUL_PASS")