/*
	Trivial test of call times

	This program times calls of functions doing hardly anything for

		virtual function (C++)

		global function called indirectly (C)

		nonvirtual member function (C++)

		global function (C)

		inline member function (C++)

		macro (C)

	The calls marked (C++) tests key C++ facilities.
	Calls marked could be either C or C++ and should have exactly
	the same performance in either language.

	The point is that the performance of the C++ facilities are
	or should be roughly equivalent to equivalent C mechanisms:

		virtual call == indirect call

		nonvirtual call == global function call

		inline call == macro

	If that is not the case, check that the timings were done correctly
	(i.e. the timer worked properly, the machine wasn't doing anything
	else during the test, etc.). If the significant different differences
	persis complain to your compiler supplier.

	The program can be given the number of iterations as an argument;
	the default is 1,000,000.


	Sample run (on an Ultraspac10 using gcc version egcs-2.91.60 19981201 (egcs-1.1.1 release):

[day] c++ -O2 calls.c
[day]   a.out 5000000
px->f(1) :      0.55 seconds
p[1](ps,1) :    0.41 seconds
x.f(1) :        0.19 seconds
p[1](&s,1) :    0.48 seconds
px->g(1) :      0.2 seconds
g(ps,1) :       0.2 seconds
x.g(1) :        0.19 seconds
g(&s,1) :       0.19 seconds
X::h(1) :       0.2 seconds
  h(1) :        0.21 seconds
px->k(1) :      0.18 seconds
K(ps,1) :       0.19 seconds
x.k(1) :        0.18 seconds
K(&s,1) :       0.19 seconds
[day] 


	- Bjarne Stroustrup - http://www.research.att.com/~bs
*/

		

	class X {
		int x;
		static int st;
	public:
		virtual void f(int a);
		void g(int a);
		static void h(int a);
		void k(int i) { x+=i; }
	};

	struct S {
		int x;
	};

	int glob = 0;

	void f(S* p, int a);
	void g(S* p, int a);
	void h(int a);
	typedef void (*PF)(S* p, int a);
	PF p[10] = { g , f };
//	inline void k(S* p, int i) { p->x+=i; }
	#define K(p,i)  ((p)->x+=(i))

struct T {
	const char* s;
	double t;

	T(const char* ss, double tt) : s(ss), t(tt) { }
	T() : s(0), t(0) { }
};


#include<stdlib.h>
#include<iostream>
#include<time.h>
using namespace std;

int main(int argc, char* argv[])
{

	int n = (1<argc) ? atoi(argv[1]) : 1000000;	// number of iterations

	X* px = new X;
	X x;
	S* ps = new S;
	S s;

	const int max_test = 14;
	T v[max_test];

	clock_t t = clock();
	if (t == clock_t(-1)) {
		cerr << "sorry, no clock\en";
		exit(1);
	}

	for (int i = 0; i<n; i++) px->f(1);
	v[0] = T("px->f(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) p[1](ps,1);
	v[1] = T("p[1](ps,1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) x.f(1);
	v[2] = T("x.f(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) p[1](&s,1);
	v[3] = T("p[1](&s,1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) px->g(1);
	v[4] = T("px->g(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) g(ps,1);
	v[5] = T("g(ps,1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) x.g(1);
	v[6] = T("x.g(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) g(&s,1);
	v[7] = T("g(&s,1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) X::h(1);
	v[8] = T("X::h(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) h(1);
	v[9] = T("  h(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) px->k(1);
	v[10] = T("px->k(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) K(ps,1);
	v[11] = T("K(ps,1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) x.k(1);
	v[12] = T("x.k(1)",clock()-t);

	t = clock();
	for (int i = 0; i<n; i++) K(&s,1);
	v[13] = T("K(&s,1)",clock()-t);

	if (clock() == clock_t(-1)) {
		cerr << "sorry, clock overflow\en";
		exit(2);
	}

	for (int i = 0; i<max_test; i++) {
		cout << v[i].s << " :\t" << v[i].t/CLOCKS_PER_SEC << " seconds\n";
	}
}

int X::st = 0;
void X::f(int a) { x+=a; }
void X::g(int a) { x+=a; }
void X::h(int a) { st+=a; }

void f(S* p, int a) { p->x += a; }
void g(S* p, int a) { p->x += a; }
void h(int a) { glob += a; }