Google Groups no longer supports new Usenet posts or subscriptions. Historical content remains viewable.
Dismiss
Groups keyboard shortcuts have been updated
Dismiss
See shortcuts

Performance : calling templated and non-templated functions

0 views
Skip to first unread message

Alex Vinokur

unread,
Jul 27, 1999, 3:00:00 AM7/27/99
to

Hi,

Performance of calling
templated and non-templated functions
was measured.

1. Two data types were used : int and string
2. 4 optimization options of egcs compiler were used.


Average time-cost of execution was obtained.
The results of the experiment are shown below.

Thanks,
Alex


//########################################################
//------------------- C++ code : BEGIN -------------------

//=================================================
#include <string>
#include <sys/time.h>

//=======================
void print_status (
int testNo_i,
hrtime_t& t_start_i,
hrtime_t& t_end_i,
int iters_i,
const string& name_i
)
{
cout << "Test#"
<< testNo_i
<< " ["
<< name_i.c_str ()
<< "]"
<< "\t: "
<< "\tAverage time = "
<< ((t_end_i - t_start_i)/iters_i)
<< " nsec"
<< endl;
}
//=======================
#define PRINT(testNo_i, object_i) \
print_status ( \
testNo_i, \
time_start, \
time_end, \
TOTAL_Iterations, \
#object_i)

//####################################################
template <typename T>
void templated_foo (const T& t_i)
{
T t;
}

//----------------
void ordinary_foo (int t_i)
{
int t;
}

//----------------
void ordinary_foo (const string& t_i)
{
string t;
}


//####################################################
int main()
{
//=======================
const unsigned int TOTAL_Tests = 5;
const unsigned int TOTAL_Iterations = 10000;

//=======================
hrtime_t time_start;
hrtime_t time_end;
//=======================

unsigned int curTestNo;
unsigned int curIndex;
unsigned int curIteration;

for (curTestNo = 1;
curTestNo <= TOTAL_Tests;
curTestNo++)
{
//=======================
cout << endl
<< "\t"
<< "##### Test#"
<< curTestNo
<< " (functions)"
<< " #####"
<< endl;

//############ int #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
templated_foo (123);
}
time_end = gethrtime();
PRINT (curTestNo, templated_foo_int_1);
//===============================

//############ int #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
templated_foo<int> (123);
}
time_end = gethrtime();
PRINT (curTestNo, templated_foo_int_2);
//===============================

//############ int #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
ordinary_foo (123);
}
time_end = gethrtime();
PRINT (curTestNo, ordinary_foo_int);
//===============================

string s123 ("123");
//############ string #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
templated_foo (s123);
}
time_end = gethrtime();
PRINT (curTestNo, templated_foo_string_1);
//===============================

//############ string #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
templated_foo<string> (s123);
}
time_end = gethrtime();
PRINT (curTestNo, templated_foo_string_2);
//===============================

//############ string #################
//=======================================
time_start = gethrtime();
for (curIteration = 1;
curIteration <= TOTAL_Iterations;
curIteration++)
{
ordinary_foo (s123);
}
time_end = gethrtime();
PRINT (curTestNo, ordinary_foo_string);
//===============================

} // for (curTestNo = 1; curTestNo <= TOTAL_Tests; curTestNo++)
//======================
return 0;
}

//------------------- C++ code : END ---------------------

//#########################################################
//------------------- Running Results : BEGIN -------------

//--------------------------
% g++ perf.C
% a.out

##### Test#1 (functions) #####
Test#1 [templated_foo_int_1] : Average time = 249 nsec
Test#1 [templated_foo_int_2] : Average time = 211 nsec
Test#1 [ordinary_foo_int] : Average time = 163 nsec
Test#1 [templated_foo_string_1] : Average time = 1435 nsec
Test#1 [templated_foo_string_2] : Average time = 5222 nsec
Test#1 [ordinary_foo_string] : Average time = 692 nsec

