Migrate to ktir-mlir-frontend 233d851: memory_space rename + tools_ktdp move

.claude/skills/ktir-dialect.md

@@ -88,7 +88,7 @@ operation ::= `ktdp.construct_memory_view` $offset `,` `sizes` `:`
 ```mlir
 #set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 31 >= 0, d1 >= 0, -d1 + 64 >= 0)>
 %A_view = ktdp.construct_memory_view %A_start_address, sizes: [32, 64], strides: [64, 1] {
-    coordinate_set = #set, memory_space = #ktdp.spyre_memory_space<HBM>
+    coordinate_set = #set, memory_space = #ktdp.memory_space<global>
 } : memref<32x64xf16>
 ```
 
@@ -254,12 +254,34 @@ access_tile<1 x 64 x index>     // Fully static
 
 Generic abstraction for device-specific memory space attributes within `ktdp`. Provides a uniform mechanism to associate IR values with a target-specific memory hierarchy while remaining extensible across backends.
 
-Concrete implementations (e.g., `SpyreMemorySpaceAttr`) describe specific memory kinds (on-chip scratchpad, HBM) and optional core affinity. This is preferred over integer-based memory space annotations in memref types, which lack readability and semantic richness for distributed scratchpad architectures.
+`MemorySpaceAttr` describes *where* memory is visible rather than naming device-specific
+memories: `global` is reachable by every compute tile, `ct_local` is private to one, with
+optional per-tile affinity via `ct_id`. This is preferred over integer-based memory space
+annotations in memref types, which lack readability and semantic richness for distributed
+scratchpad architectures.
 
 ```mlir
-memory_space = #ktdp.spyre_memory_space<HBM>
+memory_space = #ktdp.memory_space<global>
+memory_space = #ktdp.memory_space<ct_local>
+memory_space = #ktdp.memory_space<ct_local, ct_id = 7>
 ```
 
