[objectfifo] Address review: tighten endpoints, reuse infrastructure

Every DMA endpoint now states the direction it moves data in, shim ends
included. The direction was previously recovered from the endpoint's position
in its flow, through a map built for the purpose, because a shim endpoint had
no pool and so dropped its role; saying it outright deletes the map.

A core endpoint selecting only part of an object is rejected. The lowering
hands a core whole buffers, so such an endpoint would have silently received
the wrong memref; emitting the memref.subview it needs is what would let cores
take part in a join or distribute.

iter_count is recorded only on the MemTile endpoint that honors it, and
rejected elsewhere, instead of being carried onto endpoints that ignore it.

Reuses existing infrastructure the review pointed at: TileOp::getOrCreate for
tile lookup, SymbolUserMap for deciding which pools are still referenced, and
DenseSet for channel occupancy, which is all that was ever stored. The DMA
program search and the channel scan lose their per-op-type triplication.
Buffer byte size moves onto the pool op.

FIXMEs mark the three places the review identified as belonging elsewhere:
buffer placement, packet ID assignment, and the repeat_count/iter_count
tangle.

Author: andrej

docs/design/objfifo-refactor-plan.md

@@ -10,8 +10,8 @@ Target IR at each stage is documented in `docs/design/objfifo-stages/`. Read
 
 - `test/objectFifo-stateful-transform` stays green: 159 pass, 1 XFAIL.
 - Existing tests are unchanged, or changed only mechanically (RUN lines, op
-  spellings). A behavioural diff in an expected output means the commit is wrong.
-- New behaviour ships with new tests in the same commit.
+  spellings). A behavioral diff in an expected output means the commit is wrong.
+- New behavior ships with new tests in the same commit.
 - Comments follow `docs/skills` / the code-commenting skill: no history, no
   before/after framing, no restating the adjacent line.
 
@@ -163,7 +163,7 @@ The unroll hint and the alloca-to-SSA promotion belong to this pass: the hint
 preserves fifo-level information the lowering discards, and the allocas exist
 only to reach SSA form.
 
-New behaviour, with tests:
+New behavior, with tests:
 
 - an acquire on an endpoint selecting several segments takes one lock per
   segment, all with the same delta, before the object is handed over;
@@ -200,7 +200,7 @@ an aie.objectfifo.acquire" verifier and
 `test/objectFifo-stateful-transform/subview_escape_via_iter_args.mlir` all go.
 
 Mechanical but wide: most objectFifo tests use `subview.access`. Land it last so
-it never blocks a behavioural commit.
+it never blocks a behavioral commit.
 
 ---
 

docs/design/objfifo-stages/00-model.mlir

@@ -140,7 +140,8 @@
 // which gives three shapes:
 //
 //   one segment spanning the object   -> the buffer itself
-//   one segment that is a strict slice -> a memref.subview at its offset
+//   one segment that is a strict slice -> a memref.subview at its offset,
+//                                         not emitted yet and so rejected
 //   every segment of a partitioned object -> the buffer itself, after N acquires
 //
 // A core endpoint's selection is fixed, so every acquire on it yields the same
@@ -226,7 +227,7 @@
 //
 //  - a pool's segments do not overlap and cover the element type exactly
 //  - each of a pool's segments has one filling endpoint and one draining
-//    endpoint. A filler may be absent when the lock initialisers mark the
+//    endpoint. A filler may be absent when the lock initializers mark the
 //    objects as starting full
 //  - every flow reaches a destination
 //
@@ -239,16 +240,18 @@
 //
 // IMPLEMENTATION NOTES
 //
-// 1. A core endpoint whose segments do not span the whole buffer needs a
-//    memref.subview at the segment offset before the object is handed over. Do
-//    not assume elementType == buffer type on a core endpoint.
+// 1. A core endpoint whose segments do not span the whole buffer would need a
+//    memref.subview at the segment offset before the object is handed over.
+//    That is not emitted yet, so the verifier rejects such an endpoint rather
+//    than handing over the whole buffer; implementing it is what would let
+//    cores take part in a join or distribute.
 //
 // 2. A multi-segment core acquire takes one lock per segment before the object
 //    may be touched. The delta computation is unchanged; it is applied to each.
 //
 // 3. Pre-filled fifos desugar during split: the initial contents become
