Should exp2 be faster than exp? - math

Question

I'm mostly interested in the "exp" and "exp2" functions in C/C++, but this question is probably more related to the IEEE 754 standard than specific language features.
In a homework problem I did some 10 years ago, which tries to rank different floating point operations by the cycles needed, the C function
double exp2 (double)
appear to be slightly faster than
double exp (double)
Given that "double" uses a binary representation for the mantissa, I feel this result is reasonable.
Today, however, after testing the two again in several different ways, I could not see any measurable differences. So my questions are
Should exp2 be (theoretically) faster than exp? and
Should there be any measurable differences? and
Has the answer changed in the recent years?

Answer 1

There are a number of platforms that don't take much care with their math library on which exp2(x) is simply implemented as exp(x * log(2)) or vice-versa. These implementations do not deliver good accuracy (or especially good performance), but they are fairly common. On platforms that do this, one function is exactly as costly as the other but for the cost of an extra multiply, and whichever gets the extra multiply will be the slower of the two.
On platforms that aggressively tune the math library and try to deliver good accuracy, the two functions are very similar in performance. Generating the exponent of the result is easier with exp2, but getting a high-accuracy significand can require slightly more work; the two factors roughly even out to the point that performance is usually equivalent within a factor of 10-15%. Speaking very broadly, exp2 is usually the faster of the two.

Answer 2

I made some measurements, I hope some of you will find it useful.
Conditions:
Intel(R) Xeon(R) CPU E5-2620 v2 # 2.10GHz (the server had high CPU load during the test)
Compiler version: g++ (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609
Compiler options: -static -std=gnu++0x -ffast-math -Ofast -flto
The code:
#include <iostream>
#include <random>
#include <cmath>
#include <chrono>
using namespace std;
int main()
{
double g = 1/log(2);
mt19937 engine(1000);
uniform_real_distribution<double> u(0, 1);
double sum = 0;
auto begin = std::chrono::high_resolution_clock::now();
for (int i = 0; i < 1e7/4; ++i) // for non-parallel, `for (int i = 0; i < 1e7; ++i)`
{
sum += exp2(u(engine)*g); // for exp versions, sum += exp(u(engine)); for empty versions, sum += u(engine)*g;
sum += exp2(u(engine)*g); // removed for non-parallel
sum += exp2(u(engine)*g); // removed for non-parallel
sum += exp2(u(engine)*g); // removed for non-parallel
}
auto end = std::chrono::high_resolution_clock::now();
cout << chrono::duration_cast<chrono::nanoseconds>(end - begin).count()/1000./1000 << "ms" << "\t"
<< sum << "\t" << g << " exp2 p4" << endl;
}
Execution with:
for i in {1..100}; do ./empty.bin && ./exp2_p4.bin && ./exp_p4.bin && ./exp.bin && ./exp2.bin; done
where the file name tells whether the executable calls exp or exp2, and whether the summation is grouped by 4 (p4) or not.
Results
The table below shows the average runtime (time), the standard deviation in ms, and the fastest case.
| name | time (ms) | std (ms) | smallest (ms) |
|:-------:|:---------:|:--------:|:-------------:|
| empty | 244.7 | 26.2 | 130.9 |
| exp | 591.7 | 95.8 | 422.5 |
| exp2 | 536.5 | 85.4 | 393.7 |
| exp p4 | 612.3 | 89.6 | 433.2 |
| exp2 p4 | 557.2 | 87.6 | 396.8 |
For one operation, one needs to divide it with 1e7. I approximate the cost of the exponential by subtracting the time of the empty version (i.e. do the loop and summation without calculating the exp) from the exponential ones. These values are shown below:
Conclusion
exp2 can be around 11% faster than exp on Intel Xeon with gcc even if -ffast-math is on, in agreement with the accepted answer.
The manual loop unrolling by grouping the summation into a group of four does not help.

Answer 3

Should exp2 be (theoretically) faster than exp?
Yes.
The only way for x86 FPU to perform an exponentiation for non-integer power is using an instruction F2XM1 which calculates 2x-1.
No ex instruction exists on x86.
Any C library code for x86 is forced to calculate both exp and exp2 using 2x.
Should there be any measurable differences?
No.
The difference is only single FPU multiplication, which is very fast for modern processors.
Has the answer changed in the recent years?
Yes.
15-20 years ago price of multiplication was much higher than price of other operations. Nowadays, multiplication is almost as cheap as addition.