+> **⚠️ CONFLICTS with RFC 0682 — the RFC is stale here and needs updating.**
+> The RFC specifies an abstract `KtdpMemorySpaceAttr` interface with a Spyre-specific
+> `SpyreMemorySpaceAttr` implementation spelled
+> `#ktdp.spyre_memory_space<HBM|LX[, core = N]>` (plus an `unspecified` kind).
+> [ktir-mlir-frontend#58](https://github.com/torch-spyre/ktir-mlir-frontend/pull/58)
+> removed that interface and renamed the attribute to the device-agnostic form above;
+> `unspecified` was dropped with no replacement. This is a semantic change, not just a
+> rename — the enum went from naming *devices* (HBM/LX) to naming *visibility*
+> (reachable by all compute tiles vs. private to one).
+>
+> The RFC spelling no longer parses in the dialect at all, so **the syntax above is
+> authoritative and the RFC text should be revised to match** (tracked as row 4a in
+> `docs/gap_analysis.md`). Do not flag the new spelling as a spec deviation in reviews.
+> `ktir-cpu` maps `global`→`HBM` and `ct_local`→`LX` at the parse boundary, keeping the
+> concrete Spyre hierarchy in the interpreter and latency model.
+
 Future extensions will include richer metadata for compute-memory affinity.
 
 ---
@@ -281,17 +303,17 @@ module {
 
     %A_view = ktdp.construct_memory_view %A_start_address, sizes: [96, 64], strides: [64, 1] {
         coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 95 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-        memory_space = #ktdp.spyre_memory_space<HBM>
+        memory_space = #ktdp.memory_space<global>
     } : memref<96x64xf16>
 
     %B_view = ktdp.construct_memory_view %B_start_address, sizes: [96, 64], strides: [64, 1] {
         coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 95 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-        memory_space = #ktdp.spyre_memory_space<HBM>
+        memory_space = #ktdp.memory_space<global>
     } : memref<96x64xf16>
 
     %C_view = ktdp.construct_memory_view %C_start_address, sizes: [96, 64], strides: [64, 1] {
         coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 95 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-        memory_space = #ktdp.spyre_memory_space<HBM>
+        memory_space = #ktdp.memory_space<global>
     } : memref<96x64xf16>
 
     scf.for %i = %c0 to %tile_size step %c1 {

.github/workflows/ci.yml

@@ -37,7 +37,16 @@ jobs:
           LLVM_HASH=$(curl -fsSL "https://raw.githubusercontent.com/torch-spyre/ktir-mlir-frontend/$FRONTEND_COMMIT/cmake/llvm-hash.txt")
           curl -fsSL "$SETUP_MLIR" -o /tmp/setup_mlir.py
           MLIR_DIR=$(GIT_PAT="${{ secrets.GITHUB_TOKEN }}" uv run python /tmp/setup_mlir.py --hash "$LLVM_HASH" --repo torch-spyre/ktir-mlir-frontend)
-          uv pip install scikit-build-core "nanobind>=2.12.0"
+          # The install step below uses --no-build-isolation, which bypasses
+          # ktir-mlir-frontend's build-system.requires — so the `cmake>=4.0` pin
+          # it declares upstream (torch-spyre/ktir-mlir-frontend#59) is not
+          # applied and must be satisfied here instead. Keep this in sync with
+          # that pin. cmake>=4.0 is required: CMake 3.x writes the
+          # full target name into its file-API reply filename, and MLIR's
+          # mlir_generate_type_stubs() builds a 283-char target name by joining
+          # DEPENDS_TARGETS, overflowing NAME_MAX (255). CMake 4.0 truncates the
+          # name and relies on the trailing hash.
+          uv pip install scikit-build-core "nanobind>=2.12.0" "cmake>=4.0" "ninja>=1.11"
           echo "CMAKE_ARGS=-DMLIR_DIR=$MLIR_DIR" >> $GITHUB_ENV
 
       - name: Install project and dependencies

CLAUDE.md

@@ -13,7 +13,17 @@ The full spec is also mirrored in `.claude/skills/ktir-dialect.md`.
 - Specifically verify:
   - `ktdp` dialect ops (`get_compute_tile_id`, `construct_memory_view`, `construct_distributed_memory_view`, `construct_access_tile`, `construct_indirect_access_tile`, `load`, `store`) match the spec's syntax, operands, attributes, and semantics.
   - `AccessTileType` element type is always `index`.
-  - `SpyreMemorySpaceAttr` uses `#ktdp.spyre_memory_space<...>` syntax.
+  - `MemorySpaceAttr` uses `#ktdp.memory_space<global|ct_local[, ct_id = N]>` syntax.
+    **⚠️ This CONFLICTS with RFC 0682**, which still specifies a `KtdpMemorySpaceAttr`
+    interface with a Spyre-specific `SpyreMemorySpaceAttr` spelled
+    `#ktdp.spyre_memory_space<HBM|LX[, core = N]>` (plus an `unspecified` kind).
+    ktir-mlir-frontend#58 removed that interface and renamed the attribute; the RFC
+    has not been updated to match. The dialect is the executable authority here — the
+    RFC spelling no longer parses at all — so follow the syntax above and treat the
+    RFC as stale on this point until it is revised. Tracked as gap row 4a in
+    `docs/gap_analysis.md`. The interpreter still uses `HBM`/`LX` internally;
+    the parsers map the dialect kinds onto those names via
+    `KTDP_MEMORY_SPACE_KINDS` in `ktir_cpu/ir_types.py`.
   - `coordinate_set` uses `IntegerSetAttr` (affine integer sets).
   - `base_map` and `access_tile_order` use `AffineMapAttr`.
   - `access_tile_order` follows lexicographic semantics (rightmost = innermost).

docs/gap_analysis.md

@@ -3,7 +3,7 @@
 **Date**: 2026-05-30
 **Spec**: [RFC 0682 — KTIR Spec](https://github.com/torch-spyre/RFCs/blob/main/0682-KtirSpec/0682-KtirSpecRFC.md)
 
-**Legend**: ✅ implemented — 🟡 partial — ❌ not implemented — 🧪 experimental (tracks an unmerged upstream spec PR; semantics may change)
+**Legend**: ✅ implemented — 🟡 partial — ❌ not implemented — 🧪 experimental (tracks an unmerged upstream spec PR; semantics may change) — ⚠️ spec conflict (implementation intentionally diverges from the RFC; the RFC needs updating)
 
 ---
 
@@ -23,7 +23,8 @@
 | # | Spec Item | Status | Notes |
 |---|-----------|--------|-------|
 | 3 | `AccessTileType` with dynamic dimensions (`?`) | ❌ | The spec allows `access_tile<? x 64 x index>` (partially/fully dynamic shapes). The parser only extracts static integer dimensions — dynamic `?` dimensions are silently dropped. |
-| 4 | `MemorySpaceAttr` (generic) | 🟡 | The parser extracts `SpyreMemorySpaceAttr` (`HBM`/`LX`), but the spec describes `MemorySpaceAttr` as a generic extensible wrapper that could encapsulate other hardware backends. The implementation hardcodes Spyre-specific memory spaces only. |
+| 4 | `MemorySpaceAttr` (generic) | ✅ | The RFC's concern here — that the attribute was Spyre-specific rather than a generic extensible wrapper — was addressed upstream by [ktir-mlir-frontend#58](https://github.com/torch-spyre/ktir-mlir-frontend/pull/58), which removed the `KtdpMemorySpaceAttr` interface and made the attribute itself device-agnostic. `ktir_cpu` parses the new spelling and maps it onto the interpreter's `HBM`/`LX` via `KTDP_MEMORY_SPACE_KINDS` in `ktir_cpu/ir_types.py`, alongside the `MemRef.memory_space` validation that defines those names, so Spyre specifics stay confined to the simulator and latency model. **The RFC text itself is now stale — see row 4a.** |
+| 4a | `MemorySpaceAttr` spelling conflicts with RFC | ⚠️ **spec conflict** | **The implementation intentionally diverges from RFC 0682, and the RFC needs updating.** The RFC specifies `#ktdp.spyre_memory_space<HBM\|LX[, core = N]>` with an `unspecified` kind; [ktir-mlir-frontend#58](https://github.com/torch-spyre/ktir-mlir-frontend/pull/58) replaced this with `#ktdp.memory_space<global\|ct_local[, ct_id = N]>` and dropped `unspecified` with no replacement. This is a semantic change, not just a rename: the enum went from naming *devices* (HBM/LX) to naming *visibility* (reachable by all compute tiles vs. private to one). The RFC spelling no longer parses in the dialect at all, so the implementation follows the dialect. **Action: RFC 0682 §MemorySpaceAttr should be revised to match; until then treat the RFC as stale on this point.** |
 
 ## C. Affine/Polyhedral Attributes
 

examples/ktir/ffn_swiglu.mlir

@@ -26,27 +26,27 @@ module {
     // Create memory views
     %x_view = ktdp.construct_memory_view %x_ptr, sizes: [1, 64], strides: [64, 1] {
       coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 0 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<1x64xf16>
 
     %w_gate_view = ktdp.construct_memory_view %w_gate_ptr, sizes: [64, 128], strides: [128, 1] {
       coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 63 >= 0, d1 >= 0, -d1 + 127 >= 0)>,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<64x128xf16>
 
     %w_up_view = ktdp.construct_memory_view %w_up_ptr, sizes: [64, 128], strides: [128, 1] {
       coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 63 >= 0, d1 >= 0, -d1 + 127 >= 0)>,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<64x128xf16>
 
     %w_down_view = ktdp.construct_memory_view %w_down_ptr, sizes: [128, 64], strides: [64, 1] {
       coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 127 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<128x64xf16>
 
     %out_view = ktdp.construct_memory_view %out_ptr, sizes: [1, 64], strides: [64, 1] {
       coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 + 0 >= 0, d1 >= 0, -d1 + 63 >= 0)>,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<1x64xf16>
 
     // Load input x

examples/ktir/ffn_swiglu_4core.mlir

@@ -123,12 +123,12 @@ module {
 
     %x_view = ktdp.construct_memory_view %x_ptr, sizes: [4, 256], strides: [256, 1] {
       coordinate_set = #x_set,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<4x256xf16>
 
     %out_view = ktdp.construct_memory_view %out_ptr, sizes: [4, 256], strides: [256, 1] {
       coordinate_set = #x_set,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<4x256xf16>
 
     // ---- W_gate [256, 1024] distributed view: 4 column shards ----
@@ -139,19 +139,19 @@ module {
 
     %gate_p0 = ktdp.construct_memory_view %w_gate_ptr, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_0,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %gate_p1 = ktdp.construct_memory_view %gate_p1_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_1,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %gate_p2 = ktdp.construct_memory_view %gate_p2_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_2,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %gate_p3 = ktdp.construct_memory_view %gate_p3_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_3,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
 
     %w_gate_dist = ktdp.construct_distributed_memory_view
@@ -166,19 +166,19 @@ module {
 
     %up_p0 = ktdp.construct_memory_view %w_up_ptr, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_0,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %up_p1 = ktdp.construct_memory_view %up_p1_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_1,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %up_p2 = ktdp.construct_memory_view %up_p2_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_2,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %up_p3 = ktdp.construct_memory_view %up_p3_base, sizes: [256, 256], strides: [1024, 1] {
       coordinate_set = #gate_col_3,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
 
     %w_up_dist = ktdp.construct_distributed_memory_view
@@ -193,19 +193,19 @@ module {
 
     %down_p0 = ktdp.construct_memory_view %w_down_ptr, sizes: [256, 256], strides: [256, 1] {
       coordinate_set = #down_row_0,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %down_p1 = ktdp.construct_memory_view %down_p1_base, sizes: [256, 256], strides: [256, 1] {
       coordinate_set = #down_row_1,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %down_p2 = ktdp.construct_memory_view %down_p2_base, sizes: [256, 256], strides: [256, 1] {
       coordinate_set = #down_row_2,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
     %down_p3 = ktdp.construct_memory_view %down_p3_base, sizes: [256, 256], strides: [256, 1] {
       coordinate_set = #down_row_3,
-      memory_space = #ktdp.spyre_memory_space<HBM>
+      memory_space = #ktdp.memory_space<global>
     } : memref<256x256xf16>
 
     %w_down_dist = ktdp.construct_distributed_memory_view

examples/ktir/nested_yield.ktir

@@ -5,7 +5,7 @@ module {
     %c2 = arith.constant 2 : index
     %one = arith.constant dense<1.000000e+00> : tensor<4xf32>
     %zero = arith.constant dense<0.000000e+00> : tensor<4xf32>
-    %o_desc = ktdp.construct_memory_view %out, sizes: [4], strides: [1] {memory_space = #ktdp.spyre_memory_space<HBM>} : memref<4xf32>
+    %o_desc = ktdp.construct_memory_view %out, sizes: [4], strides: [1] {memory_space = #ktdp.memory_space<global>} : memref<4xf32>
 
     %sum = scf.for %i = %c0 to %c2 step %c1 iter_args(%acc = %zero) -> (tensor<4xf32>) {
       %next = arith.addf %acc, %one : tensor<4xf32>

examples/ktir/reduce_generic.mlir

@@ -2,7 +2,7 @@ module {
   func.func @reduce_explicit_region(%arg0: index) attributes {grid = [1, 1]} {
     %c0 = arith.constant 0 : index
     %cst = arith.constant 0.000000e+00 : f16
-    %view = ktdp.construct_memory_view %arg0, sizes : [1, 4], strides : [4, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>, memory_space = #ktdp.spyre_memory_space<HBM>} : memref<1x4xf16>
+    %view = ktdp.construct_memory_view %arg0, sizes : [1, 4], strides : [4, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>, memory_space = #ktdp.memory_space<global>} : memref<1x4xf16>
     %acc = ktdp.construct_access_tile %view[%c0, %c0] {
         access_tile_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>,
         access_tile_order = affine_map<(d0, d1) -> (d0, d1)>
@@ -22,7 +22,7 @@ module {
     // linalg.reduce generic format returns tensor<1xf16>; extract scalar before splat
     %scalar = tensor.extract %reduced[%c0] : tensor<1xf16>
     %splat = tensor.splat %scalar : tensor<1x4xf16>
-    %out_view = ktdp.construct_memory_view %arg0, sizes : [1, 4], strides : [4, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>, memory_space = #ktdp.spyre_memory_space<HBM>} : memref<1x4xf16>
+    %out_view = ktdp.construct_memory_view %arg0, sizes : [1, 4], strides : [4, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>, memory_space = #ktdp.memory_space<global>} : memref<1x4xf16>
     %out_acc = ktdp.construct_access_tile %out_view[%c0, %c0] {
         access_tile_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 3 >= 0)>,
         access_tile_order = affine_map<(d0, d1) -> (d0, d1)>

examples/ktir/reduce_multiop.mlir

@@ -6,7 +6,7 @@ module {
   func.func @reduce_multiop(%arg0: index) attributes {grid = [1, 1]} {
     %c0 = arith.constant 0 : index
     %cst = arith.constant 0xFC00 : f16  // -inf (identity for max)
-    %view = ktdp.construct_memory_view %arg0, sizes : [1, 8], strides : [8, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>, memory_space = #ktdp.spyre_memory_space<HBM>} : memref<1x8xf16>
+    %view = ktdp.construct_memory_view %arg0, sizes : [1, 8], strides : [8, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>, memory_space = #ktdp.memory_space<global>} : memref<1x8xf16>
     %acc = ktdp.construct_access_tile %view[%c0, %c0] {
         access_tile_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>,
         access_tile_order = affine_map<(d0, d1) -> (d0, d1)>
@@ -25,7 +25,7 @@ module {
 
     %scalar = tensor.extract %reduced[%c0] : tensor<1xf16>
     %splat = tensor.splat %scalar : tensor<1x8xf16>
-    %out_view = ktdp.construct_memory_view %arg0, sizes : [1, 8], strides : [8, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>, memory_space = #ktdp.spyre_memory_space<HBM>} : memref<1x8xf16>
+    %out_view = ktdp.construct_memory_view %arg0, sizes : [1, 8], strides : [8, 1] {coordinate_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>, memory_space = #ktdp.memory_space<global>} : memref<1x8xf16>
     %out_acc = ktdp.construct_access_tile %out_view[%c0, %c0] {
         access_tile_set = affine_set<(d0, d1) : (d0 >= 0, -d0 >= 0, d1 >= 0, -d1 + 7 >= 0)>,
         access_tile_order = affine_map<(d0, d1) -> (d0, d1)>

examples/ktir/ring_reduce.mlir

@@ -40,7 +40,7 @@ module {
     %row_view = ktdp.construct_memory_view %row_ptr,
                   sizes: [1, 128], strides: [128, 1] {
       coordinate_set = #row_set,
-      memory_space   = #ktdp.spyre_memory_space<HBM>
+      memory_space   = #ktdp.memory_space<global>
     } : memref<1x128xf16>
 
     // (2) Access tile and load
@@ -89,7 +89,7 @@ module {
       %out_view = ktdp.construct_memory_view %out_ptr,
                     sizes: [1, 128], strides: [128, 1] {
         coordinate_set = #row_set,
-        memory_space   = #ktdp.spyre_memory_space<HBM>
+        memory_space   = #ktdp.memory_space<global>
       } : memref<1x128xf16>
 
       %out_acc = ktdp.construct_access_tile %out_view[%c0, %c0] {