better throughput scheduling

update results_comparison.csv

docs/compiler/scheduling-implementation.md

@@ -6,6 +6,24 @@ there; the details below describe current implementation choices.
 
 ## Publication, order, and local materialization
 
+Deferred transfer planning allocates one host slot for repeated full-fragment
+requirements with the same physical producer, payload type, and source slot.
+One immutable producer result identifies one logical inference generation.
+Scalar source projections retain separate publications until their exact
+geometry has a common representation in both analyses.
+
+Boundary planning moves a shared publication's notifications to its earliest
+existing send boundary. The first notification stores the payload before READY;
+later notifications emit READY only. Each reader retains its load and READY
+count. FREE planning includes every physical reader before the first overwrite
+of the shared slot. Existing unique writer-reader releases, register allocation,
+capacity-driven FREE-group merging, and restart barriers remain in force.
+
+Host-slot allocation and shared-boundary planning take expected linear time
+and space in the number of physical consumer transfers. Structured send runs
+retain compact per-lane store flags. They do not duplicate payload shaping
+for notification-only readers.
+
 [`materializeScheduledCompute`](../../src/PIM/Dialect/Spatial/Passes/Transforms/MergeComputeNodes/ScheduledComputeMaterialization.cpp) records
 graph IDs for publication identity, not execution order. Class lanes retain
 graph encounter order independently of physical core IDs, preserving regular
@@ -65,10 +83,14 @@ remain approximations, not extra inferred memory traffic.
 
 [`PipelineScheduling.cpp`](../../src/PIM/Dialect/Spatial/Passes/Transforms/MergeComputeNodes/Scheduling/PipelineScheduling.cpp) caches a per-template
 adjustment between physical execution cost and nominal volume priority, scaling
-it by chunk lanes. Partitioning and packing use the nominal priorities;
-transposes count as bulk moves there. PEFT, final schedule evaluation, and
-reported per-core demand use physical estimates. These quantities must not be
-substituted for one another when interpreting results.
+it by chunk lanes. The original partitioning and packing candidate uses nominal
+priorities; transposes count as bulk moves there. The memory-aware candidate
+uses execution estimates for partitioning, retaining the existing core-budget
+and packing heuristics. Final
+selection evaluates bounded alternatives after physical placement, retaining
+the original candidate when the combined resource estimates worsen. PEFT,
+final schedule evaluation, and reported per-core demand use physical estimates.
+These quantities must not be substituted for measured simulator periods.
 
 Placement compares maximum per-core serial compute plus incident same-stage
 transfer demand, then completion/span and compute load. Each participating core

docs/compiler/scheduling.md

@@ -57,8 +57,37 @@ paths exclude core-order constraints; completion includes them. Stage spans
 exclude cross-stage routing, restart/host synchronization, and contention.
 Simulator latency and measured throughput remain the performance gates.
 
-Pipeline partitioning uses ordered-packing/dependency-tail priorities and
-nominal movement volumes. PEFT and final evaluation use physical cost estimates.
+Pipeline scheduling retains the original ordered-packing/dependency-tail
+heuristic using nominal movement volumes. A second search uses execution
+estimates and aggregate serialized shared-memory service, minimizing their
+maximum. Its DP keeps at most eight compute/memory trade-offs per state;
+four final alternatives and the initial partition undergo the existing core
+allocation, topology placement, and capacity verification. The phase-1 winner
+remains a fallback. A second bounded search accounts for shared publications.
+Selection retains the fallback unless the modeled bottleneck improves. Selection also requires that
+shared-memory service plus maximum stage span does not increase. The same
+check applies to shared-memory service plus maximum per-core compute work.
+These guards limit compute imbalance; their sums do not predict simulator
+periods. Sharing-aware alternatives must also preserve maximum stage span,
+because placement-dependent baseline loads remain approximate. PEFT is unchanged.
+
+`ComputeGraph` retains physical publication and consumer identities separately
+from aggregated dependency edges. Cross-stage demands charge one store per
+shared physical publication and one load per consumer transfer. Publication
+identity includes the immutable result generation, exact payload type, and
+physical source fragment. Scalar projections retain separate stores
+conservatively. Same-stage local/direct transfers incur no host traffic.
+Function inputs, constants, and outputs supply a separate baseline estimate.
+The target adapter supplies access width and read/write service times; request
+rounding precedes aggregation. Serialized service is shared by all stages and
+is not added to individual stage spans. Baseline loads remain approximate
+before placement, bufferization, aliasing, and load folding.
+Scalar publication stores round each contiguous source run separately.
+Consumer load counts can remain conservative before load folding.
+The scheduler evaluates boundary demand again after physical placement.
+Full graph fragments resolve to unique physical producers, so their sharing
+does not depend on reader placement. Deferred planning uses the same identity
+rule and retains separate loads, including repeated loads on one reader core.
 Placement ranks maximum per-core compute/incident-transfer demand, then stage
 completion and compute load; within 1% demand, stage span breaks the tie.
 These are placement heuristics, not a steady-state timing model.
@@ -81,7 +110,8 @@ proved hardware infeasibility.
 ## Complexity and limits
 
 Let `T` be tasks, `E` dependencies, `P` cores, `G` groups, `S` stages,
-`R` weight references, `W` distinct weights, and `C` modeled work.
+`R` weight references, `W` distinct weights, `C` modeled work, `F` physical
+fragment/consumer demands, and bounded frontier size `K = 8`.
 
 | Analysis | Time / storage |
 |---|---|
@@ -89,13 +119,18 @@ Let `T` be tasks, `E` dependencies, `P` cores, `G` groups, `S` stages,
 | Weight indexing | Up to `O(R W)` equality comparisons |
 | Weight lower bounds | `O(R + W)` / `O(W)` bits |
 | Constructive best fit | `O(T log T + P R + P W)` / `O(P W)` bits plus `O(T + P)`; bounded retries only on failure |
-| Partition DP | Up to `O(S G² ((T + R) log C + W))` plus dependency traversal / `O(S G²)` cache |
+| Partition DP | Up to `O(S G² ((T + R) log C + W + K³))` plus dependency traversal / `O(S G² + S G K)`; at most five additional physical placements per memory objective |
+| Cut memory service | Expected `O(F + G)` time / `O(F + G)` scratch and retained demands |
 | Topology clustering / cached PEFT distances | `O(P²)` time |
 | Concat cost extraction | `O(A D)` for `A` inputs of rank `D`; constant auxiliary space |
 | Cached pipeline priorities | `O(T + D)` time / `O(T + G)` space for `D` template-body operations |
-| Exact projections | `O(Q + L)` time/temporary space for `Q` slot visits and `L` producer lanes; publication maps cached |
+| Exact projections | `O(Q + L)` time for `Q` slot visits and `L` producer lanes; repeated demands aggregate by projection and fragment |
 | Conservative producer tracing | Linear in the input projection DAG, including captures |
 
 Latency insertion-gap searches can remain quadratic. Issue overhead,
 eliminated assembly copies, contention, and pipeline synchronization remain
 cost approximations. Changes require matched execution measurements.
+Loop-invariant projections use trip-count multiplication. Loop-invariant
+resident weights are collected once. Loop-dependent projections and weights
+can still require iteration visits; retained projection demands scale with
+distinct physical fragments instead of repeated visits.