Quuxplusone
commented
8 years ago Hi Steven,
Thanks for raising this. Actually, just emitting the rsqrt instructions isn't
the hard part of this. The hard part is deciding when they are profitable.
For a single rsqrtf outside of a loop (such as your rsqrtf() function) it is
almost always more efficient to use the sqrt instruction. Note that our
lowering isn't very good at the moment: we're doing:
1.0 / sqrt(x)
What we should be doing is this:
(1.0 / x) * sqrt(x)
(because 1/sqrt(x) == sqrt(x) / x). This would make the division and square
root doable in parallel.
Now, rsqrt[es]'s advantage is that they don't block the pipeline (because they
are not iterative instructions), so throughput is increased. However, latency
is also increased as more instructions have to be executed. So swapping a sqrt
for a rsqrt[es] sequence will often make code *slower* as in most cases sqrts,
rsqrts and divisions are on the critical path.
The main case where rsqrt will give a heavy speedup is in a loop where there
are no dependencies on the result of the sqrt. For example a trivial loop where
we calculate the sqrt of all members of an array independently:
for (i : ...) {
b[i] = rsqrt(a[i]); // Fast with rsqrte
}
Because it doesn't matter how long the rsqrt takes - there's nothing dependent
on its result. Throughput is key in this loop.
The only example I've seen in practice of this kind of loop is vector
normalization:
for (v : all_vectors) {
vector_magnitude[v] = sqrt(a[v].x * a[v].x + a[v].y * a[v].y + a[v].z * a[v].z);
}
I haven't seen any other examples in the wild where rsqrt would unequivocally
improve performance.
I'm interested: other than your trivial testcase, have you seen code where
rsqrt will improve performance? Would you mind sharing that?
The other issue is that the tradeoff between sqrt and rsqrt is heavily
microarchitectural, which means a lot of benchmarking.
If we wanted to do this, we'd probably be best doing it as a MachineCombiner
peephole, as this is a critical path / resource height issue.
Cheers,
James
arm-nbody.txt(6064 bytes, text/plain)aarch64-nbody.txt(5885 bytes, text/plain)