Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:86479
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.212.172 as permitted sender)
MIME-Version: 1.0
Sender: julienpauli@gmail.com
In-Reply-To: <440717E2-B633-48FF-A629-DEC3E0D89B19@golemon.com>
References: <CAEYWF=4Gn=6OcPWc3w2k6G7DWrqaUfS4QdohjhiSG+2vH8euyg@mail.gmail.com>
 <CB6903CB-DAC6-45D6-A71F-79BA14DE7B99@php.net> <440717E2-B633-48FF-A629-DEC3E0D89B19@golemon.com>
Date: Wed, 3 Jun 2015 17:13:07 +0200
Message-ID: <CAMUwpuSTjCJrTcMOuqWOkMg81Cfx8q9tSw3bNh-GqQ2bV5T90w@mail.gmail.com>
To: Sara Golemon <php@golemon.com>
Cc: Michael Wallner <mike@php.net>, "bishop@php.net" <bishop@php.net>, 
	PHP internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=f46d044481677ca99c05179e8165
Subject: Re: [PHP-DEV] Method call overhead
From: jpauli@php.net (Julien Pauli)

--f46d044481677ca99c05179e8165
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable

On Wed, Jun 3, 2015 at 4:29 PM, Sara Golemon <php@golemon.com> wrote:

>
> > On Jun 3, 2015, at 00:50, Michael Wallner <mike@php.net> wrote:
> >
> >>> On 03 06 2015, at 05:30, Bishop Bettini <bishop@php.net> wrote:
> >>
> >> My question though is on relative times.  Method call overhead is
> >> consistently 50% to 150% over a direct call.  Is my experiment invalid=
,
> or
> >> is this overhead expected?  Is the overhead in the allocation,
> >> deallocation, GC?
> >
> > I=E2=80=99suggest you use a tool like valgrind=E2=80=99s callgrind (and=
 visualize with
> e.g. kcachegrind).
> >
> I'd also take variable function calling out of the picture (or at least,
> have it as a separate dimension).  Normal applications make pretty spare
> use of variable functions (compared to actual direct calls), whereas your
> benchmark uses them exclusively.  So you've explicitly chosen the most
> pessimistic path, and an unrepresentative one.
>


Yep, as I explain in [1] several [2] articles, direct calls are more
efficient that variable ones, which makes the engine analyze your variable
and look up for the function at runtime (whereas its done at compile time
when direct call).

Methods are heavier to trigger, because the engine needs to find the class,
then to find the method in the class, to finally use it. The compiler can't
pre-compute things, because the class may not exist yet and be
rutime-autoloaded, which adds flexibility to the language, but also prevent
us from optimizing things too deep.
The lookups in method calls are done only the first time, those lookups are
cached in the VM frame for reusage later.

You may have a look at ZEND_INIT_STATIC_METHOD_CALL handler if you want to
see what happens (for static calls).

For functions, if the function is known at the time its called, and if the
call is direct, then the process is fully optimized.

[1] http://jpauli.github.io/2015/02/05/zend-vm-executor.html
[2] http://jpauli.github.io/2015/01/22/on-php-function-calls.html

Julien Pauli



>
> -Sara
> --
> PHP Internals - PHP Runtime Development Mailing List
> To unsubscribe, visit: http://www.php.net/unsub.php
>
>

--f46d044481677ca99c05179e8165--