##### Test#2 (functions) #####
Test#2 [templated_foo_int_1] : Average time = 212 nsec
Test#2 [templated_foo_int_2] : Average time = 191 nsec
Test#2 [ordinary_foo_int] : Average time = 163 nsec
Test#2 [templated_foo_string_1] : Average time = 1294 nsec
Test#2 [templated_foo_string_2] : Average time = 1216 nsec
Test#2 [ordinary_foo_string] : Average time = 593 nsec

##### Test#3 (functions) #####
Test#3 [templated_foo_int_1] : Average time = 191 nsec
Test#3 [templated_foo_int_2] : Average time = 221 nsec
Test#3 [ordinary_foo_int] : Average time = 163 nsec
Test#3 [templated_foo_string_1] : Average time = 1215 nsec
Test#3 [templated_foo_string_2] : Average time = 1238 nsec
Test#3 [ordinary_foo_string] : Average time = 555 nsec

##### Test#4 (functions) #####
Test#4 [templated_foo_int_1] : Average time = 231 nsec
Test#4 [templated_foo_int_2] : Average time = 191 nsec
Test#4 [ordinary_foo_int] : Average time = 163 nsec
Test#4 [templated_foo_string_1] : Average time = 3664 nsec
Test#4 [templated_foo_string_2] : Average time = 2135 nsec
Test#4 [ordinary_foo_string] : Average time = 562 nsec

##### Test#5 (functions) #####
Test#5 [templated_foo_int_1] : Average time = 191 nsec
Test#5 [templated_foo_int_2] : Average time = 191 nsec
Test#5 [ordinary_foo_int] : Average time = 170 nsec
Test#5 [templated_foo_string_1] : Average time = 1222 nsec
Test#5 [templated_foo_string_2] : Average time = 1204 nsec
Test#5 [ordinary_foo_string] : Average time = 629 nsec
//--------------------------


//--------------------------
% g++ -O1 perf.C
% a.out

##### Test#1 (functions) #####
Test#1 [templated_foo_int_1] : Average time = 92 nsec
Test#1 [templated_foo_int_2] : Average time = 92 nsec
Test#1 [ordinary_foo_int] : Average time = 72 nsec
Test#1 [templated_foo_string_1] : Average time = 457 nsec
Test#1 [templated_foo_string_2] : Average time = 255 nsec
Test#1 [ordinary_foo_string] : Average time = 254 nsec

##### Test#2 (functions) #####
Test#2 [templated_foo_int_1] : Average time = 185 nsec
Test#2 [templated_foo_int_2] : Average time = 92 nsec
Test#2 [ordinary_foo_int] : Average time = 138 nsec
Test#2 [templated_foo_string_1] : Average time = 255 nsec
Test#2 [templated_foo_string_2] : Average time = 270 nsec
Test#2 [ordinary_foo_string] : Average time = 255 nsec

##### Test#3 (functions) #####
Test#3 [templated_foo_int_1] : Average time = 92 nsec
Test#3 [templated_foo_int_2] : Average time = 92 nsec
Test#3 [ordinary_foo_int] : Average time = 631 nsec
Test#3 [templated_foo_string_1] : Average time = 269 nsec
Test#3 [templated_foo_string_2] : Average time = 254 nsec
Test#3 [ordinary_foo_string] : Average time = 254 nsec

##### Test#4 (functions) #####
Test#4 [templated_foo_int_1] : Average time = 92 nsec
Test#4 [templated_foo_int_2] : Average time = 98 nsec
Test#4 [ordinary_foo_int] : Average time = 72 nsec
Test#4 [templated_foo_string_1] : Average time = 254 nsec
Test#4 [templated_foo_string_2] : Average time = 254 nsec
Test#4 [ordinary_foo_string] : Average time = 261 nsec

##### Test#5 (functions) #####
Test#5 [templated_foo_int_1] : Average time = 92 nsec
Test#5 [templated_foo_int_2] : Average time = 92 nsec
Test#5 [ordinary_foo_int] : Average time = 72 nsec
Test#5 [templated_foo_string_1] : Average time = 281 nsec
Test#5 [templated_foo_string_2] : Average time = 254 nsec
Test#5 [ordinary_foo_string] : Average time = 254 nsec
//--------------------------

