High performance C++ has traditionally been a misnomer, particularly with regards to linear algebra classes and templates. Handcoded C and FORTRAN are the usual approaches taken in the physical sciences, but these lack the portability, maintainability and overall elegance of (object oriented) C++. It was brought to my attention recently that there are really clever ways of using the compiler for performance hacks in C++. Amongst these methods are expression templates by Todd Veldhuizen et al.
The difficulty in vanilla C++ array classes is the overhead associated with operations on arrays, eg., addition and multiplication. Temporary objects are created, requiring precious memory bandwidth and unnecessary loops. Expression templates is an ingenious way around this, by essentially nesting templates, and in conjunction with overloaded operators, creating parse trees at compile time, which effectively inline expressions. The following is pseudocode from Todd Veldhuizen’s notes:
struct plus{}; //overloaded operator
class Array{}; //the class
//X is a node in the parse tree; method
//works b/c class can take itself as template
//parameter
template<typename Left, typename Op, typename Right>
class X{};
//overloaded operator ‘+’ for use in nesting templated
//expressions
template<class T>
X<T, plus, Array> operator+(T,Array)
{
return X<T,plus, Array>()
}
If A,B,C represent class instances, then “D=A+B+C” looks like:
D=A+B+C;
=X<Array,plus,Array>() + C;
X<X<Array,plus,Array>,plus,Array>();
which gives performance comparable to handcoded C. For more information see the article.
