Pourquoi y a-t-il un impact important sur les performances lors du bouclage sur un tableau avec 240 éléments ou plus ?

Question

Lors de l'exécution d'une boucle de somme sur un tableau dans Rust, j'ai remarqué une énorme baisse des performances lorsque CAPACITY >= 240. CAPACITY = 239 est environ 80 fois plus rapide.

Existe-t-il une optimisation de compilation spéciale que Rust fait pour les tableaux "courts" ?

Compilé avec rustc -C opt-level=3 .

 use std::time::Instant;

const CAPACITY: usize = 240;
const IN_LOOPS: usize = 500000;

fn main() {
    let mut arr = [0; CAPACITY];
    for i in 0..CAPACITY {
        arr[i] = i;
    }
    let mut sum = 0;
    let now = Instant::now();
    for _ in 0..IN_LOOPS {
        let mut s = 0;
        for i in 0..arr.len() {
            s += arr[i];
        }
        sum += s;
    }
    println!("sum:{} time:{:?}", sum, now.elapsed());
}

Answer 1

En plus de la réponse de Lukas, si vous souhaitez utiliser un itérateur, essayez ceci :

 const CAPACITY: usize = 240;
const IN_LOOPS: usize = 500000;

pub fn bar() -> usize {
    (0..CAPACITY).sum::<usize>() * IN_LOOPS
}

Merci @Chris Morgan pour la suggestion sur le modèle de plage.

L' assemblage optimisé est assez bon :

 example::bar:
        movabs  rax, 14340000000
        ret