Question

I have a need to iterate through an amortization formula, which looks like this:

R = ( L * (r / m) ) / ( 1 - pow( (1 + (r / m)), (-1 * m * t ) );

I’m using a for loop for iteration, and incrementing the L (loan value) by 1 each time. The loop works just fine, but it did make me wonder about something else, which is the value (or lack thereof) in performing basic operations before a loop executes and then referencing those values through a variable. For example, I could further modify this function to look like

// outside for loop
amortization = (r/m)/(1 - pow( (1+(r/m)), (-1*m*t) ) )

// inside for loop
R = L * amortization

This way, instead of having to perform lots of math operations on every iteration of the loop, I can just reference the variable amount and perform a single operation.

What I’m wondering is how relevant is this? Is there any actual value in extracting these operations, or is the time saved so small that we’re talking about a savings of milliseconds from a for loop that iterates approx. 200,000 times. Follow up question: would extracting operations like this be worth it if I were doing more expensive operations like sqrt?

(note: in case it matters, I’m asking about this specifically with c++ in mind)

Answer 1

Compilers would exercise an optimization technique here which is called loop invariant code motion. It does pretty much what you did manually, i.e. extracting a constant part of expression evaluated repeteadly in loop into a precomputed value stored in variable (or register). Hence it is not likely that you gain any performance by doing this yourself.

Of course if it’s critical speed-wise, you should profile and/or review the assembly code produced by compiler in both cases.