C++ for Scientists - Technische Universität Dresden

168 CHAPTER 5. META-PROGRAMMING
The answer is yes. All of them. The main reason (but not the only one) is that different
processors have different numbers of registers. How many registers are needed in one iteration
depends on the expression and on the types (a complex value needs more registers than a float).
In the following section we will address both issues: how to encapsulate the transformation
so that it does not show up in the application and how we can change the block size without
rewritten the loop.
5.4.4 Unrolling Vector Expressions
For easier understanding, we discuss the abstraction in meta-tuning step by step. We start with
the previous loop and implement a function for it. Say the function’s name is my axpy and it
has a template argument for the block size so that we can write for instance
for (unsigned j= 0; j < rep; j++)
my axpy(u, v, w);
This function shall contain a main loop in unrolled manner with customizable size and a clean-up
loop at the end:
template
void my axpy(U& u, const V& v, const W& w)
{
assert(u.size() == v.size() && v.size() == w.size());
unsigned s= u.size(), sb= s / BSize ∗ BSize;
}
for (unsigned i= 0; i < sb; i+= BSize)
my axpy ftor()(u, v, w, i);
for (unsigned i= sb; i < s; i++)
u[i]= 3.0f ∗ v[i] + w[i];
As mentioned before, deduced template types, as the vector types in our case, must be defined
at the end and the explicitly given arguments, in our case the block size, must be at the
beginning of the template arguments. The implementation of the block statement in the first
loop can be implemented similarly to the functor in Section 5.4.1. We deviate a bit from this
implementation by using two template arguments where the former is increased until it is equal
to the second. It appeared that this approach yielded faster binaries on gcc than using only
one argument and counting it down to zero. 22 In addition, the two-argument version is more
consistent with the multi-dimensional implementation in Section ??. As for fixed-size unrolling
we need a recursive template definition. Within the operators, a single statement is performed
and the following statements are called:
template
struct my axpy ftor
{
template
void operator()(U& u, const V& v, const W& w, unsigned i)
{
u[i+Offset]= 3.0f ∗ v[i+Offset] + w[i+Offset];
22 TODO: exercise for it