how to identify the number of calls of a fuction

[contactmayankjain]

Hi,


Can you tell me is there some procedure to calculate the number of
calls of a function during run time?
How to insert a counter and how to increment it? and possibly which
function have called it how many times?



Thanks
Regards
Mayank Jain
+919818390836

 

[Victor Bazarov]

Can you tell me is there some procedure to calculate the number of
calls of a function during run time?

Yes, it's called "call counter". You place

unsigned my_function_counter;

right before the function, in the global scope. Then the very first
statement in the function should be

++my_function_counter;

and then at the end of your program you simply print the counter out.

How to insert a counter and how to increment it? and possibly which
function have called it how many times?

Ah... Which function... You need a profiler. Just use the proper
tool for the job.

V

 

[=?ISO-8859-1?Q?Erik_Wikstr=F6m?=]

Yes, it's called "call counter". You place

unsigned my_function_counter;

right before the function, in the global scope. Then the very first
statement in the function should be

++my_function_counter;

and then at the end of your program you simply print the counter out.


Ah... Which function... You need a profiler. Just use the proper
tool for the job.

Or, a bit more cumbersome, identify all places a call is made to your
function (any good IDE should be able to tell you, along with some other
tools) and add counters at each call-point. But if you need to do this
for more than one function then you probably should get a profiler.

BTW: A bit off-topic but, is there any good, free profiler for windows.
This seems to be one of those where you can only get two out of three.
Either it's good but not free, free but not good, or not for windows.

 

[Victor Bazarov]

[..]
BTW: A bit off-topic but, is there any good, free profiler for
windows.

BTW, a bit off-topic, but, wouldn't it be too much to ask to use
proper punctuation? You know, like the question mark I put after
I asked a question...

"Good" and "free" rarely coexist in a characterisation of a piece
of software, especially when development tools are concerned.
Just get a trial version of AQtime, you get two weeks of use, it
should be enough to learn the tool and to improve the performance
of your program. Then buy it. Don't get cheap when tools are
concerned. A good tool is worth every penny.

This seems to be one of those where you can only get two out
of three. Either it's good but not free, free but not good, or not
for windows.

Yep.

V

 

[Shadowman]

Yes, it's called "call counter". You place

unsigned my_function_counter;

right before the function, in the global scope. Then the very first
statement in the function should be

++my_function_counter;

and then at the end of your program you simply print the counter out.

Why not a static variable inside the function?

 

[Victor Bazarov]

Why not a static variable inside the function?

How would you print it out?

V

 

[terminator]

Why not a static variable inside the function?

you will have to either return that variable by value or store it in a
global variable before return in which case simply using a global is
more efficient.

regards,
FM.

 

[terminator]

Yes, it's called "call counter". You place

unsigned my_function_counter;

right before the function, in the global scope. Then the very first
statement in the function should be

++my_function_counter;

and then at the end of your program you simply print the counter out.


Ah... Which function... You need a profiler. Just use the proper
tool for the job.

V

you can also get a pointer to caller as an argument of the callee
which is then stored in a container:

typedef std:air<void(*)(void),std::string> mypair;

inline std::vector< mypair >& call_map(){
static std::vector< mypair > data;
return data;
};

void callee(void (* mycaller)(void),std::string caller_name){

call_map().push_back(mypair(mycaller,caller_name));
...//go on
};

void caller(void){
callee(&caller,"caller");

};

void print(const mypair& mp){
//do some printing on mp
};

int main (void){
caller();
std::cout<<"callee count="<<call_map().size()<<endl;
std::for_each(call_map().begin(),call_map.end(),print);
return 0;
};

regards,
FM.

 

[James Kanze]

[..]
BTW: A bit off-topic but, is there any good, free profiler for
windows.

"Good" and "free" rarely coexist in a characterisation of a piece
of software, especially when development tools are concerned.

I tend to agree, although there are notable exceptions,
precisely in the domain of development tools: g++ and gprof.
Also, regrettably "good" and "commercial" rarely coexist either.

Logically, commercial software has definite advantages: the
additional leverage over employees can't hurt (although abusing
it is not the best way to get the process to work).
Practically, hackers seem to abound in both commercial and free
software, and even acceptable quality is the exception for both.
And leverage or not, some non-commercial operations, like g++,
have managed to implement a fairly good development
process---better, at any rate, than that in most commercial
organizations.

 

[James Kanze]

Can you tell me is there some procedure to calculate the number of
calls of a function during run time?
How to insert a counter and how to increment it? and possibly which
function have called it how many times?

It's implementation dependent, but any good compiler should have
an option to do this automatically, writing the results out to a
file at the end of execution. (With g++, for example, the
option is -pg. And the output is written in a binary format, so
you need an additional tool, gprof, to read it. On the other
hand, you get a lot more than just the counts of how many times
each function has been called.)