[Perf] Adstack max-reducer: gate spec recognizer on bound_expr capture so dense-adstack kernels skip the dispatch entirely

Author: duburcqa

quadrants/codegen/llvm/codegen_llvm.cpp

@@ -1994,10 +1994,17 @@ void TaskCodeGenLLVM::finalize_offloaded_task_function() {
     current_task->ad_stack.allocas = ad_stack_allocas_info_;
     current_task->ad_stack.size_exprs = ad_stack_size_exprs_;
     current_task->ad_stack.bound_expr = ad_stack_static_bound_expr_;
-    // recognize `MaxOverRange` nodes that the runtime can reduce in parallel via the dedicated max-reducer dispatch
+    // Recognize `MaxOverRange` nodes that the runtime can reduce in parallel via the dedicated max-reducer dispatch
     // instead of letting the per-thread sizer enumerate. Indexing matches `ad_stack_size_exprs_` (same iteration order
-    // as the pre-scan above).
-    current_task->ad_stack.max_reducer_specs = recognize_adstack_max_reducer_specs(ad_stack_size_exprs_);
+    // as the pre-scan above). Gated on the same `ad_stack_sparse_threshold_bytes` predicate that decides whether
+    // `analyze_adstack_static_bounds` captures `bound_expr`: when the dense worst-case adstack footprint fits under the
+    // threshold, the per-thread sizer's host-eval path resolves the size_exprs cheaply and the parallel dispatch's
+    // per-launch h2d copy + reducer kernel + d2h readback is strictly more expensive than the work it replaces. Above
+    // threshold, the kernel is in sparse mode and a captured `MaxOverRange` whose iteration count would otherwise blow
+    // the `1<<24` cap is the reason the max-reducer exists. Mirrors the gate in `spirv_codegen.cpp`.
+    if (ad_stack_static_bound_expr_.has_value()) {
+      current_task->ad_stack.max_reducer_specs = recognize_adstack_max_reducer_specs(ad_stack_size_exprs_);
+    }
     // Snodes the task body mutates. Persisted on `OffloadedTask::snode_writes` so the LLVM
     // launcher can invalidate the per-task adstack metadata cache when a kernel that runs in
     // between mutated a SNode an enclosing `size_expr::FieldLoad` reads. Mirrors the SPIR-V

quadrants/codegen/spirv/spirv_codegen.cpp

@@ -203,10 +203,16 @@ TaskCodegen::Result TaskCodegen::run() {
 
   task_attribs_.ad_stack.per_thread_stride_float_compile_time = ad_stack_heap_per_thread_stride_float_;
   task_attribs_.ad_stack.per_thread_stride_int_compile_time = ad_stack_heap_per_thread_stride_int_;
-  // recognize `MaxOverRange` nodes the runtime can reduce in parallel via the dedicated max-reducer dispatch instead of
+  // Recognize `MaxOverRange` nodes the runtime can reduce in parallel via the dedicated max-reducer dispatch instead of
   // letting the per-thread sizer enumerate. Indexing matches `task_attribs_.ad_stack.allocas` (each entry's `size_expr`
-  // is the per-stack tree captured above).
-  {
+  // is the per-stack tree captured above). Gated on the same `ad_stack_sparse_threshold_bytes` predicate that decides
+  // whether `analyze_adstack_static_bounds` captures `bound_expr`: when the dense worst-case adstack footprint fits
+  // under the threshold, the per-thread sizer's host-eval path resolves the size_exprs cheaply and the parallel
+  // dispatch's per-launch buffer fill + cmdlist + `submit_synced` is strictly more expensive than the work it replaces.
+  // Above threshold, the kernel is in sparse mode and a captured `MaxOverRange` whose iteration count would otherwise
+  // blow the `1<<24` cap is the reason the max-reducer exists. The recognizer is the same in both cases; the gate just
+  // suppresses the per-launch dispatch site by leaving `max_reducer_specs` empty.
+  if (adstack_analysis.bound_expr.has_value()) {
     std::vector<SerializedSizeExpr> per_stack_size_exprs;
     per_stack_size_exprs.reserve(task_attribs_.ad_stack.allocas.size());
     for (const auto &a : task_attribs_.ad_stack.allocas) {