4 releases

0.1.5 Jun 10, 2020
0.1.4 Aug 7, 2019
0.1.3 Aug 6, 2019
0.1.2 Aug 6, 2019

#377 in Procedural macros

Download history 4085/week @ 2024-01-10 4299/week @ 2024-01-17 5738/week @ 2024-01-24 5920/week @ 2024-01-31 4404/week @ 2024-02-07 5897/week @ 2024-02-14 8595/week @ 2024-02-21 8357/week @ 2024-02-28 7161/week @ 2024-03-06 6847/week @ 2024-03-13 6152/week @ 2024-03-20 8098/week @ 2024-03-27 9702/week @ 2024-04-03 7846/week @ 2024-04-10 11276/week @ 2024-04-17 8178/week @ 2024-04-24

38,976 downloads per month
Used in 18 crates (7 directly)


168 lines


Unroll for loops with integer literal bounds using an attribute-like macro.

On crates.io On docs.rs Build status

This crate provides a attribute-like macro unroll_for_loops that can be applied to functions. This macro looks for loops to unroll and unrolls them at compile time.

Why a procedural macro?

There is already a crate called Crunchy that unrolls loops with a macro_rules! macro. This crate provides an alternative solution for unrolling loops using an attribute-like macro instead. Some benefits of an item based attribute-like macro for unrolling loops are:

  • Macro invocation doesn't pollute the algorithm with annotations. Only one annotation is needed for each function.
  • Can use variables defined outside of the macro invocation.
  • Can be extended to do partial loop unrolling


Just add #[unroll_for_loops] above the function whose for loops you would like to unroll. Currently all for loops with integer literal bounds will be unrolled, although this macro currently can't see inside complex code (e.g. for loops within closures).


The following example demonstrates the kinds of code that can be unrolled automatically.

fn main() {
    println!("matrix = ");
    for i in 0..10 {
        for j in 0..10 {
            print!("({:?}, {:?})", i, j);

Good Uses

Of course not all code benefits from unrolling. For instance the code above is bound by I/O, and hence likely wont benefit from unrolling.

On the other hand, computational tasks, such as matrix multiplication, can benefit significantly as demonstrated by this simple example of a matrix-vector product:

fn mtx_vec_mul(mtx: &[[f64; 5]; 5], vec: &[f64; 5]) -> [f64; 5] {
    let mut out = [0.0; 5];
    for col in 0..5 {
        for row in 0..5 {
            out[row] += mtx[col][row] * vec[col];

A quick benchmark of this code generated by criterion shows a 3x performance increase with loop unrolling:

Matrix-Vector Product/Ordinary
time:   [2.7254 ns 2.7657 ns 2.8153 ns]

Matrix-Vector Product/Unrolled
time:   [878.71 ps 882.96 ps 888.01 ps]

The relative performance difference can be visualized in the violin plot:

Violin plot for Matrix-Vector product benchmark

Bad Uses

There are also places where this macro has no benefit where one might be expected. For instance, when computing a sum of elements in a large array, one might break the computation into independent blocks to allow the CPU to perform out of order execution optimizations. For example the following code:

fn sum(data: &[f64]) -> f64 {
    let mut sum = 0.0;
    for i in 0..data.len() {
        sum += data[i];

can get a substantial boost in performance when computed in chunks as:

fn sum(data: &[f64]) -> f64 {
    let mut sum = [0.0; 32];
    for i in (0..data.len()).step_by(32) {
        for j in 0..32 {
            sum[j] += data[i + j];

However this example is unlikely to benefit from the unroll_for_loops macro. A benchmark for unrolling sums is included for verification.

Having said this, a macro that can partially unroll loops as shown above can be very useful and is left for future work.

Contributions are welcome!


I would like to thank the author of Crunchy for the initial great solution to this problem.


This repository is licensed under either of

at your option.


~33K SLoC