Classic Round-Up Variant of Fast Unsigned Division by Constants: Algorithm and Full Proof
Yifei Li
TL;DR
This work addresses fast unsigned integer division by a constant divisor $d>0$ by elaborating the classic round-up variant that replaces division with a sequence of multiplications and shifts. It defines an $N$-bit precomputation using $p = \lceil \log_2 d \rceil$, $m = \lceil 2^{N+p}/d \rceil$, and $m_{lo} = m \& (2^{N}-1)$, yielding $q = \left\lfloor (m_{lo} n)/2^{N} \right\rfloor$ and the quotient $t = \left\lfloor (n+q)/2^{p} \right\rfloor$; an equivalent runtime form uses $t = \left\lfloor ((n-q)/2^{h}) \right\rfloor + q$ followed by a final shift, with $h = \min(p,1)$ to handle the $d=1$ edge case. The paper provides full correctness and feasibility proofs, including the relationship to a full magic number $m = \lceil 2^{N+p}/d \rceil$ and the lower $N$-bit part $m_{lo}$, as well as a no-overflow reformulation and a faster variant for bounded dividends (e.g., $n < 2^{N-1}$). These results formalize and close gaps in prior treatments, offering a division-by-constants technique that is both provably correct and practical for compilers and heterogeneous computing where magic-number computation may occur at runtime. Overall, the approach enables efficient, pipeline-friendly unsigned division using multiplication and shifts with explicit overflow considerations.
Abstract
Integer division instruction is generally expensive in most architectures. If the divisor is constant, the division can be transformed into combinations of several inexpensive integer instructions. This article discusses the classic round-up variant of the fast unsigned division by constants algorithm, and provides full proof of its correctness and feasibility. Additionally, a simpler variant for bounded dividends is presented.