C++ for Scientists - Technische Universität Dresden

104 CHAPTER 4. GENERIC PROGRAMMING
{
}
...
double inline power(double x, double y)
{
return std::pow(x, y);
}
Speaking of platform-specific assembler hacks, maybe we are eager to contribute a code that
explores SSE units by performing two computations in parallel:
template
Base inline power(const Base& x, const Exponent) { ... }
#ifdef SSE FOR TRYPTICHON WQ OMICRON LXXXVI SUPPORTED
std::pair inline power(const std::pair& x, double y)
{
asm {
# Yo, I’m the greatestest geek under the sun!
}
return whatever;
}
#endif
#ifdef ... more hacks ...
What is to say about this snippet? If you do not like to write such specializations, we will
not blame you. If you do, always put such hacks in conditional compilation. You have
to make sure as well that your build system only enables the macro when it is definitely a
platform that supports the hack. For the case that it does not, we must guarentee that the
generic implementation or another overload can deal with pairs of double. Last but not least,
you have to rewrite your applications for using this function. Convincing others to use such
special implementation could be even more work than getting the assembler hack producing
plausible numbers. More importantly, such special signatures undermines the ideal of a clear
and intuitive programming. However, if power functions are computed on entire vectors and
matrices, one could perform the calculation pairwise internally without affecting the interface
or the user application.
You might also think that SSEs were yesterday and today we have GPUs and GPGPUs but
programming generically still takes a lot of tricks (at least in the beginning of 2010). But this is
another story and we digress. Resuming: programming for highest performance can be tricky
but at least there often ways to explore unportable feature (where available) without sacrificing
portability at the application level. 10
In the previous examples, we specialized all arguments of the function. It is also possible to
specialize some argument(s) and leave the remaining argument(s) as template(s):
template
Base inline power(const Base& x, const Exponent& y);
template
10 TODO: Is this comprehensible?