//--------------------------
% g++ -O2 perf.C
% a.out

##### Test#1 (functions) #####
Test#1 [templated_foo_int_1] : Average time = 92 nsec
Test#1 [templated_foo_int_2] : Average time = 73 nsec
Test#1 [ordinary_foo_int] : Average time = 72 nsec
Test#1 [templated_foo_string_1] : Average time = 482 nsec
Test#1 [templated_foo_string_2] : Average time = 303 nsec
Test#1 [ordinary_foo_string] : Average time = 303 nsec

##### Test#2 (functions) #####
Test#2 [templated_foo_int_1] : Average time = 125 nsec
Test#2 [templated_foo_int_2] : Average time = 73 nsec
Test#2 [ordinary_foo_int] : Average time = 72 nsec
Test#2 [templated_foo_string_1] : Average time = 303 nsec
Test#2 [templated_foo_string_2] : Average time = 310 nsec
Test#2 [ordinary_foo_string] : Average time = 303 nsec

##### Test#3 (functions) #####
Test#3 [templated_foo_int_1] : Average time = 73 nsec
Test#3 [templated_foo_int_2] : Average time = 73 nsec
Test#3 [ordinary_foo_int] : Average time = 191 nsec
Test#3 [templated_foo_string_1] : Average time = 303 nsec
Test#3 [templated_foo_string_2] : Average time = 303 nsec
Test#3 [ordinary_foo_string] : Average time = 303 nsec

##### Test#4 (functions) #####
Test#4 [templated_foo_int_1] : Average time = 73 nsec
Test#4 [templated_foo_int_2] : Average time = 73 nsec
Test#4 [ordinary_foo_int] : Average time = 72 nsec
Test#4 [templated_foo_string_1] : Average time = 310 nsec
Test#4 [templated_foo_string_2] : Average time = 303 nsec
Test#4 [ordinary_foo_string] : Average time = 310 nsec

##### Test#5 (functions) #####
Test#5 [templated_foo_int_1] : Average time = 73 nsec
Test#5 [templated_foo_int_2] : Average time = 73 nsec
Test#5 [ordinary_foo_int] : Average time = 72 nsec
Test#5 [templated_foo_string_1] : Average time = 303 nsec
Test#5 [templated_foo_string_2] : Average time = 323 nsec
Test#5 [ordinary_foo_string] : Average time = 303 nsec
//--------------------------

//--------------------------
% g++ -O3 perf.C
% a.out

##### Test#1 (functions) #####
Test#1 [templated_foo_int_1] : Average time = 92 nsec
Test#1 [templated_foo_int_2] : Average time = 92 nsec
Test#1 [ordinary_foo_int] : Average time = 18 nsec
Test#1 [templated_foo_string_1] : Average time = 227 nsec
Test#1 [templated_foo_string_2] : Average time = 227 nsec
Test#1 [ordinary_foo_string] : Average time = 457 nsec

##### Test#2 (functions) #####
Test#2 [templated_foo_int_1] : Average time = 92 nsec
Test#2 [templated_foo_int_2] : Average time = 92 nsec
Test#2 [ordinary_foo_int] : Average time = 18 nsec
Test#2 [templated_foo_string_1] : Average time = 302 nsec
Test#2 [templated_foo_string_2] : Average time = 302 nsec
Test#2 [ordinary_foo_string] : Average time = 309 nsec

##### Test#3 (functions) #####
Test#3 [templated_foo_int_1] : Average time = 92 nsec
Test#3 [templated_foo_int_2] : Average time = 92 nsec
Test#3 [ordinary_foo_int] : Average time = 18 nsec
Test#3 [templated_foo_string_1] : Average time = 302 nsec
Test#3 [templated_foo_string_2] : Average time = 302 nsec
Test#3 [ordinary_foo_string] : Average time = 317 nsec

##### Test#4 (functions) #####
Test#4 [templated_foo_int_1] : Average time = 92 nsec
Test#4 [templated_foo_int_2] : Average time = 105 nsec
Test#4 [ordinary_foo_int] : Average time = 25 nsec
Test#4 [templated_foo_string_1] : Average time = 302 nsec
Test#4 [templated_foo_string_2] : Average time = 314 nsec
Test#4 [ordinary_foo_string] : Average time = 434 nsec

##### Test#5 (functions) #####
Test#5 [templated_foo_int_1] : Average time = 92 nsec
Test#5 [templated_foo_int_2] : Average time = 91 nsec
Test#5 [ordinary_foo_int] : Average time = 18 nsec
Test#5 [templated_foo_string_1] : Average time = 302 nsec
Test#5 [templated_foo_string_2] : Average time = 318 nsec
Test#5 [ordinary_foo_string] : Average time = 319 nsec
//--------------------------

//------------------- Running Results : END ---------------


//#########################################################
//------------------- Compiler & System ------------------

g++ -v : gcc version egcs-2.91.57 19980901
(egcs-1.1 release)

uname -a : SunOS <nodename> 5.6 Generic_105181-09
sun4m sparc SUNW,SPARCstation-5

psrinfo -v : -> The sparc processor operates at 110 MHz

//---------------------------------------------------------

//#########################################################


Sent via Deja.com http://www.deja.com/
Share what you know. Learn what you don't.

[ Send an empty e-mail to c++-...@netlab.cs.rpi.edu for info ]
[ about comp.lang.c++.moderated. First time posters: do this! ]

blargg

unread,
Jul 27, 1999, 3:00:00 AM7/27/99
to
In article <7njs0m$qr4$1...@nnrp1.deja.com>, Alex Vinokur
<alexande...@telrad.co.il> wrote:

> Hi,
>
> Performance of calling
> templated and non-templated functions
> was measured.

[snip]

> template <typename T>
> void templated_foo (const T& t_i)
> {
> T t;
> }
>

> void ordinary_foo (int t_i)
> {
> int t;
> }
>

> void ordinary_foo (const string& t_i)
> {
> string t;
> }

Very likely, your results are significantly affected by the alignment of
the generated template functions. Modern processors can have different
performance characteristics depending on how the code falls on cache-line
boundaries.

Getting good performance data is difficult. In this case, it's pointless,
because a template function on any reasonable implementation will be
equivalent to a non-template function in terms of generated code.

Side note: Even though this person's code (see original post for example)
follows a consistent style, I find it very hard to read (mainly because
there are so many distracting comment lines). Uck.

[snip]

Siemel Naran

unread,
Jul 27, 1999, 3:00:00 AM7/27/99
to
On 27 Jul 1999 12:14:26 -0400, blargg <postmast.ro...@iname.com> wrote:
>In article <7njs0m$qr4$1...@nnrp1.deja.com>, Alex Vinokur

>Side note: Even though this person's code (see original post for example)


>follows a consistent style, I find it very hard to read (mainly because
>there are so many distracting comment lines). Uck.

I disagree -- to me, Alex's code seems very easy to read.

In general, I agree that too many comments and ifdefs make the code very
hard to read. But Alex's code looks fine to me anyway.
Here's the crux of the matter: it seems that more and more people are
using editors that do color highlighting, so the comments appear in a
different color. So these comments between functions serve as excellent
seperators.

--
----------------------------------
Siemel B. Naran (sbn...@uiuc.edu)
----------------------------------

Francis Glassborow

unread,
Jul 28, 1999, 3:00:00 AM7/28/99
to
In article <slrn7ps5su....@noname.nodomain.nowhere>, Siemel
Naran <sbn...@noname.nodomain.nowhere> writes

>I disagree -- to me, Alex's code seems very easy to read.
>
>In general, I agree that too many comments and ifdefs make the code very
>hard to read. But Alex's code looks fine to me anyway.
>Here's the crux of the matter: it seems that more and more people are
>using editors that do color highlighting, so the comments appear in a
>different color. So these comments between functions serve as excellent
>seperators.

and you can colour comments white on white :) But lengthy internal
comments are still a pain.


Francis Glassborow Journal Editor, Association of C & C++ Users
64 Southfield Rd
Oxford OX4 1PA +44(0)1865 246490
All opinions are mine and do not represent those of any organisation

0 new messages