C++Talk.NET C++ language newsgroups   Archives   FAQ   Search   Memberlist   Usergroups   Register   Profile   Log in to check your private messages   Log in  What is function call overhead (beginner question) Goto page 1, 2  Next          C++Talk.NET Forum Index -> C++ Language (Moderated) View previous topic :: View next topic   Author Message sathyashrayan Guest Posted: Wed Apr 27, 2005 12:33 pm    Post subject: What is function call overhead (beginner question) <abridged> what is a function call over head and how it is avoided in the inline functions in C++? </abridged> <OT> I don't know which is the correct group to ask this question. I was basically from C bacground.I was learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also?(I know that sack are not defined in C++ standard, correct me if I am wrong).This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? I went through the FAQ but it does not explain the basic of function call over head for a beginner to follow. </OT> -- "combination is the heart of chess" A.Alekhine Mail to: sathyashrayan AT gmail DOT com [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Victor Bazarov Guest Posted: Thu Apr 28, 2005 12:31 pm    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: Quote: abridged what is a function call over head and how it is avoided in the inline functions in C++? /abridged Usually it's the time the program spends packing up the arguments and transferring control to the function code plus unpacking the return values and disposing of the packed arguments after the function returns. V [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Jonathan Bartlett Guest Posted: Thu Apr 28, 2005 12:34 pm    Post subject: Re: What is function call overhead (beginner question) Quote: what is a function call over head and how it is avoided in the inline functions in C++? When calling a function, several things have to occur at the machine-language level: All of the parameters have to be pushed onto the stack (each parameter takes at least 1 instruction, sometimes more). Then you have to issue a "call", which modifies the instruction pointer, and sets the return address. Depending on how well your processor does pipelining, this may break your instruction pipeline. Then, the new function has to set up the "stack frame" which contains all of its local variables, and save the location of the previous stack frame. Then, when the function is done, it has to copy the return value, restore the original stack frame, and issue a return, after which the calling function will probably do some stack cleanup of its own. By declaring a function "inline" it can essentially just copy the body of the called function into the body of the calling function. Thus, the local variables are created at the same time, no parameters have to be pushed, no variables have to be returned, and no stack frame has to be created. In addition, you get the additional advantage that it allows optimizations through the function-call barrier. As an example of optimizing through the function-call barrier, see this trivial example: int power(int a, int b) { int result = 1; while(b) { result = result * a; b--; } return result; } /* Within some function */ y = power(x, 3); Without "power" being inlined, not only do you have the function call overhead, but the compiler can't optimize for the fact that the loop will occur exactly 3 times. If it is inlined, it would look like this to the compiler: /* Within some function */ int result = 1; int b = 3; while(b) { result = result * x; } y = result; Since "b" is a constant, the compiler can determine that the loop will occur exactly three times, and thus "unroll" the loop: /* Within some function */ int result = 1; int b = 3; result = result * x; b--; result = result * x; b--; result = result * x; b--; y = result; Now, since "b" was only used for looping, you can now see that it is not used at all, so all references to "b" can now be removed, giving this: /* Within some function */ int result = 1; result = result * x; result = result * x; result = result * x; y = result; In addition, since "y" is being overwritten anyone, it can be used in place of result, so we don't have to allocate yet another variable, and can reduce the number of assignments by one: /* Within some function */ y = 1; y = y * x; y = y * x; y = y * x; /* now y has the right answer */ All of this takes place within the compiler. There are some instances where you DO NOT want functions inlined, which is why you have to supply a keyword to get the compiler to do it. If you want to know more about the function call overhead, and what is involved in that sort of thing, see my book, Programming from the Ground Up: http://www.cafeshops.com/bartlettpublish.8640017 Jon ---- Learn to program using Linux assembly language http://www.cafeshops.com/bartlettpublish.8640017 [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top kerzum@mail.ru Guest Posted: Thu Apr 28, 2005 12:34 pm    Post subject: Re: What is function call overhead (beginner question) Well, C++ function call is very much like C's, so it implies the same overhead. Though there are several C++ issues not present in C you have to consider - I'll describe them compared to C: 1. Reference function arguments are passed as pointers and the overhead is not dependent on the size of object // C++ struct S; void f(S& s) {} has the same overhead as /* C */ struct S; void f(S* s) {} and not as /* C */ struct S; void f(S s) {} 2. non-virtual non-static member functions have additional implicit 'this' pointer argument. This implies 'one more argument overhead' // C++ class A { void f(); ... }; A a; a.f(); is implemented very much the same as /* C */ struct A {...}; void f(A*); A a; f(&a) 3. static member functions have no 'this' and no additional overhead compared to normal C and C++ functions 4. virtual member functions require vtable lookup and (correct me if I'm wrong) will require about twice as much processor time than non-virtual functions. Well, I;m not sure if this is good idea to try to translate virtual call to C, but I'll try // C++ class A { public: virtual void f(); }; A a; a.f(); /* C */ /* this stuff is mostly done during compilation */ struct A; typedef void(*Afn)(A*); void sample_A_fn(A*); Afn A_vtable_1[]={&sample_A_fn}; A { Afn* vptr; } A a; a.vptr=A_vtable; /* this is the call */ a.vptr[0](&a); Please, note also that optimizing compiler should remove this overhead when exact type of the object in known, so I example above should imply the same overhead as non-virtual member functions - consider the difference void f1() { A a; a.f(); // the type of 'a' is 'A', so just call A::f } void f2(A* a) { a->f(); // exact type of 'a' is unknown - do vtable lookup } 5. and finally, inline functions are not called at all - they are inlined. As far as I know this is also available as extension / optimization in many C compilers // C++ inline bool is_even(int i) { return !(i%2); } void f(int n) { char* message; if(is_even(n)) message="n is evenn"; else message="n is oddn"; } /* C */ void f(int n) { char* message; if((!(i%2))) message="n is evenn"; else message="n is oddn"; } The downside of inline functions is that 1. the definition of the function should be in the same comilation unit with the call 2. inlining might expand the size of executable As far as I remeber that's all - hope it will help. I'd also recommend you to read the 'D&E' book - If you are interested in this question, you'll find yet more interesting questions there. Good luck :) Regards, Peter A. Kerzum [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top GianGuz Guest Posted: Thu Apr 28, 2005 12:36 pm    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: Quote: abridged what is a function call over head and how it is avoided in the inline functions in C++? /abridged OT I don't know which is the correct group to ask this question. I was basically from C bacground.I was learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also? Yes. It is the overhead you talk about. But overhead can also derive by the way paramters are passed and values are returned. for example: int f(A a, B b) where A and B objects are passed by value and so copy constructors have to be called, involve more overhead than int f(A& a, B& b) where A and B objects are passed by reference and so only addresses are passed. (I know that sack are not defined in Quote: C++ standard, correct me if I am wrong).This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? an inline function is simply translated into a "code expansion" of its body at the point in which it is called. The result is a code that is usually larger but always faster. No argument passing thorough the stack is needed because arguments are used directly into the expanded code. You can see inlining as a sort of MACRO expansion that preserve function semantic. Gianguglielmo [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Antoun Kanawati Guest Posted: Thu Apr 28, 2005 12:37 pm    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: Quote: abridged what is a function call over head and how it is avoided in the inline functions in C++? /abridged Function call overhead is that work needed to push args on the stack, establish the call frame in the called procedure, and restore the frame pointer before the call leaves, and restore the stack after the call returns. The C++ 'inline' advises the compiler to inline functions; loosely speaking: this means replacing the function call with the function body, if the compiler decides that the conditions are suitable for such a transformation. You can get an idea by looking at assembly language listings of simple programs. extern int foo(int); int bar() { return foo(42); } int foo(int x) { return x+1; } ...globl bar .type bar, @function bar: #--- prologue: start pushl %ebp movl %esp, %ebp #--- prologue: end #---------- call overhead at call-site subl $8, %esp # push arg movl $42, (%esp) # push arg call foo # call #----------- #--- epilogue: start leave ret #--- epilogue: end .size bar, .-bar ...globl foo .type foo, @function foo: pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax incl %eax popl %ebp ret As you can see above, the overhead is in two parts: 1. At the call site: the push/call sequence. 2. At entry and exit of the called function: typically called prologue and epilogue. Furthermore, in the absence of context, optimization opportunities are not available. Now, if I mark the above two functions 'inline', and write: inline int foo(int x) { return x+1; } inline int bar() { return foo(42); } int baz() { return bar(); } Here's what I get for the bar() call; a single instruction: movl $43, %eax # <<<<< the call bar() returns a constant. Of course, this is an extreme example. In general, inlining small-bodied functions can yield significant benefits, especially when coupled with optimization. -- A. Kanawati [email]NO.antounk.SPAM (AT) comcast (DOT) net[/email] [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top mlimber Guest Posted: Thu Apr 28, 2005 12:40 pm    Post subject: Re: What is function call overhead (beginner question) Quote: This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Function call overhead is basically the same as in C. Inline functions avoid overhead by being copied into the body of the caller in place of the function call -- similar to the behavior of a #define in C except that inline functions do type checking and don't suffer from some of the other problems of macros. For instance, the following maximum computations aim to do the same thing: #define MAX( m, n ) ( (m) > (n) ? (m) : (n) ) template<class T> inline T max( const T& m, const T& n ) { return m > n ? m : n; } The difference is that when max() is called, the arguments are evaluated before the substitution is done and type checking is performed -- meaning a call like max( j++, ++k ) will yield a predictable (if obscure) result, unlike MAX( j++, ++k ), which will expand to ( (j++) > (++k) ? (j++) : (++k) ) and is probably not what was intended. Inline functions are good in many situations, but you probably do not want an entire program composed of them because it would likely be very bloated code. You should inline small functions or functions that need to be fast (preferably determined by a profiler, not intuition). M [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Jerry Coffin Guest Posted: Thu Apr 28, 2005 12:43 pm    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: [ ... ] Quote: I was basically from C bacground.I was learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also?(I know that sack are not defined in C++ standard, correct me if I am wrong).This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? A function call in C++ is roughly similar -- put the parameters where they're expected, and then begin executing at the correct place. When the function finishes execution, execution resumes from where the function was called. An inline function reduces overhead by removing all three of those operations involved in the function: moving the parameters to the specific spots in which parameters are passed, jumping from one spot to another, than then jumping back. Inline functions _can_ improve optimization beyond that though. Expanding the code inline gives the compiler the opportunity to combine that code with surrounding code as well as things like eliminating code branches that won't be used in this particular invocation. One obvious possibility is when a literal value is passed to the function, and the function has conditions based on that value -- since the compiler only has to produce code for this specific instance, it can examine (at compile time) the literal value, and only produce the code for the parts of the code that will execute for that value. -- Later, Jerry. The universe is a figment of its own imagination. [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Mario Topf Guest Posted: Fri Apr 29, 2005 1:42 am    Post subject: Re: What is function call overhead (beginner question) Quote: I was basically from C bacground.I was learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also?(I know that sack are not defined in C++ standard, correct me if I am wrong).This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? Basically, an inlined function is not called but the instructions of that function are placed at the position of the function call instead of the call. Naturally this only works for very small functions such as Get-access shins and naturally the inline keyword is only a proposition for the compiler to inline a function - not a must. The result can be smaller and faster than the actual call as diverse registers don't have to be saved before the call and the call per se is not there any longer. The bigger the inlined portion of code gets, the worse the result will be leading to bloated, slow code. Basically, methods to be inlined should be declared in the header of a class in the class declaration, so the compiler would be able to replace inlined calls in each module where the call is done. The concept of whole program optimization implemented by some newer compilers allows function inlining accross module boundaries tough. -Mario -- http://www.speckdrumm.org [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Carlos Moreno Guest Posted: Fri Apr 29, 2005 1:44 am    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: Quote: learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also?(I know that sack are not defined in C++ standard, correct me if I am wrong).This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? You got your answer -- although the C++ standard does not say much about implementation details, the way you describe it is more or less inevitable in most platforms (at least most I'm familiar with ). And so yes, inline functions are compiled right into the place they're called; the compiler ensures that the semantics of the function is respected (which is a reason why inline functions are better, and should be preferred over macros/#defines). However, it is not true that inline functions are preferred over ordinary functions. Inline functions trade program size (executable file size) by speed. Excessive or otherwise careless use of inline functions falls in the category of premature optimization (the root of all evil ). Mind you, the compiler is always free to ignore your inline keyword, or to inline things you didn't ask it to, whenever it considers it appropriate. You ought to read (after you finish your "introduction" to the language) Scott Meyers' "Effective C++" and "More Effective C++". Although beginning to be borderline dated, they're still excellent books to guide you with advice about style, advanced techniques, and common mistakes to avoid. HTH, Carlos -- [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Llewelly Guest Posted: Fri Apr 29, 2005 8:27 am    Post subject: Re: What is function call overhead (beginner question) sathyashrayan <sathyashrayan (AT) REMOVETHISgmail (DOT) com> writes: [snip] Quote: what is a function call over head and how it is avoided in the inline functions in C++? [snip] One fact of inline functions that hasn't yet been mentioned (or it has but I missed it), is that when placed in header files, they tend to increase dependencies, and therefor significantly increase compile times. For example: //foo.hpp #ifndef GAURD_FOO_HPP #define GAURD_FOO_HPP #include "bar.hpp" inline void foo(bar b) //The definition of this function requires bar to be complete, and // so we need the full bar.hpp #included. { /* ... */ } #endif // end GAURD_FOO_HPP versus: //alternate foo.hpp #ifndef GAURD_FOO_HPP #define GAURD_FOO_HPP //Just a forward decl. #include "bar_fwd.hpp" void foo(bar b); // The declaration only needs a forward declaration // such as 'struct bar;' , not the the full bar.hpp. #endif // end GAURD_FOO_HPP In the worst case this can make the difference between O(n^2) builds and O(n*log(n)) builds. Of course for many projects the increase in dependencies creates software architecture problems which are much worse than the long build times. Shared libs that make heavy use of inline funcs can take much longer to load than those that don't. At my current job, there's a global prohibition on inline functions, no matter how small, primarily for the last two reasons. Not saying inline functions evil - but they're a tool with tradeoffs, and like all good tools, should not be used without cause. [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Ben Hutchings Guest Posted: Fri Apr 29, 2005 8:39 am    Post subject: Re: What is function call overhead (beginner question) sathyashrayan wrote: Quote: abridged what is a function call over head and how it is avoided in the inline functions in C++? /abridged OT I don't know which is the correct group to ask this question. I was basically from C bacground.I was learning C++ for the past 2 months. In C when a function is called the arguments are pushed in the stack in the reverse order,then the function called. After the function goes out of scope the argument are poped back.Is this condition are true for C++ also? That's how most C and C++ function calling conventions used on the x86 work. However there are alternate calling conventions that push arguments in the given order (sometimes called "stdcall") or pass some of them in registers. For non-static member functions it is common to pass the implicit "this" argument in a register. On most other architectures, including x86-64, it is normal to pass arguments in registers if there aren't too many of them. <snip> Quote: This is a claim in the C++ language that inline function are preferred over ordinary function to avoid function call over head. Can any body explain what is a function call over head and how it is avoided in the inline functions in C++? snip The "overhead" is the time spent in transferring arguments to and from the locations required by the calling convention. Compiling a function "inline" with its caller means there is no need to copy arguments around to follow the calling convention. Perhaps more importantly, the compiler can take advantage of any known properties of the arguments when generating code for the called function inlin. For example if the caller passes in a constant argument for a parameter which the called function tests, there's actually no need to test that at run-time. -- Ben Hutchings Having problems with C++ templates? Your questions may be answered by <http://womble.decadentplace.org.uk/c++/template-faq.html>. [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Antoun Kanawati Guest Posted: Sat Apr 30, 2005 11:25 am    Post subject: Re: What is function call overhead (beginner question) Llewelly wrote: Quote: sathyashrayan <sathyashrayan (AT) REMOVETHISgmail (DOT) com> writes: [snip] what is a function call over head and how it is avoided in the inline functions in C++? [snip] One fact of inline functions that hasn't yet been mentioned (or it has but I missed it), is that when placed in header files, they tend to increase dependencies, and therefor significantly increase compile times. [snip] Quote: In the worst case this can make the difference between O(n^2) builds and O(n*log(n)) builds. That is the extreme case. In general, runtime performance is a higher priority concern that build-time performance. Quote: Of course for many projects the increase in dependencies creates software architecture problems which are much worse than the long build times. So, ultimately, a well-designed project must strike a reasonable trade-off between these various factors (build time, run time, and architecture complexity). Quote: Shared libs that make heavy use of inline funcs can take much longer to load than those that don't. Well chosen inline functions can, and do, generate fewer instructions than the plain call, particularly, when they're thin wrappers around trivial bodies (e.g.: read-only accessors to data members, or simple delegations to private functions). Quote: At my current job, there's a global prohibition on inline functions, no matter how small, primarily for the last two reasons. If your interface is a library (static or shared), such an extreme rule is important; you want to ensure that all your exposed interfaces point into the library. I would not impose such a rule just to improve build-time however. I am guessing that you have some rules regarding templates in your interfaces? This probably relates to the template-export thread(s) elsewhere in this group. Quote: Not saying inline functions evil - but they're a tool with tradeoffs, and like all good tools, should not be used without cause. When properly used, you can reduce the size and runtime of a program. -- A. Kanawati [email]NO.antounk.SPAM (AT) comcast (DOT) net[/email] [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Francis Glassborow Guest Posted: Sat Apr 30, 2005 3:53 pm    Post subject: Re: What is function call overhead (beginner question) In article <7UXbe.39529$AR.1020955 (AT) wagner (DOT) videotron.net>, Carlos Moreno <moreno_at_mochima_dot_com (AT) xx (DOT) xxx> writes Quote: However, it is not true that inline functions are preferred over ordinary functions. Inline functions trade program size (executable file size) by speed. Not necessarily true: 1) Inlining can actually produce smaller code (consider a forwarding function) 2) If the code size goes up the program may slow up (consider the case where the extra size forces code to be too large to fit in cache. -- Francis Glassborow ACCU Author of 'You Can Do It!' see http://www.spellen.org/youcandoit For project ideas and contributions: http://www.spellen.org/youcandoit/projects [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Carlos Moreno Guest Posted: Sun May 01, 2005 3:00 pm    Post subject: Re: What is function call overhead (beginner question) Francis Glassborow wrote: Quote: However, it is not true that inline functions are preferred over ordinary functions. Inline functions trade program size (executable file size) by speed. Not necessarily true: 1) Inlining can actually produce smaller code (consider a forwarding function) 2) If the code size goes up the program may slow up (consider the case where the extra size forces code to be too large to fit in cache. Both true, of course. I didn't want to go too much in detail (however, I think I should have added an "in general" to my statement above); that's partly why I suggested Scott Meyers' book: one of the items discusses this inline issue very nicely -- including what you mention. Carlos -- [ See http://www.gotw.ca/resources/clcm.htm for info about ] [ comp.lang.c++.moderated. First time posters: Do this! ] Back to top Display posts from previous: All Posts1 Day7 Days2 Weeks1 Month3 Months6 Months1 Year Oldest FirstNewest First         C++Talk.NET Forum Index -> C++ Language (Moderated) All times are GMT Goto page 1, 2  Next Page 1 of 2   Jump to: Select a forum C/C++----------------C LanguageC Language (Moderated)C++ Language (Moderated)C++ language (comp.lang.c++)C++ language, library and standards Non-English C/C++ Newsgroups----------------C++ (German)C++ (French)  You cannot post new topics in this forum You cannot reply to topics in this forum You cannot edit your posts in this forum You cannot delete your posts in this forum You cannot vote in polls in this forum Powered by phpBB © 2001, 2006 phpBB Group SEO toolkit © 2004-2006 webmedic.