Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:67964
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.212.42 as permitted sender)
MIME-Version: 1.0
In-Reply-To: <CABBJUpcmhxrL8e_Yv=ysxXqbhN5nfdGwEZ0Thfm3uY+RARGBQA@mail.gmail.com>
References: <CAAyV7nGo4+n_4Ad7oKyuvLWTtmnui7fn6s-noCwG2PtT5A70tQ@mail.gmail.com>
	<51C9FA9C.8050403@sugarcrm.com>
	<CAAyV7nHz0E2Tmin5_S4OVii=U1HhuKKL6y_KAa+j=X7DT9My6g@mail.gmail.com>
	<51CA1C93.6080500@sugarcrm.com>
	<CAAyV7nHo-ZLx2F=+6URctZXTqx8tLgR=xG7j0wJ3unmiCxGvXQ@mail.gmail.com>
	<51CA24C5.9090505@sugarcrm.com>
	<CAAyV7nG2Lmo0q01KGbKpBzpJXbs-2E+1ir8yCOFnN8yC-Up2Gw@mail.gmail.com>
	<51CB167A.4020207@sugarcrm.com>
	<CAAyV7nHWJYkB0sFWNep=QJqVX7+QsKJ-ne=rD7Qszs98DDx3aA@mail.gmail.com>
	<CABBJUpeuVMDRFjyy9QVnOAkHJ9t2BC_TTfn_GJVf6UwHB3_v2Q@mail.gmail.com>
	<CABBJUpdWOTN1G4NGdNTSyBdfkk-2rW2bD+Tt_z4Q6o_T_Mh8Lw@mail.gmail.com>
	<CAAyV7nFQaKBQmok_vNqwUy8CY5RjcDSvgQRt0KA+yXTnwiWGWQ@mail.gmail.com>
	<CABBJUpcmhxrL8e_Yv=ysxXqbhN5nfdGwEZ0Thfm3uY+RARGBQA@mail.gmail.com>
Date: Thu, 27 Jun 2013 11:54:22 -0400
Message-ID: <CAAyV7nFmN3JErNHOA6-o_YxcoE=0-OCjmGQUsRXL5zO7PvGidw@mail.gmail.com>
To: Laruence <laruence@php.net>
Cc: Stas Malyshev <smalyshev@sugarcrm.com>, 
	"internals@lists.php.net" <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=001a11c1bfaa9b1e7f04e024c6bb
Subject: Re: [PHP-DEV] RFC: Protocol Type Hinting
From: ircmaxell@gmail.com (Anthony Ferrara)

--001a11c1bfaa9b1e7f04e024c6bb
Content-Type: text/plain; charset=ISO-8859-1

Laruence,

so are you saying, that check every method's signature of a class is
> *faster* than just check interface?
>

Yes, yes I am saying that. And yes, the numbers show that.

Think about it for a second. When you implement an interface, at compile
time the compiler must loop through and check every methods signature for
every interface. No matter if you ever type-hint against that interface or
not. It always runs every class definition. And due to the point that
opcode caches aren't caching this compilation step, it happens on every
page load.

So in the case where you implement an interface, but don't actually use
that interface in any hints, you're still iterating through every method.

My case only iterates through those methods when the hint is actually
reached. So in the cases where the class never enters a hinted
function/method, you wind up saving that iteration. So in that case it's
significantly faster...

In the case where both happens, all this does is delay the loop until
run-time. So the iteration still happens (the same amount, as it happens
for every unique class:interface pairing possible). In fact, the comparison
is quite comparable (there are some minor differences, but not in terms of
what's happening, just when it's happening).

And once we have a comparison (successful or not), we cache it for the two
class_entries involved. So then we never have to worry about executing it
again.

Therefore, structural hinting will be *worst-case* the same cost
(statistically) as interfaces (it's just delaying the check to runtime
instead of *every* compile). The average case (a cache hit, multiple checks
of the same CE), structural will be faster as it's just a HT lookup instead
of a recursive instanceof mapping. The best case (no hint), you *never*
iterate through the methods in the first place.

Sounds like a pretty convincing win on performance to me... Which is why
it's kind of weird to keep hearing that it's slow to do, at least 6 times
now in this thread...

I don't need to run the test at all


sigh...

Anthony

--001a11c1bfaa9b1e7f04e024c6bb--