関数呼び出しのコスト

ちょっと気になったので計測

//functions.h

#pragma once

void f(__int64& i);

struct normal_function
{
	void f(__int64& i);
};

struct virtual_function_base
{
	virtual void f(__int64& i)=0;
};

struct virtual_function
	:public virtual_function_base
{
	virtual void f(__int64& i);
};

// functions.cpp
#include "functions.h"

void f(__int64& i)
{
	++i;
}

void normal_function::f(__int64& i)
{
	++i;
}

void virtual_function::f(__int64& i)
{
	++i;
}

//main.cpp
#include <cstdio>
#include <conio.h>

#include <tchar.h>
#include <windows.h>
#include <mmsystem.h>
#pragma comment(lib,"winmm.lib")

#include <boost/function.hpp>
#include <boost/bind.hpp>

#include "functions.h"

void time_check()
{
	unsigned long start_time=timeGetTime();
	__int64 target=0;
	for(__int64 i=0;i<100000000;++i)
		f(target);
	std::printf("time=%d target=%d\n\n",timeGetTime()-start_time,target);
}

template <typename T>
void time_check_member(T& t)
{
	unsigned long start_time=timeGetTime();
	__int64 target=0;
	for(__int64 i=0;i<100000000;++i)
		t.f(target);
	std::printf("time=%d target=%d\n\n",timeGetTime()-start_time,target);
}

template <typename T>
void time_check_member_pointer(T* t)
{
	unsigned long start_time=timeGetTime();
	__int64 target=0;
	for(__int64 i=0;i<100000000;++i)
		t->f(target);
	std::printf("time=%d target=%d\n\n",timeGetTime()-start_time,target);
}

template <typename T>
void time_check_functor(const T& t)
{
	unsigned long start_time=timeGetTime();
	__int64 target=0;
	for(__int64 i=0;i<100000000;++i)
		t(target);
	std::printf("time=%d target=%d\n\n",timeGetTime()-start_time,target);
}

int _tmain(int argc, _TCHAR* argv[])
{
	timeBeginPeriod(1);
	Sleep(3000);

	printf("global function\n");
	time_check();

	normal_function normaltype;
	printf("member function\n");
	time_check_member(normaltype);
	
	virtual_function virtualtype;
	printf("virtual member function\n");
	time_check_member(virtualtype);

	printf("virtual_base member function\n");
	time_check_member_pointer((virtual_function_base*)&virtualtype);

	printf("global member functor\n");
	boost::function<void (__int64&)> functor_global=boost::bind(&f,_1);
	time_check_functor(functor_global);

	printf("member functor\n");
	boost::function<void (__int64&)> functor_normal=boost::bind(&normal_function::f
		,normaltype,_1);
	time_check_functor(functor_normal);

	printf("virtual member functor\n");
	boost::function<void (__int64&)> functor_virtual=boost::bind(&virtual_function::f
		,virtualtype,_1);
	time_check_functor(functor_normal);

	printf("virtual_base member functor\n");
	boost::function<void (__int64&)> functor_virtual_base=boost::bind(&virtual_function_base::f
		,(virtual_function_base*)&virtualtype,_1);
	time_check_functor(functor_virtual_base);

	timeEndPeriod(1);

	_getch();
	return 0;
}

global function
time=215 target=100000000

member function
time=216 target=100000000

virtual member function
time=475 target=100000000

virtual_base member function
time=479 target=100000000

global member functor
time=562 target=100000000

member functor
time=647 target=100000000

virtual member functor
time=648 target=100000000

virtual_base member functor
time=689 target=100000000

WindowsXP SP3
QuadCore Q8200
DDR3 4GB

これを気にするほどクリティカルな処理を書いたことはないでござる