Re: Excessive Inlining
On Mar 30, 11:56 am, Fei Liu <fei...@aepnetworks.com> wrote:
LuB wrote:
On Mar 30, 11:42 am, Fei Liu <fei...@aepnetworks.com> wrote:
LuB wrote:
How judicious ought one be when inlining small methods.
Keep in mind that inline is just a hint to the compiler. The compiler
has the freedom to choose either inline or not inline the specified
subroutine.
If your profiling indicates that inlining a subroutine can significantly
improve application performance, consider adding 'inline' declaration.
Fei
Yes, I do know that it is just a hint.
Assume I am writing a library for someone else to use.
And, assume my classes in turn, wrap up some other library (MFC, WTL,
take your pick). I am essentially wrapping up some library ... writing
pass through calls ... and then handing the resulting class to someone
else. Maybe selling it someone else.
Will I be hurting someone else's code - by declaring and implementing
as "inline" all the simple, one line pass through operations in my
library.
-Luther
How can it hurt someone else's code? Inlining only happens at link
time...What makes you think it might hurt someone else's code?
At the risk of being wordy, I think my perception is wrong .. and
maybe this is a question for a *compiler* newsgroup:
But, my fear was that ... in any given method, only one nested call
can be inlined. Given the following example, could the compiler inline
ALL of the methods? or is it somehow limited to just one. Notice how
they are nested/successive calls? Inline calling an inline ... etc. I
got the impression that the compiler was physically limited ... that
it wouldn't inline more than one of these methods in this particular
call graph.
class BigMethods
{
void methodA()
{
int len = myList.GetSize();
}
};
class MyList
{
inline void GetSize() const
{
return impl_.size();
}
ListImpl<T> impl_;
};
template<typename T>
class ListImpl
{
inline void size() const
{
return impl_.size();
}
std::list<T> impl_;
};
If that is the case, then I might be more apt (for pure performance
sake) to use direct access for some things and 'save' my single
possible inline call for something I can't easily replace with a
property?
class BigMethods
{
void methodA()
{
int len = myList.impl_.GetSize();
}
};
class MyList
{
inline void GetSize() const
{
return impl_.size();
}
ListImpl<T> impl_;
};
template<typename T>
class ListImpl
{
inline void size() const
{
return impl_.size();
}
std::list<T> impl_;
};
Please ignore any technical problems with the above psuedocode - my
underlying question is in regards to inlining hints and compiler
limitations.
If I'm limited to one inline method per call graph - maybe I won't use
a low level wrapper - since those inline methods would use up my
single inline function per call.
Sorry if this explanation is confusing. HTH.
-Luther