Compiler Explorer

Source code

#![no_std]

#[inline(never)]
pub fn optimized() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp) = iter.next() {
        sum += cp;
    }
    sum
}

#[inline(never)]
pub fn optimized_str_bytes() -> u32 {
    let s = "12345678".as_bytes();

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp) = iter.next() {
        // here the inner iterator doesn't affect optimization
        if iter.next().is_some() {
            sum += cp as u32;
        }
    }
    sum
}

#[inline(never)]
pub fn unoptimized_str_chars() -> u32 {
    let mut iter = "12345678".chars();

let mut sum = 0;
    while let Some(cp) = iter.next() {
        // iter.next() does a lot, but is it the amount of calculations, or the inner iterator advancing?
        sum += cp as u32;
    }
    sum
}

#[inline(never)]
pub fn unoptimized() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp) = iter.next() {
        // here, there are not a lot of calculations
        // result of next is ignored
        iter.next();
        sum += cp;
    }
    sum
}

#[inline(never)]
pub fn unoptimized1() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp) = iter.next() {
        // is this second next that stops this from being optimized?
        sum += if iter.next().is_some() {
            cp
        } else {
            1
        };
    }
    sum
}

#[inline(never)]
pub fn unoptimized1a() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp1) = iter.next() {
        sum += if let Some(&cp2) = iter.next() {
            cp1 + cp2
        } else {
            cp1
        };
    }
    sum
}

#[inline(never)]
pub fn unoptimized1b() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 5; // start from a different value so the function isn't deduped with something else
    while let Some(&cp1) = iter.next() {
        sum += if let Some(&cp2) = iter.next() {
            // compared to unoptimized1a, the difference is that cp2 is not accessed
            // how does this break optimization?
            cp1
        } else {
            cp1
        };
    }
    sum
}

#[inline(never)]
pub fn weird_optimized1c() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp1) = iter.next() {
        // is this second next that stops this from being optimized?
        sum += if let Some(&cp2) = iter.next() {
            if let Some(&cp3) = iter.next() {
                cp1 + cp2 + cp3
            } else {
                // cp2 not accessed
                cp1
            }
        } else {
            cp1
        };
    }
    sum
}

#[inline(never)]
pub fn unoptimized2() -> u32 {
    let s = [1, 2, 3, 4, 5, 6, 7];

let mut iter = s.iter();
    let mut sum = 0;
    while let Some(&cp) = iter.next() {
        // probably this case explains chars() not being optimized?
        if cp < 5 {
            sum += *iter.next().unwrap_or(&0);
        }
    }
    sum
}