compile time vs runtime recursion - c++

Question

Is template recursion more efficient than non-template recursion?
I.e. which one of the two is better:
typedef std::vector<int> Ivec;
template <int N>
void test1(Ivec& v){
assert(v.size() >= N);
for (int i=0;i<N;i++){v[i]++;}
test1<N-1>(v);
}
template <>
void test1<0>(Ivec& v){}
void test2(Ivec& v,int N){
assert(v.size() >= N);
for (int i=0;i<N;i++){v[i]++;}
if (N == 1) {return;}
test2(v,N-1);
}

Answer 1

I will be surprised if the template version is ever slower. It should be faster most of the time, if not every time. After all, the template version computes the values at compile time.
Here's program that times the two approaches.
#include <iostream>
#include <cstddef>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <cassert>
typedef std::vector<int> Ivec;
template <int N>
void test1(Ivec& v){
assert(v.size() >= N);
for (int i=0;i<N;i++){v[i]++;}
test1<N-1>(v);
}
template <>
void test1<0>(Ivec& v){}
void test2(Ivec& v,int N){
assert(v.size() >= N);
for (int i=0;i<N;i++){v[i]++;}
if (N == 1) {return;}
test2(v,N-1);
}
void timeFunction(void (*fun)())
{
clock_t start = std::clock();
fun();
clock_t end = std::clock();
double secs = 1.0*(end-start)/CLOCKS_PER_SEC;
std::cout << "Time taken: " << secs << std::endl;
}
void time_test1()
{
Ivec a;
const int N = 500;
for (int i = 0; i < N; ++i )
{
a.push_back(std::rand());
}
for ( int i = 0; i < N*20; ++i )
{
test1<N>(a);
}
}
void time_test2()
{
Ivec a;
const int N = 500;
for (int i = 0; i < N; ++i )
{
a.push_back(std::rand());
}
for ( int i = 0; i < N*20; ++i )
{
test2(a, N);
}
}
int main()
{
std::srand(time(NULL));
timeFunction(time_test1);
timeFunction(time_test2);
return 0;
}
Program built on a Linux machine with g++ version 4.8.4 with the command:
g++ -Wall -std=c++11 socc.cc -o socc
Output:
Time taken: 3.96467
Time taken: 4.32788
The output validates my hunch. As usual, your mileage may vary.

Answer 2

Template recursion should be faster, but you need to know N at compile time.
Which is better?
Usually function recursion since it is more flexible and generates the machine code only once.
But if you know N at compile time ( as a define for example ) and not as something you read from a file, and the performance need is greater than the size of the generated code, than you could yake advantage of the optimisations that the compiler can do.