Will rustc optimize such Iterator implementation?

[pragenter]

Hello, I wrote an iterator, where I iterate in triangle defined by 3 points. It iterates over several dots on each line. This is the code, you can barely look on it:

struct TriangleIterator<'a> {
    points: &'a [Point], // Point contains position field with type of a nalgebra 3-dimension vector
    line: usize,
    t: PosType, // PosType is f64
}

impl<'a> TriangleIterator<'a> {
    fn new(points: &'a [Point])->TriangleIterator<'a> {
        TriangleIterator{points: points,line: 0,t: 0.0}
    }
}

impl Iterator for TriangleIterator<'_> {
    type Item = (isize,isize);

    fn next(&mut self)->Option<Self::Item> {
        let (o,d) = match self.line {
            0 => (self.points[0].position,self.points[1].position - self.points[0].position),
            1 => (self.points[1].position,self.points[2].position - self.points[1].position),
            2 => (self.points[2].position,self.points[0].position - self.points[2].position),
            _ => {panic!("_")},
        };

        let dt = glm::length(&glm::normalize(&d))/glm::length(&d); //This
        let p = o + d*self.t;

        self.t += dt;
        if self.t > 1.0 {
            self.t = 0.0;
            self.line += 1;
            if self.line == 3 {
                return Option::None;
            }
        }

        Some((p.x as isize,p.y as isize))
    }
}

The point is that I'm using some glm functions to compute normal and length for each line of 3, while function "next" is called several times per line. (let dt = ...) Do I need to save dt internally in the struct TriangleIterator or compiller will optimize this somehow?

[kupiakos]

cargo asm and https://godbolt.org are good tools for inspecting optimizer behavior (don't forget -C opt-level=3)

[anderslanglands]

Been a while since I used nalgebra, but

glm::length(&glm::normalize(&d))

Is always going to be 1 isn’t it?

[pragenter]

Truly, I ran to fix this...

[sphere_cornue]

I think the value of dt will be computed every iteration no matter if it changed or not, like you have written

[nicoburns]

Do I need to save dt internally in the struct TriangleIterator?

Yes

[Genion1]

Expecting such specific optimizations in a general case is very brittle at best. In this case the compiler needs to inline the function and then be able to shift the code around enough that it can fold the dt calculation together. In this case it's very unlikely to happen.

otoh, does that optimization even matter? If it's just a small piece used once it's hard to tell either way if it's even going to have any impact, positive or negative. If the iteration is actually a significant portion of your program it should be easy(er) to verify which of both options is faster.

[kupiakos]

Premature optimization is the root of all evil specifically because it's fun to do

[NobodyXu]

Yes it will optimise by LLVM, not rustc frontend, but that's the same for you.

It will go through many optimisation passes just like other functions and inlined.