Replacing an math.h exp call with a lookup table

Question

I was wondering if there's any point in modifying code to use a lookup table for math.h exp, or if it was done automatically by clang++ when given the -O3 flag.

If it's not, is there a #pragma that does this?

clarification

I was talking about memoisation of function calls. That is, if the function is passed the same exact arguments (yeah floating point numbers can actually be the same, if they're derived from constants and integers).

Example

Say I was going to run exp(-a*x) where a is not a compile-time constant, but once it's set once, it won't be modified. Similarly x can be one of 10 possible values, all of which are set once, and not modified again.

btw for questions like this, this is an awesome tool: https://godbolt.org/ — 463035818_is_not_an_ai, Apr 10 '18 at 20:17
It's very unlikely that it's there, since both resolution and range would be application dependent. And looking up floats beween boundary values probably isn't that fast. — Jacques de Hooge, Apr 10 '18 at 20:20
If this could be done in general, it's probably how `exp()` would be coded in the library. — Barmar, Apr 10 '18 at 20:37
do you have a specific problem at hand? for integers it might be worth considering a table and even for floats in case you have some predictable calling patterns (like eg `exp(i*x)` where `i` is integer and `x` is a constant float). In its current form the question is too broad imho — 463035818_is_not_an_ai, Apr 10 '18 at 20:38
[Premature optimization is the root of all evil](http://c2.com/cgi/wiki?PrematureOptimization) — Barmar, Apr 10 '18 at 20:38
@user463035818 that's exactly the case. So I should keep an array of call values? — Alex Petrosyan, Apr 10 '18 at 20:40
@Barmar [...Yet we should not pass up our opportunities in that critical 3%](http://wiki.c2.com/?PrematureOptimization) :P — 463035818_is_not_an_ai, Apr 10 '18 at 20:41
I don't understand. If you call the function multiple times with the same exact arguments, why not call it once and remember the result? This would be more efficient, since the function code would not have to be executed many times. (This would be moot if there is a volatile variable inside the function.) — Thomas Matthews, Apr 10 '18 at 20:58

score 2 · Accepted Answer · answered Apr 10 '18 at 21:20

I don't know much about clang specifics, so I cannot tell details about what it does. But I can reason what it might be able to do.

If the argument is a compile time constant, then the optimizer might be able to pre-calculate at compile/link time. But it's by no means required to, and I wouldn't expect all compilers to do that.

If the argument is not compile time constant, and multiple calls within same function use the same argument (and there are no volatile objects involved), then the optimizer might re-use the result if it knows that the functions don't have side-effects. This optimization I would recommend you to do manually, just because it's better to not repeat yourself anyway.

If the argument is not compile time constant, then you could store the result in a table somewhere to be used later, but the memory access to load the value is probably much slower than doing the calculation itself, so this might end up being a pessimisation.

Obviously, whether there is any point in doing any of these optimisation will depend on many aspects such as the CPU architechture, caches etc. and most importantly on whether the operation had any significant effect on the performance in the first place.

I did some testing, with my implementation of a lookup table... When compiled with `-O3`, it automatically `caches' expensive operations. My attempt at memoisation is definitely making the code slower. — Alex Petrosyan, Apr 10 '18 at 22:06
@AlexPetrosyan: You probably spotted an optimization known as Common SubExpression Elimination (CSE). If a compiler spots two calls with the exact same arguments, to a known pure function, it usually strips out the second call. (Pure functions don't have side effects. Obviously you can't strip two calls to `std::printf`) — MSalters, Apr 11 '18 at 00:37

Replacing an math.h exp call with a lookup table

1 Answers1