- Rating
- 1
- Confidence
- 4
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
The paper introduces TileTune, a system designed to reduce the time needed to find high-performing GPU kernel configurations using TileLang. It first uses static information from tile programs to prune candidate configurations before empirical evaluation. The remaining candidates are then evaluated using grouped compilation and compilation–benchmarking overlap, with the fastest valid kernel selected based on measured latency. The experiments compare end-to-end tuning time, pruning quality, and selection cost. Across 25 workloads on H200, TileTune achieves a 2.16× speedup over the four-GPU TileLang Autotune baseline. With a shortlist budget of α = 0.5, it retains the full-search optima across all evaluated workloads on A100, H200, and B300. Its selection cost is higher than Roller's but lower than XGBoost's, while both baselines retain the optima less consistently.
Critical strengths
(+) By leveraging static tile-program information for candidate pruning and streamlining the evaluation of retained configurations, TileTune reduces end-to-end autotuning time while preserving the full-search optima across the evaluated workloads.
Critical weaknesses
(-) Limited evidence for generality and pruning robustness. The evaluation mainly focuses on GEMM and attention-related workloads, with pruning tested only at a 50% shortlist budget. This makes it difficult to assess whether TileTune generalizes to kernels with different computational patterns or remains effective under more aggressive pruning. In addition, the ablation focuses on system-level optimizations without isolating the contributions of the work and underfill views. It therefore remains unclear whether combining these views through rank multiplication improves pruning quality over using either view alone.
(-) Overemphasis on comparisons with a baseline using fewer GPUs. The paper highlights speedups of 4.02–5.35× against the one-GPU TileLang baseline, while TileTune uses four GPUs. Although a resource-matched comparison is included, the aggregate speedup on H200 drops from 4.02× to 2.16×. Emphasizing the one-GPU results in the abstract and Figure 5 may give an exaggerated impression of the efficiency gains under equal GPU resources.
Questions for authors
Q1. Pruning budget sensitivity. How would TileTune perform under a smaller shortlist budget, such as α = 0.3? Would it still retain the full-search optima, and how would this affect the selected-kernel performance?
Q2. Generality across kernel types. Would TileTune remain effective on other types of tile-based kernels, such as reduction-heavy or data-movement-oriented kernels, without requiring kernel-specific modifications?
2 comments
Dear Reviewer ihn6,
Thank you again for your time and suggestions. As the discussion ends on November 18 (AoE), we would appreciate knowing whether our rebuttal has addressed your concerns. If so, we would be grateful if you would consider a possible score increase at your discretion. We are happy to clarify any remaining points before the deadline.
Best regards, The authors
Thank you for your rigorous review. We value your feedback on the evaluation of our work. We would like to clarify that while our paper includes a pruning model, the core contribution of TileTune is to rethink the autotune system in the era of tiled-based DSLs (As in Global Comment 1). We identify that the unique structure of tiled DSL programs enables a more efficient, system-level orchestration of compilation and benchmarking. Consequently, our cost model is designed to be simple and general, serving as a heuristic pruner to narrow the search space rather than a high-precision performance estimator. Nevertheless, we agree that the robustness and generality of the pruner are critical, and we appreciate your suggestions for deeper evaluation. Below, we address your concerns point by point.
W1. Ablation of work and underfill views. We thank the reviewer for this insightful suggestion. We have performed an ablation study to isolate the individual contributions of the "work view" and "underfill view." As shown in the table below (using H200 as a representative case),
The data confirms that the work view provides the necessary baseline accuracy (based on a classic roofline model), while the underfill view acts as a targeted correction for wave quantization effects.
W2. Overemphasis on comparisons with a baseline using fewer GPUs. We have updated our manuscript so that the speedups over the 4-GPU baseline are reported as our primary results (See Global Comment 2). We are sorry for the confusion caused by our earlier presentation.
Q1. Pruning budget sensitivity. As shown in the table in Global Comment 3, Even at α=0.3, TileTune stays essentially lossless (98.8%–99.5% geomean across all GPUs). At this tighter budget the optimum is no longer retained on every workload (23/25), yet the kernels actually selected stay near-optimal. Our primary objective is to develop a near-lossless pruner. Therefore, we adopt a conservative setting of α=0.5 to ensure the highest possible fidelity in performance.
Q2. Generality across kernel types. We agree that our evaluation did not separate the regimes. The pruner prices tile-level reuse, so it works best when the tile choice changes traffic that dominates latency. Reduction and data-movement kernels sit at the other end of this spectrum. Even there, the loss stays small, because a 50% shortlist already contains a near-optimal configuration. On B300:
We agree with the reviewer's concern about the generality of the cost model, and we believe its root cause is that the model's validity depends on which configuration inputs it actually covers. For instance, whether rasterization (thread-block swizzling) is enabled for a GEMM is an input we do not currently model at all, so two candidates that differ only in that setting are indistinguishable to the pruner. In the camera-ready version we will therefore constrain the pruner's inputs explicitly. This keeps the pruner within its intended role — an intermediate optimizer that discards clearly slow candidates — rather than an accurate GPU cost model.