On 4/13/16 10:55 AM, Lin Yo-An wrote:
Hi internals,
The javascript engine V8 uses a strategy called "startup snapshot" to
optimize app load time (see
http://v8project.blogspot.tw/2015/09/custom-startup-snapshots.html for more
details)
The approach used by V8 creates a snapshot from heap, so the V8Context
could be reused directly without re-running the bootstraping code.
I think running javascript app in the browser is somehow like we run php
script for each requests where the app bootstrapping code is required to be
executed repeatedly for each request.
Currently, our opcache extension can cache the byte codes, but the byte
codes still need to be executed every time when bootstrapping an app, and
which increases the overhead for each request.
For example, a lot of applications use composer to initialize the class
loader via the statement below:
require "vendor/autoload.php";
The statement above produces thousands of byte code to run, which is to
make an app ready. (If you use vld extension to show the opcodes)
However, if we can support a simple syntax to describe what is doing
"bootstrap", we are able to create a startup snapshot from it.
The proposal here want to introduce some new syntax to optimize app load
time though the below syntax:
bootstrap "vendor/autoload.php"; // caches the context after running
this script.
Or
bootstrap {
require "vendor/autoload.php";
// do something else for making app ready
};
And of course, we might detect the bootstrap script automatically without
creating new syntax and opcodes, but I think it's hard to do because PHP
applications can be written by many ways...
Questions
========
I don't know if this approach is doable or not. Or maybe we can support
this in a separated extension instead of changing the zend core?
Do you guys think it's doable? would you like to share your idea for this?
I have no idea how feasible it is for the engine. It may be impossible,
or it may be straightforward. However, if it can be done then it would
allow for vastly improved architecture for large applications. Many
large systems (Drupal being the example I know best) spend a lot of time
trying to optimize their bootstrap, loading as few services as possible,
adding complexity and indirection to lazy-load services, etc. because
that code is executed on every request. That means even a single
function call removed along that critical path can add up to a lot of
time over the course of a day. If instead we could snapshot a point in
time and restart there, we could remove all of that optimization and
make the bootstrap process actively load most of the system, then freeze
it; then requests come in to a fully booted system and we save a ton of
time initializing services on every request. I'd love that.
The trick, of course, is that PHP's standard setup model assumes that
the environment is created before the code is even loaded. The
superglobals, for instance, exist before the first line of userspace
code, yet those are the things that will vary per run *after* the
snapshot is made. And then there's the question of how to detect and
trigger a re-bootstrap, say when code is updated. For that reason, I
suspect such a change would require far more than just a few new
keywords; there would need to be some sever-level specification of a
bootstrap script that is distinct from the user-facing script that the
web server executes, and a few thousand edge cases to think about.
--
--Larry Garfield
--
PHP Internals - PHP Runtime Development Mailing List
To unsubscribe, visit: http://www.php.net/unsub.php
