Fix DW ConvGradX weight tile size (L1 OOB in MobileNet backward)

DWConvGradX2DTileConstraint shares serializeTilingSolution with the
regular-conv base class, which built the per-tile weight cube as
(Cout, dxCube.dims[1], P, Q). That is right for regular conv where
W[1] == Cin, but depthwise weight layout is [C, 1, P, Q]: dim 1 is
always 1 and the per-channel slice should track dim 0 (Cout == C).

For MobileNetV1 block_12 (C=256, 3x3 DW) the base formula produced a
2.36MB weight cube instead of the real 9KB, and the resulting DMA copy
flooded L1 past all 16 banks starting at bank offset 0x4000, crashing
the first backward pass.

Extract the weight-cube construction into a _make_weight_cube hook
on the base class and override it in DWConvGradX2DTileConstraint to
produce ([offset_c, 0, 0, 0], [c_size, 1, P, Q]). With this, MobileNet
training now runs 4 steps through gvsoc without OOB; ResNet8 (regular
conv only) is unaffected.

Author: runwangdl

Deeploy/Targets/PULPOpen/TileConstraints/ConvGradConstraint.py

@@ -269,6 +269,16 @@ def extraSerializeChecks(cls, ctxt: NetworkContext, operatorRepresentation: Oper
         """Hook for DW checks etc."""
         return
 
+    @classmethod
+    def _make_weight_cube(cls, dxCube: HyperRectangle,
+                          wShape: Tuple[int, int, int, int]) -> HyperRectangle:
+        """Per-tile weight cube. Regular conv: W layout [Cout, Cin/group, P, Q],
+        so the Cin slice tracks dxCube.dims[1]. Subclasses override for DW."""
+        return HyperRectangle(
+            (0, dxCube.offset[1], 0, 0),
+            (wShape[0], dxCube.dims[1], wShape[2], wShape[3]),
+        )
+
     # ---------------------------------------------------
     # 4) serialize: dx tiles -> dy halo tiles
     # ---------------------------------------------------
@@ -371,15 +381,9 @@ def serializeTilingSolution(
                 dxAbsOff=abs_off
             )
 
-            # Per-tile W cube: slice C_in (dim 1) to match the dx channel range.
-            # For regular conv the geometrical constraint ties dxName[1] == wName[1],
-            # so dxCube.offset[1]/dims[1] line up with the W slice we need.
-            # For DW or PW this degenerates to a full cube when the tiler didn't
-            # split the axis (wShape[1] either 1 for DW or already == Cin full).
-            wCube = HyperRectangle(
-                (0, dxCube.offset[1], 0, 0),
-                (wShape[0], dxCube.dims[1], wShape[2], wShape[3]),
-            )
+            # Per-tile W cube: layout differs between regular and DW conv,
+            # so delegate to the subclass-overridable helper.
+            wCube = cls._make_weight_cube(dxCube, wShape)
 
             replacements["dim_im_in_x"].append(dxCube.dims[2])    # H_in_tile
             replacements["dim_im_in_y"].append(dxCube.dims[3])    # W_in_tile
@@ -526,6 +530,17 @@ def get_dy_channels(
         # DW: dY channels is C
         return dyFull[1]
 
+    @classmethod
+    def _make_weight_cube(cls, dxCube: HyperRectangle,
+                          wShape: Tuple[int, int, int, int]) -> HyperRectangle:
+        # DW weight layout [C, 1, P, Q]: the Cout axis (dim 0) tracks dxCube's
+        # channel axis, Cin is always 1. Returning the regular-conv cube here
+        # multiplies the weight transfer by Cin and blows past L1.
+        return HyperRectangle(
+            (dxCube.offset[1], 0, 0, 0),
+            (dxCube.dims[1], 1, wShape[2], wShape[3]),
+        )
+
 class ConvGradWTileConstraintBase(TileConstraint):
     """
     Base for ConvGradW2D tiling (im2col-style):