{"entries":[{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"1562-1571","path":"docs/spec-compiler-part-3-dfg.md","roles":["context","applicability"],"text":"The publisher creates a deterministic, collision-free construction-local\nsymbol for each outlined graph. An existing `loom.spatial_region.graph_name`\nmay be used only as a readability or debug stem. The temporary region does not\nown graph identity, and symbol spelling does not encode cut selection, source\norder, graph identity, or artifact identity.\n\nThe templates therefore omit the def + launch wrap to keep the\nbody's structural diff readable. The wrap is mandatory output, not\nan optimization, and is verified by the front-end's standard\nverifier rules in Section 9.","why":"Governing context of the sampled obligation: the publisher outlines each graph under a construction-local symbol and the def + launch wrap is mandatory output, which fixes published dataflow.graph definitions as the governed outputs."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"23-26","path":"docs/spec-compiler-part-3-dfg.md","roles":["applicability","input_construction"],"text":"the launch result is derived. Part 3 consumes each explicit\n`loom.spatial_region` inside its owning `dataflow.thread` and publishes the\ncorresponding graph definition and launch only after complete conversion and\nnative finalization succeed.","why":"Part 3 consumes each explicit loom.spatial_region inside its owning dataflow.thread and publishes the corresponding graph definition and launch; establishes that inputs must place regions inside thread definitions for the wrap obligation to apply."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"462-465","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction","input_well_formedness"],"text":"* `loom.spatial_region` is temporary compiler IR inside a\n  `dataflow.thread`. It owns one structured graph candidate with normalized\n  value, stream-channel, and memory boundary segments. It never appears in a\n  finalized Canonical Dataflow Program.","why":"loom.spatial_region is temporary IR inside a dataflow.thread owning one structured graph candidate with normalized value, stream-channel and memory boundary segments: the shape the grammar samples."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"564-569","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction","input_well_formedness"],"text":"6. `loom.spatial_region` is the temporary publication boundary inside an\n   existing `dataflow.thread`. Its operands are normalized as value inputs,\n   stream input channels, memory inputs, and stream output channels; its\n   results are value outputs followed by memory outputs. Each stream input\n   has one affine `source_map` from the consumer thread domain to the producer\n   thread domain. The lowering collects all explicit candidates before","why":"Normalized operand order (value inputs, stream inputs, memory inputs, stream outputs) and result order (value then memory outputs), plus one affine source_map per stream input; drives the sampled operandSegmentSizes/resultSegmentSizes and empty source_maps."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"573-574","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"canonical graph. Current publication supports nested `scf.if` completion\n   propagation. Stream channel segments become payload-typed graph stream","why":"Publication supports nested scf.if completion propagation, justifying the scf.if (and scf.for) nesting variants of the sampled publication sites."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"578-582","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"enter the canonical graph body. One binding denotes one ordered dynamic\n   event sequence. A fixed structured scope may contain multiple sequential\n   or structured mutually exclusive sites. Lowering emits one fixed ordinal\n   schedule, filters inactive branch sites, demuxes each input from the\n   filtered ordinal, and muxes outputs back into that same dynamic order.","why":"A fixed structured scope may contain multiple sequential or mutually exclusive sites, justifying sampling one or two sequential regions per thread."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"591-598","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_construction"],"text":"Branches may have unequal or empty site sets, and a later branch selector\n   may depend on an earlier input event. Enclosing loops repeatedly activate\n   the same schedule, so one or several static body sites may each fire\n   dynamically. Across repeated thread launches, each endpoint binding and\n   logical point concatenates these per-instance sequences in deterministic\n   launch issue order. Channel delivery pairs the resulting producer and\n   consumer sequences by message ordinal after applying `source_map`; it does\n   not pair thread activations or create activation-owned segments. Endpoint","why":"Enclosing loops repeatedly activate the same schedule, so a region nested in scf.for is a well-formed publication site rather than a rejected form."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"598-601","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_well_formedness"],"text":"not pair thread activations or create activation-owned segments. Endpoint\n   sites nested under `scf.parallel` or `scf.forall` have no inferred\n   traversal order and fail before publication. Unselected or non-fixed\n   graph-owned parallel forms also fail closed.","why":"Sites under scf.parallel or scf.forall and non-fixed graph-owned parallel forms fail before publication; the grammar excludes those nestings so sampled inputs stay publishable."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"499-506","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_well_formedness"],"text":"`llvm.func` or `func.func` definitions. An `llvm.call` or `func.call` inside a\n`dataflow.thread` definition's body is an InstructionCore call. If the callee\ncontains code that must become a `dataflow.graph` definition, Part 3 must\ninline or specialize that callee into the active thread definition\nbefore graph extraction. A `dataflow.thread.launch` is invalid\ntransitively inside every thread or graph definition. Non-inlined\nInstructionCore calls may remain only when their callee body is graph-free\nafter this preparation.","why":"Calls that would need inlining and any transitively nested dataflow.thread.launch are invalid in this preparation state; the grammar emits no calls and no launches inside regions or threads."},{"file_sha256":"d76b4cb1e888697d5f011a939e68cbc6230647c4d457c12d22689740aa43a44d","kind":"documentation_input","lines":"1413-1419","path":"docs/spec-compiler-part-3-dfg.md","roles":["input_well_formedness"],"text":"* `loom.spatial_region` is a transparent structured boundary. A blocking\n  receive inside that region cannot be justified by a send that follows the\n  region in the same stored-program strand merely because the published graph\n  launch becomes asynchronous. Such a transformation would turn an\n  inline-semantics deadlock into progress. A resulting retirement/send cycle\n  therefore identifies a deadlocking or incorrectly cut candidate; lowering\n  must not remove a wait by inventing a same-activation channel witness.","why":"A blocking receive inside the region that would require a same-activation channel witness marks a deadlocking candidate; the grammar emits no channel receives, so no sampled candidate is rejected on that ground."},{"file_sha256":"73f239de628bbf8d40145ecde732142ffcf6567c9483e6dc2286ae9176a6907c","kind":"language_definition","lines":"8-99","path":"include/Frontend/IR/LoomOps.td","roles":["input_construction","input_well_formedness"],"text":"def Loom_SpatialRegionOp : Loom_Op<\"spatial_region\", [\n    IsolatedFromAbove,\n    SingleBlock,\n    AttrSizedOperandSegments,\n    AttrSizedResultSegments,\n    RecursiveMemoryEffects\n]> {\n  let summary = \"Structured candidate for one SpatialCore graph\";\n  let description = [{\n    Holds one structured candidate inside a `dataflow.thread`. Operands are\n    normalized as value inputs, stream input channels, memory inputs, and\n    stream output channels. Results are normalized as value outputs followed\n    by memory outputs. Each stream input has one affine `source_map`.\n\n    This operation is temporary compiler IR. Successful publication replaces\n    it with one native-valid `dataflow.graph` and its matching launch.\n  }];\n\n  let arguments = (ins\n      Variadic<AnyType>:$valueInputs,\n      Variadic<Dataflow_ChannelType>:$streamInputs,\n      Variadic<AnyType>:$memoryInputs,\n      Variadic<Dataflow_ChannelType>:$streamOutputs,\n      AffineMapArrayAttr:$source_maps,\n      OptionalAttr<StrAttr>:$graph_name);\n\n  let results = (outs\n      Variadic<AnyType>:$valueResults,\n      Variadic<AnyType>:$memoryResults);\n\n  let regions = (region AnyRegion:$body);\n\n  let skipDefaultBuilders = 1;\n  let builders = [\n    OpBuilder<(ins\n        \"::mlir::ValueRange\":$valueInputs,\n        \"::mlir::ValueRange\":$streamInputs,\n        \"::mlir::ValueRange\":$memoryInputs,\n        \"::mlir::ValueRange\":$streamOutputs,\n        \"::mlir::TypeRange\":$valueResultTypes,\n        \"::mlir::TypeRange\":$memoryResultTypes,\n        \"::mlir::ArrayAttr\":$sourceMaps,\n        CArg<\"::mlir::StringAttr\", \"{}\">:$graphName), [{\n      $_state.addOperands(valueInputs);\n      $_state.addOperands(streamInputs);\n      $_state.addOperands(memoryInputs);\n      $_state.addOperands(streamOutputs);\n      $_state.addTypes(valueResultTypes);\n      $_state.addTypes(memoryResultTypes);\n      $_state.addAttribute(\"source_maps\", sourceMaps);\n      if (graphName)\n        $_state.addAttribute(\"graph_name\", graphName);\n      auto &properties = $_state.getOrAddProperties<Properties>();\n      properties.operandSegmentSizes = {\n          static_cast<int32_t>(valueInputs.size()),\n          static_cast<int32_t>(streamInputs.size()),\n          static_cast<int32_t>(memoryInputs.size()),\n          static_cast<int32_t>(streamOutputs.size())};\n      properties.resultSegmentSizes = {\n          static_cast<int32_t>(valueResultTypes.size()),\n          static_cast<int32_t>(memoryResultTypes.size())};\n      $_state.addRegion();\n    }]>\n  ];\n\n  let hasVerifier = 1;\n}\n\ndef Loom_SpatialYieldOp : Loom_Op<\"spatial_yield\", [\n    Terminator,\n    ParentOneOf<[\"::loom::SpatialRegionOp\"]>,\n    AttrSizedOperandSegments,\n    Pure\n]> {\n  let summary = \"Yield value and memory results from a spatial candidate\";\n\n  let arguments = (ins\n      Variadic<AnyType>:$values,\n      Variadic<AnyType>:$memories);\n\n  let skipDefaultBuilders = 1;\n  let builders = [\n    OpBuilder<(ins\n        \"::mlir::ValueRange\":$values,\n        \"::mlir::ValueRange\":$memories), [{\n      $_state.addOperands(values);\n      $_state.addOperands(memories);\n      auto &properties = $_state.getOrAddProperties<Properties>();\n      properties.operandSegmentSizes = {\n          static_cast<int32_t>(values.size()),\n          static_cast<int32_t>(memories.size())};\n    }]>","why":"TableGen definitions of loom.spatial_region and loom.spatial_yield: operand/result segment order, AffineMapArrayAttr source_maps, optional graph_name, single block, and terminator parentage — the exact generic-form spelling the grammar emits."},{"file_sha256":"f4e60b2e62b496c3714437bd100ab5236540abebd3685dfbd25eeddb37cb7160","kind":"language_definition","lines":"614-676","path":"include/Dataflow/IR/DataflowOps.td","roles":["input_construction","input_well_formedness"],"text":"def Dataflow_ThreadOp : Dataflow_Op<\"thread\", [\n    AutomaticAllocationScope,\n    IsolatedFromAbove,\n    HasParent<\"::mlir::ModuleOp\">,\n    SingleBlockImplicitTerminator<\"ThreadYieldOp\">,\n    FunctionOpInterface,\n    RecursiveMemoryEffects\n]> {\n  let summary = \"Symbol-bearing function-like AccCore kernel definition\";\n  let description = [{\n    Module-scope, function-like callable that holds an AccCore kernel\n    body. It does not itself execute; one or more\n    `dataflow.thread.launch` ops materialize launches of it.\n\n    The body's entry block has the layout\n    `(args_*, thread_ctrl: none, iv_*: index)` (per spec section\n    5.4.1). The first N block args mirror `function_type.inputs`; the\n    trailing `thread_ctrl` and grid index args are NOT in\n    `function_type` (they are launch-instance extras). Specifically:\n\n      * Args[0 .. N-1]   match `function_type.inputs` position-wise.\n      * Args[N]          is `none` -- the per-launch `thread_ctrl`\n                         slot, used as the AccCore start signal and\n                         consumed by root `dataflow.graph.launch` ops\n                         in the body as a dependency event.\n      * Args[N+1 .. end] are all `index` -- one per grid dim.\n\n    The custom assembly format prints the required `domain(...)` immediately\n    after the symbol and the trailing extras after the function-style\n    signature using a separate `ctrl ( ... )` clause\n    (the `thread_ctrl` slot) and an `iv ( ... )` clause (the\n    grid-index slots). Either / both clauses are optional; threads\n    written without them are accepted at parse time only when the op\n    is external (i.e., body is empty), since a body-having thread\n    must carry the trailing `thread_ctrl` slot per the verifier.\n\n    The op is `IsolatedFromAbove`; values flow in only through the\n    matching `dataflow.thread.launch` body operands.\n\n    Every definition carries one closed `domain`: DenseRectangular or\n    DynamicWork. Dense rank is derived solely from the trailing index block\n    arguments. DynamicWork carries one ordinary function-input ordinal and has\n    no coordinate suffix.\n  }];\n\n  let arguments = (ins\n      SymbolNameAttr:$sym_name,\n      TypeAttrOf<FunctionType>:$function_type,\n      Dataflow_ThreadDomainAttr:$domain,\n      OptionalAttr<StrAttr>:$sym_visibility,\n      OptionalAttr<DictArrayAttr>:$arg_attrs,\n      OptionalAttr<DictArrayAttr>:$res_attrs);\n\n  let regions = (region SizedRegion<1>:$body);\n\n  let hasCustomAssemblyFormat = 1;\n  let hasVerifier = 1;\n\n  let builders = [\n    OpBuilder<(ins\n        \"::llvm::StringRef\":$name,\n        \"::mlir::FunctionType\":$type,\n        \"::dataflow::ThreadDomainAttr\":$domain,","why":"dataflow.thread definition: module-scope symbol, required domain attribute, and entry-block layout (args, thread_ctrl none, grid indices) needed to spell the enclosing thread that owns each sampled region."},{"file_sha256":"f4e60b2e62b496c3714437bd100ab5236540abebd3685dfbd25eeddb37cb7160","kind":"language_definition","lines":"839-880","path":"include/Dataflow/IR/DataflowOps.td","roles":["context"],"text":"def Dataflow_GraphOp : Dataflow_Op<\"graph\", [\n    IsolatedFromAbove,\n    HasParent<\"::mlir::ModuleOp\">,\n    SingleBlockImplicitTerminator<\"GraphReturnOp\">,\n    FunctionOpInterface,\n    RecursiveMemoryEffects,\n    DeclareOpInterfaceMethods<RegionKindInterface>\n]> {\n  let summary = \"Symbol-bearing function-like SpatialCore graph definition\";\n  let description = [{\n    Module-scope, function-like callable holding the SpatialCore body\n    of a leaf dataflow graph. It does not itself execute; one or more\n    `dataflow.graph.launch` ops materialise launches of it inside the\n    body of a `dataflow.thread` definition.\n\n    `function_type` contains only application payload ports. Normalized\n    `input_segments` and `result_segments` classify those payloads as value,\n    stream, and memory ports. The body's distinguished leading `none` block\n    argument is the invocation start protocol endpoint, while launch `done`\n    is derived exclusively from `dataflow.graph.return.complete`; neither is\n    stored in the function type.\n\n    This is the only canonical graph definition surface.\n  }];\n\n  let arguments = (ins\n      SymbolNameAttr:$sym_name,\n      TypeAttrOf<FunctionType>:$function_type,\n      DenseI32ArrayAttr:$input_segments,\n      DenseI32ArrayAttr:$result_segments,\n      OptionalAttr<StrAttr>:$sym_visibility,\n      OptionalAttr<DictArrayAttr>:$arg_attrs,\n      OptionalAttr<DictArrayAttr>:$res_attrs);\n\n  let regions = (region SizedRegion<1>:$body);\n\n  let hasCustomAssemblyFormat = 1;\n  let hasVerifier = 1;\n\n  let builders = [\n    OpBuilder<(ins\n        \"::llvm::StringRef\":$name,","why":"dataflow.graph is the only canonical graph definition surface and is materialized for execution by dataflow.graph.launch ops; fixes the operation name selected in the postcondition as the outlined graph definition."},{"file_sha256":"f4e60b2e62b496c3714437bd100ab5236540abebd3685dfbd25eeddb37cb7160","kind":"language_definition","lines":"973-1005","path":"include/Dataflow/IR/DataflowOps.td","roles":["context"],"text":"def Dataflow_GraphLaunchOp : Dataflow_Op<\"graph.launch\", [\n    AttrSizedOperandSegments,\n    AttrSizedResultSegments,\n    DeclareOpInterfaceMethods<SymbolUserOpInterface>\n]> {\n  let summary = \"Asynchronous launch of a dataflow.graph callable\";\n  let description = [{\n    References a `dataflow.graph` definition by symbol from inside a\n    `dataflow.thread` body. Dependencies, value inputs, stream input channel\n    bindings, memory imports, and stream output channel bindings are explicit\n    operand segments. Each stream input binding carries one affine\n    `source_map` from the enclosing consumer thread domain to its producer\n    domain. Value outputs and memory exports are SSA results; the trailing\n    `done` result is the graph retirement event.\n\n    The operation resolves its callee through `SymbolUserOpInterface` but does\n    not project callee effects through `MemoryEffectsOpInterface`.\n  }];\n\n  let arguments = (ins\n      FlatSymbolRefAttr:$callee,\n      AffineMapArrayAttr:$source_maps,\n      Variadic<NoneType>:$dependencies,\n      Variadic<AnyType>:$valueInputs,\n      Variadic<Dataflow_ChannelType>:$streamInputs,\n      Variadic<AnyType>:$memoryInputs,\n      Variadic<Dataflow_ChannelType>:$streamOutputs);\n\n  let results = (outs\n      Variadic<AnyType>:$valueResults,\n      Variadic<AnyType>:$memoryResults,\n      NoneType:$done);","why":"dataflow.graph.launch references a dataflow.graph definition through the FlatSymbolRefAttr callee, fixing the attribute name used to resolve the launch side of the wrap in the postcondition."},{"file_sha256":"ac9844b024e5d4761973186a7fe17c93da2de169a36f778eafc78d5277dc1f63","kind":"verifier","lines":"102-145,200-228","path":"lib/Frontend/IR/LoomOps.cpp","roles":["input_well_formedness"],"text":"LogicalResult SpatialRegionOp::verify() {\n  auto thread = (*this)->getParentOfType<dataflow::ThreadOp>();\n  if (!thread)\n    return emitOpError(\"must appear inside a dataflow.thread body\");\n  if ((*this)->getParentOfType<SpatialRegionOp>())\n    return emitOpError(\"must not be nested in another loom.spatial_region\");\n  if (!getBody().hasOneBlock())\n    return emitOpError(\"must contain exactly one block\");\n\n  Block &entry = getBody().front();\n  if (entry.getNumArguments() != getNumOperands())\n    return emitOpError(\"entry block argument count (\")\n           << entry.getNumArguments() << \") must match operand count (\"\n           << getNumOperands() << ')';\n  for (auto [index, pair] : llvm::enumerate(\n           llvm::zip_equal(entry.getArguments(), getOperands()))) {\n    if (std::get<0>(pair).getType() != std::get<1>(pair).getType())\n      return emitOpError(\"entry block argument #\")\n             << index << \" type \" << std::get<0>(pair).getType()\n             << \" must match operand type \" << std::get<1>(pair).getType();\n  }\n\n  for (auto [index, value] : llvm::enumerate(getValueInputs()))\n    if (failed(verifyValueCarrier(getOperation(), value.getType(),\n                                  \"value input\", index)))\n      return failure();\n  for (auto [index, value] : llvm::enumerate(getValueResults()))\n    if (failed(verifyValueCarrier(getOperation(), value.getType(),\n                                  \"value result\", index)))\n      return failure();\n  for (auto [index, value] : llvm::enumerate(getMemoryInputs()))\n    if (failed(verifyMemoryCarrier(getOperation(), value.getType(),\n                                   \"memory input\", index)))\n      return failure();\n  for (auto [index, value] : llvm::enumerate(getMemoryResults()))\n    if (failed(verifyMemoryCarrier(getOperation(), value.getType(),\n                                   \"memory result\", index)))\n      return failure();\n\n  ArrayAttr sourceMaps = getSourceMaps();\n  if (sourceMaps.size() != getStreamInputs().size())\n    return emitOpError(\"source_maps count (\")\n           << sourceMaps.size() << \") must match stream input count (\"\n           << getStreamInputs().size() << ')';\nLogicalResult SpatialYieldOp::verify() {\n  auto parent = (*this)->getParentOfType<SpatialRegionOp>();\n  if (!parent)\n    return emitOpError(\"must appear inside loom.spatial_region\");\n  if (getValues().size() != parent.getValueResults().size())\n    return emitOpError(\"value count (\")\n           << getValues().size() << \") must match parent value result count (\"\n           << parent.getValueResults().size() << ')';\n  if (getMemories().size() != parent.getMemoryResults().size())\n    return emitOpError(\"memory count (\")\n           << getMemories().size()\n           << \") must match parent memory result count (\"\n           << parent.getMemoryResults().size() << ')';\n  for (auto [index, pair] :\n       llvm::enumerate(llvm::zip_equal(getValues(), parent.getValueResults())))\n    if (std::get<0>(pair).getType() != std::get<1>(pair).getType())\n      return emitOpError(\"value #\")\n             << index << \" type \" << std::get<0>(pair).getType()\n             << \" must match parent result type \"\n             << std::get<1>(pair).getType();\n  for (auto [index, pair] : llvm::enumerate(\n           llvm::zip_equal(getMemories(), parent.getMemoryResults())))\n    if (std::get<0>(pair).getType() != std::get<1>(pair).getType())\n      return emitOpError(\"memory #\")\n             << index << \" type \" << std::get<0>(pair).getType()\n             << \" must match parent result type \"\n             << std::get<1>(pair).getType();\n  return success();\n}","why":"SpatialRegionOp/SpatialYieldOp verifiers: parent thread required, no nesting, exactly one block, entry-block arguments matching operands one-for-one by type, source_maps count equal to stream inputs, and yield counts/types matching the region results — the acceptance rules the sampled inputs must satisfy."},{"file_sha256":"05567d70fd335a83ee2f46b2d0a3025a903207a88602a798b1845033e7f8ef64","kind":"implementation","lines":"912-918","path":"lib/Frontend/Lowering/LowerForToGraphPass.cpp","roles":["applicability"],"text":"::llvm::StringRef getArgument() const final {\n    return \"loom-lower-for-to-graph\";\n  }\n  ::llvm::StringRef getDescription() const final {\n    return \"Publish explicit loom.spatial_region operations as \"\n           \"dataflow.graph definitions plus dataflow.graph.launch ops.\";","why":"The --loom-lower-for-to-graph pass registration and description confirm this stage publishes explicit loom.spatial_region ops as dataflow.graph definitions plus dataflow.graph.launch ops, supporting the stage attribution of the claim and the retained subject flag."},{"file_sha256":"c25a72ad99349973a47f2a1e081b6b269920e25cc5f59f74619c2e7ce0c2b65d","kind":"test","lines":"39-52","path":"test/raise/scf-to-dfg-explicit-spatial-ownership.mlir","roles":["input_construction"],"text":"dataflow.thread private @selected_spatial domain(#dataflow.thread_domain<dense>)(\n    %target: memref<1xi32>, %value: i32) ctrl (%ctrl: none) {\n  \"loom.spatial_region\"(%value, %target)\n      <{operandSegmentSizes = array<i32: 1, 0, 1, 0>,\n        resultSegmentSizes = array<i32: 0, 0>}> ({\n    ^bb0(%payload: i32, %memory: memref<1xi32>):\n      %zero = arith.constant 0 : index\n      memref.store %payload, %memory[%zero] : memref<1xi32>\n      \"loom.spatial_yield\"()\n          <{operandSegmentSizes = array<i32: 0, 0>}> : () -> ()\n  }) {graph_name = \"selected_graph\", source_maps = []} :\n      (i32, memref<1xi32>) -> ()\n  dataflow.thread.yield\n}","why":"Published-case spelling of a dataflow.thread owning a loom.spatial_region with one value input and one memory input in generic form, used as the concrete syntax template for the sampled memory-boundary variant."},{"file_sha256":"df76d22d1149cf2929b700df6f97b58d27b64d523346cfbb4dbf9ba8e66baa49","kind":"test","lines":"62-79","path":"test/raise/scf-to-dfg-nested-completion.mlir","roles":["input_construction"],"text":"dataflow.thread private @for_completion domain(#dataflow.thread_domain<dense>)(%limit: index, %enabled: i1)\n      ctrl (%start: none) {\n    %c0 = arith.constant 0 : index\n    %c1 = arith.constant 1 : index\n    scf.for %i = %c0 to %limit step %c1 {\n      scf.if %enabled {\n        \"loom.spatial_region\"()\n            <{operandSegmentSizes = array<i32: 0, 0, 0, 0>,\n              resultSegmentSizes = array<i32: 0, 0>}> ({\n          ^bb0:\n            \"loom.spatial_yield\"()\n                <{operandSegmentSizes = array<i32: 0, 0>}> : () -> ()\n        }) {graph_name = \"for_graph\", source_maps = []} : () -> ()\n      }\n    }\n    dataflow.thread.yield\n  }","why":"Accepted spelling of an empty-boundary loom.spatial_region nested in scf.for/scf.if inside a dataflow.thread, used as the template for the nested publication-site variants."},{"file_sha256":"197ccf7e69971f310502d6a5181dd00cdf96a9711fe3abf64e2b339bfd958513","kind":"test","lines":"86-101","path":"test/raise/spatial-candidate-surface.mlir","roles":["input_construction"],"text":"//--- weighted-selected.mlir\ndataflow.thread private @selected_weighted domain(#dataflow.thread_domain<dense>)(%c: i1, %v: i32) ctrl (%start: none) {\n  %result = \"loom.spatial_region\"(%c, %v)\n      <{operandSegmentSizes = array<i32: 2, 0, 0, 0>,\n        resultSegmentSizes = array<i32: 1, 0>}> ({\n    ^bb0(%cond: i1, %value: i32):\n      cf.cond_br %cond weights([1, 9]), ^yes, ^no\n    ^yes:\n      \"loom.spatial_yield\"(%value)\n          <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n    ^no:\n      \"loom.spatial_yield\"(%value)\n          <{operandSegmentSizes = array<i32: 1, 0>}> : (i32) -> ()\n  }) {graph_name = \"selected_weighted_graph\", source_maps = []} :\n      (i1, i32) -> i32\n  dataflow.thread.yield","why":"Spelling of a loom.spatial_region with one value input and one value result yielded through loom.spatial_yield (segment arrays and function type); only the syntax of the value-output boundary is relied on, not this test's rejected weighted-CFG body."}],"primary_bundle_sha256":"22a1b498e96a507d7b6d70a8ebd03bfb43e4da86c39c48519a5cc9754ee3311e","project":"PolyArch/loom","revision":"48615bc5925ef4b9db8b4550b5d4322933cf4b7b","schema":"spectriad.authoring-context/v1","selection_sha256":"07f36e594c96cae05ca36f29434be6127c32dfbcc9d87f1cf2ecc03df22e55c7"}