clarify: partial-PE Shared TLOAD followed by cooperative TMATMUL

[jiale-wangOwO]

Clarify partial-PE Shared TLOAD followed by cooperative TMATMUL

Summary

Please clarify the intended 0.58.4 semantics for a common compiler-generated pattern:

# producer
BSTART.TLSU TLOAD, FP32
B.DIM LB0=64
B.DIM LB1=128
B.DIM LB2=64
B.IOS mask=0001, ->S0<32KB>
B.IOR [a1,a3],[]
BSTOP

BSTART.TLSU TLOAD, FP32
B.DIM LB0=32
B.DIM LB1=64
B.DIM LB2=32
B.IOS mask=0001, ->S1<8KB>
B.IOR [a2,a3],[]
BSTOP

# consumer
BSTART.CUBE TMATMUL, FP32
B.DATR FP32, byte0, Null
B.FPATR 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
B.DIM LB0=128
B.DIM LB1=32
B.DIM LB2=64
B.IOS S0, mask=1111
B.IOS S1, mask=1111
B.IOT mask=1111, last, ->T<4KB>
BSTOP

The actual example is from:

kernel_multi_thread_matmul_matmul_shared_cube_layout_B1_M256_N256_K256_tM128_tN32_tK64_DTypefloat.elf.diss

Relevant addresses in the disassembly:

• producer S0: 0x113a0–0x113b6
• producer S1: 0x113bc–0x113d0
• consumer TMATMUL: 0x113d2–0x113f6

The producer uses B.IOS mask=0001 for both Shared destinations. The later TMATMUL uses the same S0/S1 as Shared sources with mask=1111.

What is unambiguous in the current ASL

1. BSTART.TLOAD defines the Shared destination form as one B.IOS with SharedTileID, TSize, and PE_MASK, and says that each selected quarter uses that PE's private GPR base and stride:

• BSTART.TLOAD.asl:1

The same machine-readable ASL contract says that a successful Shared form updates selected valid elements and that unselected PE regions remain unchanged for partial-mask updates.

2. Shared state records initialized quarters explicitly:

• shared-registers.asl:12-16 defines SharedTileAnyQuarterInitialized();
• shared-registers.asl:18-24 defines SharedTileFullyInitialized();
• shared-registers.asl:26-30 defines SharedTilePublished();
• shared-registers.asl:32-40 defines SharedTileCooperativeMatrixReady().

SharedTileCooperativeMatrixReady() requires:

SharedTileDescriptorLegal(shared_tile_id)
shared.allocation_mask == '1111'
shared.initialized_mask == '1111'
shared.published
shared.tile.contents_defined

3. Shared CUBE source schema calls the readiness predicate before accepting the source:

• shared-cube-matrix.asl:3-25

Specifically, BundleMatrixSharedSourceSchemaLegal() returns FALSE when SharedTileCooperativeMatrixReady(shared_tile_id) is false.

4. Cooperative TMATMUL mask and Group-M behavior are defined separately:

• cube-tmatmul.asl:119-145 defines cooperative selection and requires the cooperative mask to be '1111';
• shared-cube-matrix.asl:42-73 defines M_per_PE and valid_M;
• cube-tmatmul.asl:282-355 derives the current PE fragment and destination after Shared schema checks.

5. The release ADRs add the following requirements:

• ADR-0097:67-73: Shared B.IOS destination allocates one Core-wide object; PE mode controls participation and quarter updates;
• ADR-0098:84-100: range modifiers attach only to the immediately preceding B.IOT/B.IOS group, and a multi-PE Shared destination requires B.ASSEMBLE;
• ADR-0100:50-76: cooperative TMATMUL uses group-M and requires four-PE participation/readiness.

The unresolved combination

From the above, the following interpretation appears required:

TLOAD B.IOS mask=0001
  => only the PE0-selected quarter is updated
  => PE1/PE2/PE3 quarters remain unchanged

TMATMUL B.IOS mask=1111
  => cooperative Shared source
  => S0/S1 must already satisfy SharedTileCooperativeMatrixReady()
  => all four quarters must be initialized and published

However, the ASL does not appear to state the complete producer sequence for the intended single-PE-issuer case.

Please clarify the following points in the spec:

1. Is TLOAD B.IOS mask=0001 intended to load only one fixed Shared quarter, or is one PE allowed to issue a complete logical Shared tile while the other PE quarters are implicitly populated?
2. If it loads only one quarter, what exact architectural instruction sequence must initialize the remaining three quarters before a TMATMUL B.IOS mask=1111 consumer?
3. Is a single-PE issuer followed by a four-PE TMATMUL an explicitly supported execution pattern? If yes, please define the issuer/consumer synchronization and the state transition from initialized_mask=0001 to initialized_mask=1111.
4. For Shared TLOAD with PE_MASK=1111, is B.ASSEMBLE INIT_LAST mandatory under ADR-0098, and what are the exact B.ASSEMBLE fields and association for the TLOAD form?
5. For a Local TLOAD followed by TMOV.L2S.PUBLISH, does TMOV.L2S.PUBLISH with PE_MASK=0001 produce only one quarter or can it complete a Shared generation? Please provide the normative source-order and INIT/MIDDLE/LAST carrier.
6. If the intended behavior is that an uninitialized quarter is readable by TMATMUL using ReadSharedTileWord() undefined values, this conflicts with the current SharedTileCooperativeMatrixReady() precondition. Please state which behavior is intended.
7. For the example above, should the compiler generate four producer executions (one per PE), a Shared B.ASSEMBLE generation, or a different Shared/Local operand form?

Requested normative clarification

Please add an ASL executable point and/or an explicit normative NDF covering:

• the legal producer carrier for a partial-mask Shared update that is later consumed cooperatively;
• whether single-PE issuer/four-PE consumer is supported;
• the required allocation_mask, initialized_mask, published, and contents_defined transitions;
• the required B.ASSEMBLE association, if any;
• the exact example carrier for the group_M=128, N=32, K=64 case.

Until this is clarified, a model must choose between two plausible interpretations: reject the example because the Shared primary is not fully ready, or accept a single-PE issuer as an implicit complete Shared producer. The current ASL predicates clearly define the readiness check, but do not provide an unambiguous end-to-end carrier for the latter behavior.

[ckwllawliet]

Confirmed design freeze for the Shared producer/consumer clarification, based on fresh origin/main baseline 5114fb6 (fetched 2026-08-26).

The intended 0.58.4 behavior is:

• PE_MASK selects participating issuer/consumer PEs; it does not select implicit Shared quarters.
• A single-PE Shared destination without B.ASSEMBLE writes the complete logical Shared parent. For example, B.IOS mask=0001, ->S0<32KB> is a complete 32KiB Shared producer, and the resulting generation may be consumed later with mask=1111.
• A multi-PE Shared destination must use B.ASSEMBLE. B.IOS.SizeCode is the current WriterTSize; B.ASSEMBLE.INIT.ParentSizeCode is the complete parent size; every PE supplies its own explicit offset; writer ranges must not overlap; LAST validates complete coverage and atomically publishes.
• Producer and consumer masks need not match.
• Shared readiness is hardware-maintained runtime state. The ASL model must represent parent-level whole_parent_ready separately from producer participation and coverage. No new READY instruction or encoding field is added.
• Every Shared source consumer requires the whole Shared parent to be ready and published. A pending/incomplete Shared generation is not exposed through partial streaming and must cause wait/no-effect rather than an undefined payload read.
• B.SUBVIEW is the only partial-source range mechanism. Its effective offset is per selected PE: each PE evaluates its own PE-local GPR value plus the encoded immediate. Therefore four PEs may select different ranges of one published Shared parent, such as four 8KiB ranges of a 32KiB source.
• TSTORE.SPART Function 14 is removed as an independent ISA/TLSU mode and is replaced by ordinary TSTORE plus Shared-source B.SUBVIEW.
• TMOV.L2S.INSERT, TMOV.L2S.PUBLISH, TMOV.S2L.BROADCAST, and TMOV.S2L.EXTRACT Functions 9-12 are likewise removed as independent modes and replaced by ordinary TMOV plus B.ASSEMBLE or B.SUBVIEW. Function 13 GMOV remains.
• Local capacity is 64KiB per individual Local TReg/destination, with a separate 256KiB aggregate Local pool per PE. Shared parent capacity remains 256KiB per Core.
• Cooperative TMATMUL applies only to Local-A/Shared-B and Shared-A/Shared-B forms: LB0=Core-total group_M, LB1=N, LB2=K, group_M=1..128, PE_MASK=1111, with the confirmed M16/M32 valid_M distribution. Local-only Matrix, Shared-A/Local-B, and TGEMV rules remain separate.

The implementation-ready handoff is recorded in the accompanying freeze contract. APPLY is not authorized by this comment; the executor must start from the fresh baseline, update owning ASL/NDF first, regenerate projections/evidence, add focused AVS coverage, and run the repository PR gates. The contract also marks the new Shared readiness, per-PE Shared B.SUBVIEW, legacy-Function removal, and Local-capacity clarification decisions that require a new ADR or an explicit amendment to the existing ADR owner.