PAPER: INTRODUCTIONLarge language models (LLMs) (Achiam et al., 2023;Touvron et al., 2023a;b) are extensively utilized across a range of tasks like chatbot (Roller et al., 2020), code generation (Mark et al., 2021), reasoning (Yao et al., 2023;Besta et al., 2023;Ning et al., 2023), etc. Traditionally, the interactions between LLMs and application users are sequential: the user sends a new prompt after completion result of the previous prompt is received. However, many applications are now designed to process sequences with an internal tree structure, including self-consistency (Wang et al., 2022), few-shot prompting (Mann et al., 2020), multi-step reasoning (Yao et al., 2023;Hao et al., 2023;Xie et al., 2024), and speculative decoding (Miao et al., 2023;Cai et al., 2024), etc, as shown in Figure 1. Usually, these applications produce substantially more tokens than traditional ones, to provide large space for tree search (Graves, 2012;Lu et al., 2022;Liu et al., 2023) or selection, as shown in Table 1. We need a more efficient decoding algorithm in response to this interaction paradigm change from sequence-based decoding to tree-based decoding. (Wei et al., 2022) and tree-based ToT (Yao et al., 2023) decoding for a reasoning task. The task is sorting 128 numbers from Besta et al. (2023). The total generated tokens of CoT is only 525 while 38,315 in ToT, resulting in inefficiency in end-to-end latency (second) and IO (TB). IO mainly consists of two parts as follows. (i) KV cache: IO-KV; (ii) Partial results during attention calculation like QK T and softmax: IO-PA; Baselines: (i) Flash-Decoding (Dao et al., 2023); (ii) Tree Attention: tree attention in Medusa (Cai et al., 2024).Latency IO-KV IO When requests have shared prefixes in a tree structure, existing inference systems (Hugging Face; NVIDIA; Kwon et al., 2023) designed for sequence-based decoding introduce redundancy by failing to be prefix-aware at one or more of the following three levels: (1) computation-for instance, the redundant recomputation of KV caches for shared prompts across requests in a batch (Hugging Face); (2) memory storage-for example, the redundant storage of KV caches for shared prefixes (Hugging Face; Kwon et al., 2023; NVIDIA); (3) memory access (IO)-such as repeatedly loading the KV cache of a shared system prompt during attention calculations (Hugging Face; Kwon et al., 2023;NVIDIA). Although some tree-based inference systems (Zheng et al., 2023;Gim et al., 2023;Cai et al., 2024;Miao et al., 2023) address the first two issues, they largely overlook the third and arguably the most crucial aspect: memory access, which is critical in the context of memory-bound LLM inference (Shazeer, 2019;Cai et al., 2024;Kim et al., 2023).Prompt 1Sequence-based decoding Step 2(G 2 ) Step history
================================================================================

REVIEW
--------------------------------------------------------------------------------
**Summary Of The Paper**  
The paper proposes **DEFT-Flatten**, a hardware-efficient attention algorithm designed to optimize **tree-structured decoding** in large language models (LLMs). Traditional sequence-based decoding methods suffer from inefficiencies in **memory access** and **GPU utilization** when handling tree-structured decoding tasks such as **multi-step reasoning**, **speculative decoding**, and **few-shot prompting**. The authors identify two key challenges: (1) ensuring **prefix-awareness** to avoid redundant KV cache loading, and (2) achieving **load-balanced computation** across GPU cores. To address these, DEFT-Flatten introduces **KV-Guided Grouping** to reduce redundant KV cache access and **Flattened Tree KV Splitting** to balance workloads across GPU streams. The algorithm is evaluated on various tree-based decoding tasks, demonstrating **significant speedups** (up to 2.23×) in decoding latency compared to existing methods like Flash-Decoding, Tree Attention-Medusa, and Tree Attention-SpecInfer.

**Strengths**  
1. **Clear Problem Identification**: The paper accurately identifies a growing challenge in modern LLM deployment — the inefficiency of existing inference systems when handling tree-structured decoding tasks. This is a timely and relevant problem, especially as tree-based decoding becomes more prevalent in complex reasoning pipelines.  

2. **Conceptual Innovation**: The introduction of **KV-Guided Grouping** and **Flattened Tree KV Splitting** offers a principled approach to addressing **both memory access and compute load imbalance** in tree-structured decoding. These concepts are grounded in practical considerations of GPU architecture and memory hierarchy, suggesting potential broad utility.