-//    initialisers on the aie.buffer ops, and "N objects start full" becomes the
-//    pool's lock initialisers.
+//    initializers on the aie.buffer ops, and "N objects start full" becomes the
+//    pool's lock initializers.
 //
 //===----------------------------------------------------------------------===//
 //

include/aie/Dialect/AIE/IR/AIEOps.td

@@ -2284,12 +2284,12 @@ def AIE_ObjectFifoPoolOp
       OptionalAttr<FlatSymbolRefArrayAttr>:$buffers,
       OptionalAttr<ObjectFifoSegmentArrayAttr>:$segments,
       OptionalAttr<FlatSymbolRefArrayAttr>:$locks,
-      // Times the pool is cycled through per outer iteration; lock initialisers
+      // Times the pool is cycled through per outer iteration; lock initializers
       // scale with it.
       OptionalAttr<AIEI32Attr>:$repeatCount,
       // Outer iterations the DMA chain runs for.
       OptionalAttr<AIEI32Attr>:$iterCount,
-      // No locks are created for this pool; its actors are unsynchronised.
+      // No locks are created for this pool; its actors are unsynchronized.
       DefaultValuedAttr<BoolAttr, "false">:$disableSynchronization,
       // Name of the objectFifo this pool holds the objects of.
       OptionalAttr<StrAttr>:$fifoName, InitValuesArrayAttr:$initValues);
@@ -2307,6 +2307,9 @@ def AIE_ObjectFifoPoolOp
     /// Byte-agnostic element count of one object, taken from the element type.
     int64_t getObjectSize();
 
+    /// Size of one object in bytes, under the closest data layout.
+    int64_t getObjectSizeInBytes();
+
     /// One entry per way the object is divided; a pool with no `segments` is
     /// one whole object.
     llvm::SmallVector<ObjectFifoSegmentAttr> getSegmentAttrs();
@@ -2383,7 +2386,7 @@ def AIE_ObjectFifoDmaEndpointOp
   }];
 
   let arguments = (ins SymbolNameAttr:$sym_name, Index:$tile,
-      OptionalAttr<ObjectFifoRole>:$role, OptionalAttr<FlatSymbolRefAttr>:$pool,
+      ObjectFifoRole:$role, OptionalAttr<FlatSymbolRefAttr>:$pool,
       OptionalAttr<DenseI32ArrayAttr>:$segments,
       OptionalAttr<ObjectFifoChannelAttr>:$channel,
       // Channel the user demands, claimed before any is auto-assigned.
@@ -2408,7 +2411,7 @@ def AIE_ObjectFifoDmaEndpointOp
       OptionalAttr<StrAttr>:$fifoName);
 
   let assemblyFormat = [{
-    $sym_name `(` $tile `)` ($role^ $pool)? attr-dict
+    $sym_name `(` $tile `)` $role (`of` $pool^)? attr-dict
   }];
 
   let hasVerifier = 1;

include/aie/Dialect/AIE/Transforms/AIEDMAChannelAnalysis.h

@@ -18,10 +18,10 @@ namespace xilinx::AIE {
 /// Which DMA channels of each tile are already spoken for, so that a channel is
 /// handed out at most once across everything that programs one.
 class DMAChannelAnalysis {
-  mlir::DenseMap<std::tuple<mlir::Value, DMAChannelDir, int>, int>
-      channelsPerTile;
-  mlir::DenseMap<std::tuple<mlir::Value, DMAChannelDir, int>, int>
-      aieStreamsPerTile;
+  /// A channel or stream port is either spoken for or free, so membership is
+  /// the whole state.
+  mlir::DenseSet<std::tuple<mlir::Value, DMAChannelDir, int>> usedChannels;
+  mlir::DenseSet<std::tuple<mlir::Value, DMAChannelDir, int>> usedStreams;
 
 public:
   DMAChannelAnalysis(DeviceOp &device);
@@ -33,7 +33,8 @@ class DMAChannelAnalysis {
                          bool requiresAdjacentTileAccessChannels);
 
   /// Claim `channel` for (`tile`, `dir`) so first-free assignment cannot take
-  /// it. Returns -1 when the channel is out of range or already claimed.
+  /// it. Returns the channel, or -1 when it is out of range or already
+  /// claimed; the caller reports, since it knows which endpoint asked.
   int reservePinnedChannel(TileLike tile, DMAChannelDir dir, int channel);
 
   /// Claim a raw stream port, reporting on `tile` when it is already taken.