C++ for Scientists - Technische Universität Dresden

160 CHAPTER 5. META-PROGRAMMING
assign entry 0
assign entry 1
assign entry 2
assign entry 3
In this implementation, we replaced the loop by a recursion — counting on the compiler to
inline the operations (otherwise it would be even slower as the loop) — and made sure that no
loop index is incremented and tested for termination. This is only beneficial for small loops that
run in L1 cache. Larger loops are dominated by loading the data from memory and the loop
overhead is irrelevant. To the contrary, unrolling operations on very large vectors entirely will
probably decrease the performance because a lot of instructions need to be loaded and decrease
therefore the available bandwidth for the data. As mentioned before, compilers can unroll such
operations by themselves — and hopefully know when it is better not to — and sometimes this
automatic unrolling is even slightly faster then the explicit implementation.
5.4.2 Nested Unrolling
From our experience, compilers usually unroll nested loops. Even a good compiler that can
handle certain nested loops will not be able to optimize every program kernel, in particular those
with heavily templatized programs instantiated with user-defined types. We will demonstrate
here how to unroll nested loops at compile time at the example of matrix vector multiplication.
For this purpose, we introduce a simplistic fixed-size matrix type:
template
class fsize matrix
{
typedef fsize matrix self;
public:
typedef T value type;
BOOST STATIC ASSERT((Rows ∗ Cols > 0));
const static int my rows= Rows, my cols= Cols;
fsize matrix()
{
for (int i= 0; i < my rows; ++i)
for (int j= 0; j < my cols; ++j)
data[i][j]= T(0);
}
fsize matrix( const self& that ) { ... }
// cannot check column index
const T∗ operator[](int r) const { return data[r]; }
T∗ operator[](int r) { return data[r]; }
mat vec et operator∗(const fsize vector& v) const
{
return mat vec et (∗this, v);
}
private: