fix(tiling): MiniMalloc cost variable + SGD rank-2 DMA constraint (#18)

* fix(tiling): force SGD weight spatial dims to full size for rank-2 DMA

SGDTileConstraint now pins dim_i == shape[i] for i >= 2 (kernel_h, kernel_w).
minimizeRectangle can then collapse the trailing dims so every L2<->L3 DMA
tile is rank-2, avoiding the AnydimAsyncDmaTransferAdapter for-loop that
emitted 4 096 blocking pi_cl_ram_copy_2d calls per L2 tile for [128,128,3,3]
weights (~49x slowdown on ResNet8 optimizer with MiniMalloc).

* fix(tiling): force InPlaceAccumulatorV2 weight-grad spatial dims to full size

InPlaceAccumulatorV2TileConstraint now pins dim_i == shape[i] for i >= 2
(kH, kW) on the accum_buffer tensor.  BOPTileConstraint already ties
gradient and data_out dims to accum_buffer, so one pin is enough.

Without this, MiniMalloc tiles [C_out, C_in, kH, kW] weight-gradient
tensors along all four dims.  For ResNet8 layer3.conv2 [128,128,3,3]
this produced an explicit for-loop of 4096 iterations inside the L3 DMA
closure (pi_cl_ram_copy_2d(4 B) + pi_cl_ram_copy_wait per iteration),
resulting in ~73 k blocking L3 DMA calls per training step.

After the fix minimizeRectangle collapses kH×kW -> rank-2 tiles so each
L2->L3 transfer is a single contiguous pi_cl_ram_copy_2d (~41 KB).
Verified: 0 blocking DMA for-loops in ResNet8 TrainingNetwork.c.

Author: runwangdl

Deeploy/Targets/PULPOpen/TileConstraints/InPlaceAccumulatorV2TileConstraint.py

@@ -31,6 +31,15 @@ class InPlaceAccumulatorV2TileConstraint(BOPTileConstraint):
     def addGeometricalConstraint(cls, tilerModel: TilerModel, parseDict: Dict, ctxt: NetworkContext) -> TilerModel:
         tilerModel = super().addGeometricalConstraint(tilerModel, parseDict, ctxt)
 
+        # Force spatial dims (index >= 2) to full size so that minimizeRectangle
+        # can collapse them and DMA tiles stay rank ≤ 2 (L3Dma pi_cl_ram_copy_2d limit).
+        accumName = parseDict[cls.dataIn1Name]
+        shape = ctxt.lookup(accumName).shape
+        if not isinstance(shape, int) and len(shape) > 2:
+            for dimIdx in range(2, len(shape)):
+                dimVar = tilerModel.getTensorDimVar(tensorName = accumName, dimIdx = dimIdx)
+                tilerModel.addConstraint(dimVar == shape[dimIdx])
+
         # lazy_reset_grad is a scalar flag — pin full size so it is not tiled.
         lazyResetName = parseDict['lazy_reset_grad']
         tilerModel.addTensorDimToModel(ctxt, lazyResetName)

Deeploy/Targets/PULPOpen/TileConstraints/SGDTileConstraint.py

@@ -2,7 +2,11 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from typing import Dict
+
+from Deeploy.DeeployTypes import NetworkContext
 from Deeploy.Targets.Generic.TileConstraints.BOPTileConstraint import BOPTileConstraint
+from Deeploy.TilingExtension.TilerModel import TilerModel
 
 
 class SGDTileConstraint(BOPTileConstraint):
@@ -11,6 +15,21 @@ class SGDTileConstraint(BOPTileConstraint):
     dataIn2Name = 'grad'
     dataOutName = 'weight_updated'
 
+    @classmethod
+    def addGeometricalConstraint(cls, tilerModel: TilerModel, parseDict: Dict, ctxt: NetworkContext) -> TilerModel:
+        tilerModel = super().addGeometricalConstraint(tilerModel, parseDict, ctxt)
+
+        # Force spatial dims (index >= 2) to full size so that minimizeRectangle
+        # can collapse them and DMA tiles stay rank ≤ 2 (L3Dma pi_cl_ram_copy_2d limit).
+        weightName = parseDict[cls.dataIn1Name]
+        shape = ctxt.lookup(weightName).shape
+        if not isinstance(shape, int) and len(shape) > 2:
+            for dimIdx in range(2, len(shape)):
+                dimVar = tilerModel.getTensorDimVar(tensorName = weightName, dimIdx = dimIdx)
+                tilerModel.addConstraint(dimVar == shape[dimIdx])
+
+        return tilerModel
+
 
 class ReluGradTileConstraint(BOPTileConstraint):