Let bindings result in different memory and cpu usage. Why?

[fallen-icarus]

I am trying to add a Rational type for my project so that I can represent decimals on-chain. Here is the type:

pub type Rational {
  numerator: Int,
  denominator: Int,
}

I then implemented an add_ratios function that also reduces the fraction after the calculation:

// This is used to find the greatest common divisor.
fn euclid(x: Int, y: Int) -> Int {
  if y == 0 {
    x
  } else {
    let new_y =
      x % y

    euclid(y, new_y)
  }
}

pub fn add_ratios(x: Rational, y: Rational) -> Rational {
  let num_x =
    x.numerator
  let num_y =
    y.numerator
  let den_x =
    x.denominator
  let den_y =
    y.denominator
  let new_num =
    num_x * den_y + num_y * den_x
  let new_den =
    den_x * den_y
  let gcd =
    euclid(new_num, new_den)

  Rational { numerator: new_num / gcd, denominator: new_den / gcd }
}

Personally, I find all the lets noisy so I wrote another version like this:

pub fn add_ratios2(x: Rational, y: Rational) -> Rational {
  let new_num =
    x.numerator * y.denominator + y.numerator * x.denominator
  let new_den =
    x.denominator * y.denominator
  let gcd =
    euclid(new_num, new_den)

  Rational { numerator: new_num / gcd, denominator: new_den / gcd }
}

Using these tests, I bench marked both versions:

test add_ratios_test() {
  let rat_1 =
    Rational { numerator: 2, denominator: 5 }
  let rat_2 =
    Rational { numerator: 1, denominator: 8 }
  add_ratios(rat_1, rat_2) == Rational { numerator: 21, denominator: 40 }
}

test add_ratios_test2() {
  let rat_1 =
    Rational { numerator: 2, denominator: 5 }
  let rat_2 =
    Rational { numerator: 1, denominator: 8 }
  add_ratios2(rat_1, rat_2) == Rational { numerator: 21, denominator: 40 }
}

This is what I got:
┍━ cardano_swaps/rational ━━━━━━━━━━━━━━━━━━━━━━━━
│ PASS [mem: 46180, cpu: 20327301] add_ratios_test
│ PASS [mem: 56912, cpu: 24783041] add_ratios_test2
┕━━━━━━━━━━━━━━━━━━━━ 2 tests | 2 passed | 0 failed

add_ratios2 is using about 25% more memory and cpu. Why?

[fallen-icarus]

I think I figured it out. Since add_ratios2 called x.denominator and y.denominator twice, I did another test with this version:

pub fn add_ratios3(x: Rational, y: Rational) -> Rational {
  let y_den =
    y.denominator
  let x_den =
    x.denominator
  let new_num =
    x.numerator * y_den + y.numerator * x_den
  let new_den =
    x_den * y_den
  let gcd =
    euclid(new_num, new_den)

  Rational { numerator: new_num / gcd, denominator: new_den / gcd }
}

In this version, I stored the result of x.denominator and y.denominator in a variable and then used that variable twice instead of calling those functions twice. This version resulted in similar performance to the first version with all the lets.

In hindsight, this seems pretty basic... I guess I assumed those functions would only be evaluated once even though I called them twice.

[rvcas]

A Let binding is an application of some expression to a lambda to introduce something into scope. This costs something, more let bindings will always be more cost. Also it's better to favor destructuring all fields earlier at a higher scope than using field access. Although field access is convenient it is generally less performant than destructuring everything up front.