REFACTOR: tiler reads VariableBuffer.alias_of instead of legacy _alias

CHANGELOG.md

@@ -5,6 +5,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 
 
 ### List of Pull Requests
+- REFACTOR: tiler reads VariableBuffer.alias_of instead of legacy _alias [#203](https://github.com/pulp-platform/Deeploy/pull/203)
 - Fix Neureka [#188](https://github.com/pulp-platform/Deeploy/pull/188)
 - HOTFIX: XDNA2 Action Fix [#201](https://github.com/pulp-platform/Deeploy/pull/201)
 - XDNA2 Platform Support [#179](https://github.com/pulp-platform/Deeploy/pull/179)
@@ -62,6 +63,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 - Aligned CLI commands across the project
 - Added @runwangdl as a code owner
 - Skip emitting duplicate `testInputVector` data for inputs placed in L3 (loaded at runtime from the readfs hex instead), reducing test binary size
+- Tiler (`TilerExtension`, `MemoryScheduler`) and `NetworkContext.dealiasBuffer` use directed `VariableBuffer.alias_of` instead of the legacy `_alias` attribute [#203](https://github.com/pulp-platform/Deeploy/pull/203)
 
 ### Fixed
 - Fix Neureka's output-channels subtile size (in ConvTemplate) and Dense/DW/PW tile constraints
@@ -85,6 +87,7 @@ This file contains the changelog for the Deeploy project. The changelog is divid
 ### Removed
 - removed experimental `enable3x3` flag, from Neureka Engine. Now, 3x3 mode is enabled by default.
 - `testDMA.py` was an old test; we now have `test_dmas.py` instead.
+- Legacy `_alias` workaround in Generic/PULPOpen `ReshapeTemplate` (tiling now uses `alias_of`)
 
 ## Release v0.2.1 (2026-02-05) [#158](https://github.com/pulp-platform/Deeploy/pull/158)
 

Deeploy/DeeployTypes.py

@@ -259,6 +259,9 @@ def __init__(self, name: str = '', shape = [1], aliases: Optional[List[str]] = N
         self.is_output: bool = False
 
         self.aliases: Set[str] = set(aliases) if aliases is not None else set()
+        # Directed "I am an alias of these storage ancestors" (tiling / dealiasBuffer).
+        # Distinct from symmetric self.aliases used by has_live_aliases.
+        self.alias_of: Set[str] = set()
 
     def _bufferRepresentation(self) -> Dict:
         return {"type": self._instance, "name": self.name, "size": int(np.prod(self.shape))}
@@ -561,13 +564,23 @@ def dealiasBuffer(self, name: str) -> str:
             Raises an Exception if aliases are circular, i.e. there
             is no underlying VariableBuffer
         """
-        seenAliases: Set[str] = set()
-        alias = self.lookup(name)
-        while hasattr(alias, "_alias"):
-            seenAliases.add(alias.name)
-            alias = self.lookup(alias._alias)
-            assert alias.name not in seenAliases, "Circular aliasing detected!"
-        return alias.name
+
+        def _roots(bufName: str, seen: Set[str]) -> Set[str]:
+            buf = self.lookup(bufName)
+            assert isinstance(buf, VariableBuffer)
+            if not buf.alias_of:
+                return {buf.name}
+            assert buf.name not in seen, "Circular aliasing detected!"
+            nextSeen = seen | {buf.name}
+            roots: Set[str] = set()
+            for parentName in buf.alias_of:
+                roots |= _roots(parentName, nextSeen)
+            return roots
+
+        roots = _roots(name, set())
+        assert len(roots) == 1, (f"Buffer {name} aliases conflicting storage roots {sorted(roots)}; "
+                                 "all alias_of paths must resolve to one root")
+        return next(iter(roots))
 
     def unravelReference(self, ref: VariableBuffer) -> VariableBuffer:
         """Function to find the underlying referenced VariableBuffer

Deeploy/Targets/Generic/Templates/ReshapeTemplate.py

@@ -33,12 +33,8 @@ def alignToContext(self, ctxt: NetworkContext,
         # Link aliases to each buffer
         bufferIn.aliases.add(bufferOut.name)
         bufferOut.aliases.add(bufferIn.name)
-
-        # Tiling still reads the legacy single-valued `_alias` attribute
-        # (TilerExtension / MemoryScheduler). Set it here so platforms that
-        # rely on Reshape pointer-passthrough during tiling don't each need
-        # to carry the same workaround in a subclass.
-        bufferOut._alias = bufferIn.name
+        # Directed storage parent for tiling / dealiasBuffer
+        bufferOut.alias_of.add(bufferIn.name)
 
         return ctxt, operatorRepresentation, []
 

Deeploy/Targets/PULPOpen/Templates/ReshapeTemplate.py

@@ -2,9 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Dict, List, Tuple
-
-from Deeploy.DeeployTypes import NetworkContext, OperatorRepresentation, VariableBuffer
 from Deeploy.Targets.Generic.Templates.ReshapeTemplate import _ReshapeTemplate as _GenericReshapeTemplate
 
 
@@ -13,24 +10,6 @@ class _ReshapeTemplate(_GenericReshapeTemplate):
     def __init__(self, templateStr):
         super().__init__(templateStr)
 
-    def alignToContext(self, ctxt: NetworkContext,
-                       operatorRepresentation: OperatorRepresentation) -> Tuple[NetworkContext, Dict, List[str]]:
-
-        ctxt, operatorRepresentation, _ = super().alignToContext(ctxt, operatorRepresentation)
-
-        # Get buffers
-        bufferIn = ctxt.lookup(operatorRepresentation['data_in'])
-        assert isinstance(bufferIn, VariableBuffer)
-
-        bufferOut = ctxt.lookup(operatorRepresentation['data_out'])
-        assert isinstance(bufferOut, VariableBuffer)
-
-        # HACK: Tiling wasn't updated in the Fix aliasing PR so we have to still
-        #       set the _alias argument
-        bufferOut._alias = bufferIn.name
-
-        return ctxt, operatorRepresentation, []
-
 
 referenceTemplate = _ReshapeTemplate("""
 // Reshape (Name: ${nodeName}, Op: ${nodeOp})

Deeploy/TilingExtension/MemoryScheduler.py

@@ -301,11 +301,11 @@ def filterTensorMemoryConstraint(ctxt: NetworkContext, tensorMemoryConstraint: T
 
                 buffer = ctxt.lookup(tensorName)
                 # JUNGVI: Buffer targeted by alias have to say alive as long as their "aliasers"
-                if hasattr(buffer, "_alias"):
-                    alias = buffer._alias
-                    if alias in tensorLifetimeMap.keys():
-                        prevLifetime = tensorLifetimeMap[alias]
-                        tensorLifetimeMap[alias] = tuple((prevLifetime[0], stepIdx))
+                if buffer.alias_of:
+                    for alias in buffer.alias_of:
+                        if alias in tensorLifetimeMap.keys():
+                            prevLifetime = tensorLifetimeMap[alias]
+                            tensorLifetimeMap[alias] = tuple((prevLifetime[0], stepIdx))
 
                 if tensorName in tensorLifetimeMap.keys():
                     prevLifetime = tensorLifetimeMap[tensorName]
@@ -369,7 +369,7 @@ def _buildCostVector(self, ctxt, graph, tensorMap, memoryLevel):
                     cost = wordCost * c.multiBufferCoefficient
 
                     # SCHEREMO: In-place operator outputs are "costless" whenever their input is in the same pattern
-                    if hasattr(ctxt.lookup(node), "_alias") and ctxt.lookup(node)._alias in neighbors:
+                    if ctxt.lookup(node).alias_of and any(a in neighbors for a in ctxt.lookup(node).alias_of):
                         cost = 0
 
             costVector.append(cost)
@@ -655,9 +655,14 @@ def permMatrix2permList(permMatrix: np.ndarray) -> List[int]:
                         continue
 
                     # SCHEREMO: Don't fully unroll aliases here - this is pattern-sensitive!
-                    if hasattr(_buffer, "_alias") and _buffer._alias in blockNames:
-                        _alias = ctxt.lookup(memoryBlock.name)._alias
-                        aliasedBlocks.append((memoryBlock, _alias))
+                    inPatternParents = [a for a in _buffer.alias_of if a in blockNames]
+                    if inPatternParents:
+                        roots = {ctxt.dealiasBuffer(p) for p in inPatternParents}
+                        assert len(roots) == 1, (
+                            f"Buffer {memoryBlock.name} has in-pattern alias parents with conflicting "
+                            f"storage roots {sorted(roots)}")
+                        # Share addrSpace with a deterministic in-pattern parent.
+                        aliasedBlocks.append((memoryBlock, sorted(inPatternParents)[0]))
                         continue
 
                     upperIdx = blockIdx

Deeploy/TilingExtension/TilerExtension.py

@@ -296,7 +296,8 @@ def _convertCtxtToStaticSchedule(self, ctxt: NetworkContext,
 
                     _buffer = ctxt.lookup(node.name)
                     # SCHEREMO: If alias buffers have zero cost, they don't contribute to the currentMax and their addrSpace is None
-                    if hasattr(_buffer, "_alias") and (ctxt.is_global(_buffer._alias) or _buffer._alias in blockNames):
+                    if _buffer.alias_of and (any(ctxt.is_global(a) for a in _buffer.alias_of)
+                                             or any(a in blockNames for a in _buffer.alias_of)):
                         continue
 
                     currentMax = max(currentMax, node._addrSpace[1])
@@ -333,15 +334,18 @@ def _convertCtxtToStaticSchedule(self, ctxt: NetworkContext,
                     if _buffer._memoryLevel != memoryLevel:
                         continue
 
-                    if hasattr(_buffer, "_alias") and ctxt.is_global(_buffer._alias):
+                    if _buffer.alias_of and ctxt.is_global(ctxt.dealiasBuffer(tensorName)):
                         continue
 
-                    if hasattr(_buffer, "_alias") and _buffer._alias in blockNames:
+                    inPatternParents = [a for a in _buffer.alias_of if a in blockNames]
+                    if inPatternParents:
+                        roots = {ctxt.dealiasBuffer(p) for p in inPatternParents}
+                        assert len(roots) == 1, (f"Buffer {tensorName} has in-pattern alias parents with conflicting "
+                                                 f"storage roots {sorted(roots)}")
+                        parentName = sorted(inPatternParents)[0]
+                        aliasNodes = [node for node in nodeList if node.name == parentName]
 
-                        alias = ctxt.dealiasBuffer(tensorName)
-                        aliasNodes = [node for node in nodeList if node.name == alias]
-
-                        assert len(aliasNodes) == 1, f"alias {alias} references more than one node!"
+                        assert len(aliasNodes) == 1, f"alias {parentName} references more than one node!"
 
                         aliasNode = aliasNodes[0]
 

DeeployTest/testSchedulingExtension.py

@@ -195,9 +195,7 @@ def validateDynamicMemoryLayoutSolution(ctxt: NetworkContext, tilingSchedule: Ti
                     _buffer = ctxt.lookup(block.name)
                     for other in otherBlocks:
                         _otherBuffer = ctxt.lookup(other.name)
-                        if (hasattr(_buffer, "_alias")
-                                and _buffer._alias == other.name) or (hasattr(_otherBuffer, "_alias")
-                                                                      and _otherBuffer._alias == block.name):
+                        if (other.name in _buffer.alias_of) or (block.name in _otherBuffer.alias_of):
                             collisions.append(False)
                             continue
 

DeeployTest/testTypes.py

@@ -224,6 +224,56 @@ def testPointerTypeEquivalence():
     return True
 
 
+def testDealiasBufferUsesAliasOf():
+    """Regression for #201: dealiasBuffer walks directed alias_of"""
+    ctxt = NetworkContext(VariableBuffer, ConstantBuffer, StructBuffer, TransientBuffer)
+
+    bufferIn = VariableBuffer("reshape_in", shape = [4, 4])
+    bufferOut = VariableBuffer("reshape_out", shape = [16])
+    ctxt.add(bufferIn, "local")
+    ctxt.add(bufferOut, "local")
+
+    bufferIn.aliases.add(bufferOut.name)
+    bufferOut.aliases.add(bufferIn.name)
+    bufferOut.alias_of.add(bufferIn.name)
+
+    assert not hasattr(bufferOut, "_alias"), "legacy _alias must not be required for dealiasing"
+    assert ctxt.dealiasBuffer(bufferOut.name) == bufferIn.name
+    assert ctxt.dealiasBuffer(bufferIn.name) == bufferIn.name
+
+    bufferOut2 = VariableBuffer("reshape_out2", shape = [2, 8])
+    ctxt.add(bufferOut2, "local")
+    bufferOut.aliases.add(bufferOut2.name)
+    bufferOut2.aliases.add(bufferOut.name)
+    bufferOut2.alias_of.add(bufferOut.name)
+
+    assert ctxt.dealiasBuffer(bufferOut2.name) == bufferIn.name
+
+    # Multi-parent: both parents share one storage root. Lex order of parents
+    # must not change the resolved root (zzz sorts before mid).
+    mid = VariableBuffer("mid", shape = [16])
+    zzz = VariableBuffer("zzz", shape = [16])
+    multi = VariableBuffer("multi", shape = [16])
+    ctxt.add(mid, "local")
+    ctxt.add(zzz, "local")
+    ctxt.add(multi, "local")
+    mid.alias_of.add(bufferIn.name)
+    zzz.alias_of.add(bufferIn.name)
+    multi.alias_of.update({zzz.name, mid.name})
+    assert ctxt.dealiasBuffer(multi.name) == bufferIn.name
+
+    # Conflicting roots must be rejected.
+    otherRoot = VariableBuffer("other_root", shape = [16])
+    conflict = VariableBuffer("conflict", shape = [16])
+    ctxt.add(otherRoot, "local")
+    ctxt.add(conflict, "local")
+    conflict.alias_of.update({bufferIn.name, otherRoot.name})
+    with pytest.raises(AssertionError):
+        ctxt.dealiasBuffer(conflict.name)
+
+    return True
+
+
 if __name__ == "__main__":
     testImmediateSerialization()
     testImmediatePromotion()
@@ -239,3 +289,4 @@ def testPointerTypeEquivalence():
     testPointerSerialization()
     testPointerPromotion()
     testPointerTypeEquivalence()
+    testDealiasBufferUsesAliasOf()