What is do_cos_slow.isra? - glibc

Question

I wrote a simple code to test for prof.
double bar_compute (double d) {
double t = std::abs(d);
t += std::sqrt(d);
t += std::cos(d);
return t;
}
// Do some computation n times
double foo_compute(unsigned n) {
std::random_device rd;
std::mt19937 mt(rd());
std::uniform_real_distribution<double> dist(0.0, 1.0);
double total = 0;
for (int i=0; i<n; i++) {
double d = dist(mt);
total += bar_compute(d);
}
return total;
}
When I run prof and view the output it is
56.14% runcode libm-2.23.so [.] __cos_avx
27.34% runcode runcode [.] _Z11foo_computej
13.92% runcode runcode [.] _Z11bar_computed
0.86% runcode libm-2.23.so [.] do_cos_slow.isra.1
0.44% runcode runcode [.] cos#plt
0.41% runcode libm-2.23.so [.] sloww1
0.35% runcode libm-2.23.so [.] __dubcos
0.17% runcode ld-2.23.so [.] _dl_lookup_symbol_x
What is do_cos_slow.isra and sloww1 mean?
Is there a faster version of cos that I can use? Otherwise why would it be called slow?

Answer 1

do_cos_slow comes from its declaration in glibc/sysdeps/ieee754/dbl-64/s_sin.c. It is called do_cos_slow because it is more precise than the function it is based on do_cos as per the comment above its declaration on Line 164.
The .isra is because the function is version which has been optimised by IPA SRA as per the following Stack Overflow Answer, What does the GCC function suffix “isra” mean?
sloww1 is a function that computes sin(x+dx) as per the comment above it.
Regarding a faster version of cos, I am not sure if there is a faster version, but if you update your glibc or libc implementation that provides libm, to at least glibc 2.28, then you will get the results of Wilco Dijkstra's removal of these slowpath functions and refactor of dosincos which gives a speed boost.
From the commit message
Refactor the sincos implementation - rather than rely on odd partial inlining
of preprocessed portions from sin and cos, explicitly write out the cases.
This makes sincos much easier to maintain and provides an additional 16-20%
speedup between 0 and 2^27. The overall speedup of sincos is 48% over this range.
Between 0 and PI it is 66% faster.
Other alternatives you can try are other libc or libm implementations, or other cos implementations including avx_mathfun or avx_mathfun with some fixes for newer GCC or supersimd.