3. **Empirical Validation Across Multiple Tasks**: The paper evaluates DEFT-Flatten on three distinct tree-based decoding tasks (**few-shot prompting**, **multi-step reasoning**, and **speculative decoding**) using real-world datasets and established benchmarks. The reported speedups (up to 2.23×) are notable and suggest meaningful gains in practical deployment scenarios.

4. **Comprehensive Baseline Comparisons**: The paper compares DEFT-Flatten with multiple prior works, including **Flash-Decoding**, **Tree Attention-Medusa**, and **Tree Attention-SpecInfer**, offering a nuanced understanding of its performance in relation to existing solutions.

**Weaknesses**  
1. **Insufficient Implementation Detail**: Despite the conceptual clarity of the proposed method, the **implementation specifics** remain vague. For example, the integration of **bit causal masks** and the **practical mechanics of flattened tree KV splitting** are not thoroughly explained, leaving gaps in reproducibility and understanding of the actual implementation.

2. **Ambiguities in Experimental Setup**: The **experimental methodology** is not fully transparent. Critical details such as **dataset choices**, **token lengths**, **exact hyperparameters**, and **model configurations** are often omitted or inadequately described, limiting the ability to interpret and reproduce the results.

3. **Missing Statistical Rigor**: The reported speedups and performance improvements are **not accompanied by statistical confidence intervals or p-values**, making it difficult to assess the **robustness and reliability** of the findings. This undermines the credibility of the empirical claims.

4. **Overlapping Contributions with Concurrent Work**: Several **concurrent efforts** (e.g., Ye et al., 2024a; Juravsky et al., 2024) also explore attention optimization for **large-batch single-context decoding**, raising concerns about the **originality and distinctiveness** of DEFT-Flatten. The paper should clarify how its approach diverges from and improves upon these concurrent proposals.

5. **Limited Scalability and Generalization Analysis**: The paper provides **qualitative descriptions** of scalability with respect to **model size and prompt length**, but lacks quantitative assessments (e.g., trend lines, regression analyses) to substantiate these claims. Moreover, the **applicability of DEFT-Flatten to sequence-based decoding** is not discussed, which limits the scope of the contribution.

**Questions For The Authors**  
1. Please provide a **formal derivation or proof** that the **Flattened Tree KV Splitting** strategy indeed ensures **workload balance** across GPU streams, and specify the **time complexity** of the splitting algorithm.  
2. Could you elaborate on the **mechanics of implementing KV-Guided Grouping**? Specifically, how are **shared prefixes identified and grouped**, and what is the **computation overhead** incurred during this process?  
3. How is the **block size** chosen in the **Flattened Tree KV Splitting** strategy, and what is the **empirical impact of varying block sizes** on performance?  
4. Does **DEFT-Flatten** extend the **bit causal mask (BCM)** capability beyond the **64-token limit** of **SpecInfer**, and if so, how is this achieved?  
5. Could you explain how the **Tree-Topology-Aware Global Reduction** differs from the **global reduction in Flash-Decoding**, and how it is implemented in the **OpenAI Triton** framework?

**Limitations Not Addressed By The Authors**  
1. The paper does not **fully address the limitations of DEFT-Flatten** in extreme scenarios, such as **very deep or wide trees**, or when the **token lengths vary drastically** across branches. Understanding these edge cases is crucial for assessing the **general robustness** of the method.  
2. The **potential applicability of DEFT-Flatten to sequence-based decoding** is not discussed, which leaves open the question of whether the method has **broader relevance** beyond tree-structured tasks.  
3. The **reproducibility of the experiments** is compromised due to the **lack of detailed hyperparameter settings, batch sizes, and training/inference configurations**, making it difficult for others to reproduce the results.

**Soundness**  
3 (Good)

**Contribution**  
3 (Good)

**Confidence**  
3 (Moderate)

**Rating**  
7 (Accept)

**Brief Justification For Rating**  
While the paper presents a compelling idea for optimizing **tree-structured decoding** in LLMs, the **insufficient technical detail**, **lack of statistical rigor**, and **overlaps with concurrent work** raise concerns about the **novelty and reproducibility** of the proposed method. Nonetheless, the **conceptual innovation** and **empirical validation** on real-world tasks make the paper acceptable for publication, albeit with the expectation that the authors address the noted shortcomings in future revisions.

================================================================================
