Testing the speed of a conditional that depends on a parameter, a templated parameter, a class variable, or an element of a class heap

test_conditional_speed.cpp

#include <iostream>
#include <climits>
#include <cmath>
#include <ctime>

#define PI 3.14159265
#define REPETITIONS 2000000000
using namespace std;

double speed_test_nontemplated0() {
  double result = 0.0;
  for (unsigned long int i=0; i<REPETITIONS; ++i) {
    result += i*PI;
  }
  return result;
}

double speed_test_nontemplated1() {
  double result = 0.0;
  for (unsigned long int i=0; i<REPETITIONS; ++i) {
     result += i/PI; 
   }
  return result;
}

double speed_test_parametrized(int param) {
  double result = 0.0;
  for (unsigned long int i=0; i<REPETITIONS; ++i) {
    if (param == 0) {
       result += i*PI;
    } else {
       result += i/PI; 
    }    
  }
  return result;
}


template <int param>
double speed_test_templated() {
  double result = 0.0;
  for (unsigned long int i=0; i<REPETITIONS; ++i) {
    if (param == 0) {
       result += i*PI;
    } else {
       result += i/PI; 
    }    
  }
  return result;
}

class SpeedTest {
public:
  SpeedTest(){};
  ~SpeedTest() {};

  void set_param(int _param) {
    param = _param;
  }

  double speed_test() {
    double result = 0.0;
    for (unsigned long int i=0; i<REPETITIONS; ++i) {
      if (param == 0) {
         result += i*PI;
      } else {
         result += i/PI; 
      }    
    }
    return result;
  }
  
private:
  int param;
};

class SpeedTestHeap {
public:
  SpeedTestHeap(){param = new int[5];};
  ~SpeedTestHeap() {};

  void set_param(int _param) {
    param[0] = _param;
  }

  double speed_test() {
    double result = 0.0;
    for (unsigned long int i=0; i<REPETITIONS; ++i) {
      if (param[0] == 0) {
         result += i*PI;
      } else {
         result += i/PI; 
      }    
    }
    return result;
  }
  
private:
  int *param;
};


int main(int argc, char** argv) {
  clock_t begin = clock();
  std::cout << speed_test_templated<0>() << endl;
  clock_t end = clock();
  double elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Templated 0: " << elapsed_secs << " s" << endl;
  
  begin = clock();
  std::cout << speed_test_templated<1>() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Templated 1: " << elapsed_secs << " s" << endl;

  begin = clock();
  std::cout << speed_test_nontemplated0() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Nontemplated 0: " << elapsed_secs << " s" << endl;

  begin = clock();
  std::cout << speed_test_nontemplated1() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Nontemplated 1: " << elapsed_secs << " s" << endl;

  begin = clock();
  std::cout << speed_test_parametrized(0) << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Parametrized 0: " << elapsed_secs << " s" << endl;

  begin = clock();
  std::cout << speed_test_parametrized(1) << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Parametrized 1: " << elapsed_secs << " s" << endl;

  SpeedTest *st = new SpeedTest();
  st->set_param(0);
  begin = clock();
  std::cout << st->speed_test() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Class variable 0: " << elapsed_secs << " s" << endl;

  st->set_param(1);
  begin = clock();
  std::cout << st->speed_test() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Class variable 1: " << elapsed_secs << " s" << endl;
  delete st;

  SpeedTestHeap *sth = new SpeedTestHeap();
  sth->set_param(0);
  begin = clock();
  std::cout << sth->speed_test() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Class variable from heap 0: " << elapsed_secs << " s" << endl;

  sth->set_param(1);
  begin = clock();
  std::cout << sth->speed_test() << endl;
  end = clock();
  elapsed_secs = double(end - begin) / CLOCKS_PER_SEC;
  std::cout << "Class variable from heap 1: " << elapsed_secs << " s" << endl;
  delete sth;

}

With -O1:

6.28319e+18
Nontemplated 0: 1.50417 s
6.3662e+17
Nontemplated 1: 7.03087 s
6.28319e+18
Templated 0: 1.5052 s
6.3662e+17
Templated 1: 7.02276 s
6.28319e+18
Parametrized 0: 1.5045 s
6.3662e+17
Parametrized 1: 7.02177 s
6.28319e+18
Class variable 0: 1.71983 s
6.3662e+17
Class variable 1: 7.02438 s
6.28319e+18
Class variable from heap 0: 1.77325 s
6.3662e+17
Class variable from heap 1: 7.02127 s