C++ for Scientists - Technische Universität Dresden

5.4. META-TUNING: WRITE YOUR OWN COMPILER OPTIMIZATION 171
}
check size(size(that));
unsigned s= my size, sb= s / BSize ∗ BSize;
for (unsigned i= 0; i < sb; i+= BSize)
assign()(∗this, that, i);
for (unsigned i= sb; i < s; i++)
data[i]= that[i];
return ∗this;
The drawback is that we cannot use the symbol ‘=’ naturally as infix operator but must write:
u.operator=(v + v + w);
This has in fact a certain geeky charm and one could also argue that people did (and still do)
more painful things for performance. Nonetheless, it does not meet our ideals of intuitiveness
and readability.
Alternative notations are:
or
unroll(u= v + v + w);
unroll(u)= v + v + w;
Both version are implementable and provide comparable intuitiveness. The former expresses
more correctly what we are doing while the latter is easier to implement and the structure of the
computed expression remains better visibility. Therefore we show the realization of the second
form.
The function unroll is simple to implement: it just returns an object with a reference to the
vector and a type information for the unroll size:
template
unroll vector inline unroll(Vector& v)
{
return unroll vector(v);
}
The class unroll vector is not complicated either. It only needs to take a reference to the target
vector and an assignment operator:
template
class unroll vector
{
public:
unroll vector(V& ref) : ref(ref) {}
template
V& operator=(const Src& that)
{
assert(size(ref) == size(that));
unsigned s= size(ref), sb= s / BSize ∗ BSize;