On Sunday, September 9, 2001, at 12:43 PM, Cristopher Daniluk wrote:
Let's just make the supposition for a second that you're right, that the
difference between calling a userspace function over an internal function is
going to create phenomenal decreases in overall execution time. The
implication I believe you give is that over an amortized amount of time,
execution speed between calling a userland function and internal function
will be approximately 2x.
Try the example I listed with preg_match. Clearly here one would not expect that the execution speed is twice as long, as (at least intuitively) preg_match does much more woirk than the userland alias.
This is just mind boggling! Sure, there's roughly
twice the work to call a user function wrapper compared to calling the
internal. There's also the loss in parsing.
The parsing overhead is amortized over a million executions of the code block.
However, do not make the fatal
mistake of assuming that twice the cost of an operation translates to twice
the cost of a process, or for that matter, even a negligible cost increase.
Why not? It took twice as long to run. To me that's a cost. If I was writing a bit of code which did an enormous number of executions of simple userland functions, I would care about this. If I'm calling _() or some other function 10 times on a page, then you;re right, I won't care, but if I _do_ for whatever reasoncall a function repeatedly, then it _can_ make a difference.
PHP would not, and I can't make this clear enough, would NOT be a viable
option in the market if the performance loss in real world scenarios from
simply entering into a function was that great.
What does this have to do with anything? The market viability of php implies nothing about the execution speed of function calls (though the latter may be true.)
I'd venture (these are
SWAGs) to say that a single call to preg_replace does over 500x more machine
instructions than calling a userland function.
I bet the gettext call
itself, which is the focal point of this discussion, does 50x more machine
instructions, than the function call that's wrapping it. If you look at it
on a microcosmic sense, there is a clear and real difference, but when you
analyze on a macro level, you clearly can't argue there is a performance
loss worth caring about. It's just childish and foolish and arguing it makes
you look truly foolish. If you don't believe that, imagine for a tenth of a
second that you're right, and think about the implications.
Thinking about the ramifications of me being right shouldn't make me analytically look at the cost of things? Whatever. Fortunately my world view is gruonded enough that I think I can survive the implications of userland function calls having a significant cost. Instead of sticking my head in the sand, I would rather use this knowledge productively. To me means when analyzing code efficiency that one should realize that repeated call to userland functions have an intrinsic cost in addtiion to the work done inside a function.
