How Significant Is PHP Function Call Overhead?

PHP function call overhead is precisely 15.5355%.

:) Just stirring the pot.

Seriously, here are a couple great links on the subject:

Is it possible to have too many functions in a PHP application?

functions vs repeated code

The code maintainability versus speed discussions at these links address the (maybe more important) question implied by the OP, but just to add a little data that may also be pertinent and hopefully useful to people who come across this thread in the future, here are results from running the below code on a 2011 Macbook Pro (with very little drive space and too many programs running).

As noted elsewhere, an important consideration in deciding whether to call a function or put the code "in-line" is how many times the function will be called from within a certain block of code. The more times the function will be called, the more it's worth considering doing the work in-line.

Results (times in seconds)

Call Function Method | In-Line Method | Difference | Percent Different

1,000 iterations (4 runs)

0.0039088726043701 | 0.0031478404998779 | 0.00076103210449219 | 19.4694

0.0038208961486816 | 0.0025999546051025 | 0.0012209415435791 | 31.9543

0.0030159950256348 | 0.0029480457305908 | 6.7949295043945E-5 | 2.2530

0.0031449794769287 | 0.0031390190124512 | 5.9604644775391E-6 | 0.1895

1,000,000 iterations (4 runs)

3.1843111515045 | 2.6896121501923 | 0.49469900131226 | 15.5355

3.131945848465 | 2.7114839553833 | 0.42046189308167 | 13.4249

3.0256152153015 | 2.7648048400879 | 0.26081037521362 | 8.6201

3.1251409053802 | 2.7397727966309 | 0.38536810874939 | 12.3312

function postgres_friendly_number($dirtyString) {        $cleanString = str_ireplace("(", "-", $dirtyString);    $badChars = array("$", ",", ")");    $cleanString = str_ireplace($badChars, "", $cleanString);        return $cleanString;    }//main$badNumberString = '-$590,832.61';$iterations = 1000000;$startTime = microtime(true);for ($i = 1; $i <= $iterations; $i++) {    $goodNumberString = postgres_friendly_number($badNumberString);}$endTime = microtime(true);$firstTime = ($endTime - $startTime); $startTime = microtime(true);for ($i = 1; $i <= $iterations; $i++) {    $goodNumberString = str_ireplace("(", "-", $badNumberString);    $badChars = array("$", ",", ")");    $goodNumberString = str_ireplace($badChars, "", $goodNumberString);}$endTime = microtime(true); $secondTime = ($endTime - $startTime); $timeDifference = $firstTime - $secondTime;$percentDifference = (( $timeDifference / $firstTime ) * 100);

Nobody has yet discussed how the server's hardware is related to function call overhead.

When a function is called, all of the CPU's registers contain data relevant to the current execution point. All of the CPU's registers must be saved to memory (typically the process' stack) or there is no hope of ever returning to that execution point and resuming execution. When returning from the function, all of the CPU's registers must be restored from memory (typically the process' stack).

So, one can see how a string of nested function calls can add overhead to the process. The CPU's registers must be saved over and over again on the stack and restored over and over again to get back from the functions.

This is really the source of the overhead of function calls. And if function arguments are passed, those must all be duplicated before the function can be called. Therefore, passing huge arrays as function arguments is a poor design.

Studies have been done on object-oriented PHP on overhead of use of getters/setters. Removing all getters/setters cut execution time by about 50%. And that simply is due to function call overhead.

The canonical PHP implementation is very slow because it's easy to implement and the applications PHP aims at do not require raw performance like fast function calls.

You might want to consider other PHP implementations.

If you are writing the applications you should be writing in PHP (dump data from DB to the browser over a network) then the function call overhead is not significant. Certainly don't go out of your way to duplicate code because you were afraid using a function would be too much overhead.