loop unrolling and metaprogramming(TMP)?

Question

While reading [Compile-time code optimization] from wikipedia' article-Template metaprogramming:

template <int length>
Vector<length>& Vector<length>::operator+=(const Vector<length>& rhs) 
{
    for (int i = 0; i < length; ++i)
        value[i] += rhs.value[i];
    return *this;
}

When the compiler instantiates the function template defined above, the following code may be produced:[citation needed]

template <>
Vector<2>& Vector<2>::operator+=(const Vector<2>& rhs) 
{
    value[0] += rhs.value[0];
    value[1] += rhs.value[1];
    return *this;
}

The compiler's optimizer should be able to unroll the for loop because the template parameter length is a constant at compile time.

However, take caution as this may cause code bloat as separate unrolled code will be generated for each 'N'(vector size) you instantiate with.

However, I learned while writing TMP codes, loop should be avoided because it is run-time and recursion with templates is a substition.

I have search edit on google and find this question which unrool manually. Answers also encourage to use recursion.

So, should I rely on Compile-time code optimization which is able to unroll the for loop using compile-time determinate length(end of the loop) at compile time or use recursion all the time?

I think the article from wikepedia encourage us to rely on un-roll. Maybe I misunderstand it?

have you considered using [`std::integer_sequence`](http://en.cppreference.com/w/cpp/utility/integer_sequence) which doesn't necessarily demand to use recursion? — W.F., Nov 23 '17 at 09:40
What is your concern with non-unrolled loops? Have you benchmarked them? There aren't that many loops that _needs_ to be unrolled — Passer By, Nov 23 '17 at 09:42

score 4 · Accepted Answer · answered Nov 23 '17 at 09:41

4

Loop unrolling has nothing to do with template (at least in general). Compilers can unroll loops when size is known (they may also be able to unroll not statically bounded loops but this is much more difficult).

If you use template recursion that only means that you can control the way loop unrolling occurs.

Whatever, don't try make premature optimization... It is unlikely that rolled loops is your runtime cost problem. Let the compiler unroll is at least free of charge, while doing it by yourself is a little bit painful and error-prone while not being sure that the result will worth the effort.

answered Nov 23 '17 at 09:41

Jean-Baptiste Yunès

34,548
4
48
69

1

Even if you do manually unroll your loops, there's nothing stopping a compiler from looking at it, deciding the cache pressure is more important, and *re-rolling* your loop back in – Caleth Nov 23 '17 at 09:55
@Caleth not aware of loop rerolling! Thanks for the info, can learn a thing everyday. – Jean-Baptiste Yunès Nov 23 '17 at 12:53

score 0 · Answer 2 · answered Nov 23 '17 at 09:36

0

From my experience loop unrolling works up to a certain length. I guess that if code grows too large this has a negative impact on cache and resulting in a less than optimal performance

answered Nov 23 '17 at 09:36

marom

5,064
10
14

loop unrolling and metaprogramming(TMP)?

2 Answers2