Merge pull request #90 from pinepain/upgrades-and-new-features

Upgrades and new features

Author: pinepain

.travis.yml

@@ -6,17 +6,21 @@ services:
 
 env:
   global:
-    - V8=6.5
+    - V8=6.5.144
   matrix:
-    - TAG=xenial-v8-65-php-71
-    - TAG=xenial-v8-65-php-71 TEST_PHP_ARGS=-m
-    - TAG=xenial-v8-65-php-72
-    - TAG=xenial-v8-65-php-72 TEST_PHP_ARGS=-m
+    - PHP=7.2
+    - PHP=7.2 TEST_PHP_ARGS=-m
+    - PHP=7.1
+    - PHP=7.1 TEST_PHP_ARGS=-m
 
 before_install:
   # docker on travis doesn't allow anything before FROM, let's fix that
-  - sed -i -e "s/\${TAG}/$TAG/g" Dockerfile && sed -i -e '1,2d' Dockerfile
-  - docker build -t ${TRAVIS_REPO_SLUG}:${V8}-${PHP} --build-arg TAG=${TAG} .
+  - sed -i -e "s/:latest/:${V8}/g" Dockerfile
+  - docker build -t ${TRAVIS_REPO_SLUG} --build-arg PHP=${PHP} .
 
 script:
-  - docker run -e TEST_PHP_ARGS ${TRAVIS_REPO_SLUG}:${V8}-${PHP} bash -c "make test | tee result.txt; ./test-report.sh"
+  - docker run
+    -e TEST_PHP_ARGS
+    -v `pwd`:/root/php-v8
+    ${TRAVIS_REPO_SLUG}
+    bash -c "phpize && ./configure && make test | tee result.txt; ./test-report.sh"

Dockerfile

@@ -1,13 +1,28 @@
-ARG TAG=xenial-v8-65-php-72
+FROM pinepain/libv8:latest
 
-FROM pinepain/php-v8-docker:${TAG}
+ARG PHP=7.2
+
+ENV DEBIAN_FRONTEND noninteractive
+ENV TERM=xterm-256color
+ENV LC_ALL=C.UTF-8
+ENV NO_INTERACTION=1
+ENV REPORT_EXIT_STATUS=1
+
+RUN echo "deb http://ppa.launchpad.net/ondrej/php/ubuntu xenial main" > /etc/apt/sources.list.d/ondrej-php-xenial.list && \
+    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 4F4EA0AAE5267A6C && \
+    apt-get update && \
+    apt-get install -y valgrind && \
+    apt-get install -y php${PHP} php${PHP}-cli php${PHP}-dev php${PHP}-fpm && \
+    rm -rf /var/lib/apt/lists/* && \
+    echo 'variables_order = "EGPCS"' >> `php --ini | grep "Loaded Configuration File" | awk '{print $4}'` && \
+    php -i && \
+    php-config || true && \
+    mkdir /root/php-v8
 
-COPY . /root/php-v8
 COPY ./scripts/provision/.bashrc /root/.bashrc
 
 WORKDIR /root/php-v8
 
-ENV NO_INTERACTION=1
+#COPY . /root/php-v8
+#RUN phpize && ./configure && make
 
-RUN php -i && php-config || true
-RUN phpize && ./configure && make

README.md

@@ -100,7 +100,7 @@ on top of php-v8 extension and makes embedding JavaScript in PHP easier.
 ### Requirements
 
 #### V8
-You will need a recent v8 Google JavaScript engine version installed. At this time v8 >= 6.5.116 required.
+You will need a recent v8 Google JavaScript engine version installed. At this time v8 >= 6.5.144 required.
 
 #### PHP
 This extension is PHP7-only. It works and tested with both PHP 7.0 and PHP 7.1.
@@ -167,6 +167,15 @@ $ sudo make install
  - [pinepain/libv8-experimental](https://launchpad.net/~pinepain/+archive/ubuntu/libv8-experimental) normally contains
    `libv8` version that used in current `master` branch.
 
+### Docker
+
+First, let's build docker image `docker build -t pinepain/php-v8 .` that we'll use later for development. By default, 
+it contains PHP 7.2, though you can change that by passing `--build-arg PHP=MAJOR.MINOR` where MAJOR.MINOR version
+present in [ondrej/php](https://launchpad.net/~ondrej/+archive/ubuntu/php) PPA.
+
+To start playing with php-v8 in docker, run ```docker run -e TEST_PHP_ARGS -v `pwd`:/root/php-v8 -it pinepain/php-v8 bash``.
+Now you can build php-v8 as usual with `phpize && ./configure && make`. Don't forget to run `make test`!
+
 ### Docs
 
 To start writing docs you will need to get [GitBook](https://gitbook.com), just run `npm install gitbook-cli -g` and

config.m4

@@ -19,14 +19,14 @@ if test "$PHP_V8" != "no"; then
   SEARCH_PATH="/usr/local /usr"
   SEARCH_FOR="include/v8.h"
 
-  V8_MIN_API_VERSION_STR=6.5.116
+  V8_MIN_API_VERSION_STR=6.5.144
 
   DESIRED_V8_VERSION=`echo "${V8_MIN_API_VERSION_STR}" | $AWK 'BEGIN { FS = "."; } { printf "%s.%s", [$]1, [$]2;}'`
 
   # Path where v8 from packages we recommend are installed, it's /opt/libv8-MAJOR.MINOR on Ubuntu
-  # and /usr/local/opt/v8@MAJOR.MINOR on macOS
-  PRIORITY_SEARCH_PATH="/opt/libv8-${DESIRED_V8_VERSION} /usr/local/opt/v8@${DESIRED_V8_VERSION}"
-  SEARCH_PATH="${PRIORITY_SEARCH_PATH} /usr/local /usr"
+  # and /usr/local/opt/v8@MAJOR.MINOR on macOS. For Docker image it's just /opt/libv8
+  PRIORITY_SEARCH_PATH="/opt/libv8-${DESIRED_V8_VERSION} /usr/local/opt/v8@${DESIRED_V8_VERSION} /opt/libv8"
+  SEARCH_PATH="${PRIORITY_SEARCH_PATH} ${SEARCH_PATH}"
 
   if test -r $PHP_V8/$SEARCH_FOR; then
     V8_ROOT_DIR=$PHP_V8

docs/development/release-libv8.md

@@ -23,14 +23,10 @@ To track v8 changes you can use these links:
 1. Copy fresh `libv8-X.Y` build packages from `libv8-experimental` (default target for all libv8 builds we trigger)
    to it `libv8-X.Y` PPA. Do not rebuild, just copy binaries.
 2. **Wait for packages copied and published!**
-3. If there was a minor version bump in `libv8` (not patch), create new dockerfiles for it in
-   [php-v8-docker](https://github.com/pinepain/php-v8-docker) and set `ARG V8=X.Y` to proper version.
-4. Go to [php-v8-docker Docker Hub](https://hub.docker.com/r/pinepain/php-v8-docker) and remove old Docker tags from
-   been rebuild on push as we don't need them anymore and replace them with a new one (we still need to keep old tags
-   for CI purpose and just in case things won't go smooth and we have to rollback).
-5. Rebuild/publish docker images to include new `libv8` version.
-6. You may want to set proper default image `TAG` in `php-v8` `Dockerfile` by updating it first line `ARG TAG=xenial-v8-64-php-72`.
-7. Make sure you have proper `php-v8` version set in `packaging/Dockerfile` under `V8` constant. 
+3. Build [pinepain/libv8](https://github.com/pinepain/dockerfiles/tree/master/libv8) docker image, tag it with the 
+   relevant v8 full version and push to Docker Hub.
+4. You may want to set proper `V8` version in `php-v8` by updating it in `.travis.yml`.
+5. Make sure you have proper `php-v8` version set in `packaging/Dockerfile` under `V8` constant. 
 
 ## After docker images rebuilt/published
 

src/php_v8_heap_statistics.cc

@@ -37,6 +37,9 @@ void php_v8_heap_statistics_create_from_heap_statistics(zval *return_value, v8::
     zend_update_property_double(this_ce, return_value, ZEND_STRL("peak_malloced_memory"), hs->peak_malloced_memory());
 
     zend_update_property_bool(this_ce, return_value, ZEND_STRL("does_zap_garbage"), static_cast<zend_long>(hs->does_zap_garbage()));
+
+    zend_update_property_double(this_ce, return_value, ZEND_STRL("number_of_native_contexts"), hs->number_of_native_contexts());
+    zend_update_property_double(this_ce, return_value, ZEND_STRL("number_of_detached_contexts"), hs->number_of_detached_contexts());
 }
 
 static PHP_METHOD(HeapStatistics, __construct) {
@@ -51,10 +54,14 @@ static PHP_METHOD(HeapStatistics, __construct) {
 
     zend_bool does_zap_garbage = '\0';
 
-    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|" "dddd" "dddd" "b",
+    double number_of_native_contexts = 0;
+    double number_of_detached_contexts = 0;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "|" "dddd" "dddd" "b" "dd",
                               &total_heap_size, &total_heap_size_executable, &total_physical_size, &total_available_size,
                               &used_heap_size, &heap_size_limit, &malloced_memory, &peak_malloced_memory,
-                              &does_zap_garbage) == FAILURE) {
+                              &does_zap_garbage,
+                              &number_of_native_contexts, &number_of_detached_contexts) == FAILURE) {
         return;
     }
 
@@ -68,6 +75,9 @@ static PHP_METHOD(HeapStatistics, __construct) {
     zend_update_property_double(this_ce, getThis(), ZEND_STRL("peak_malloced_memory"), peak_malloced_memory);
 
     zend_update_property_bool(this_ce, getThis(), ZEND_STRL("does_zap_garbage"), does_zap_garbage);
+
+    zend_update_property_double(this_ce, getThis(), ZEND_STRL("number_of_native_contexts"), number_of_native_contexts);
+    zend_update_property_double(this_ce, getThis(), ZEND_STRL("number_of_detached_contexts"), number_of_detached_contexts);
 }
 
 static PHP_METHOD(HeapStatistics, getTotalHeapSize) {
@@ -160,6 +170,26 @@ static PHP_METHOD(HeapStatistics, doesZapGarbage) {
     RETVAL_ZVAL(zend_read_property(this_ce, getThis(), ZEND_STRL("does_zap_garbage"), 0, &rv), 1, 0);
 }
 
+static PHP_METHOD(HeapStatistics, getNumberOfNativeContexts) {
+    zval rv;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    RETVAL_ZVAL(zend_read_property(this_ce, getThis(), ZEND_STRL("number_of_native_contexts"), 0, &rv), 1, 0);
+}
+
+static PHP_METHOD(HeapStatistics, getNumberOfDetachedContexts) {
+    zval rv;
+
+    if (zend_parse_parameters_none() == FAILURE) {
+        return;
+    }
+
+    RETVAL_ZVAL(zend_read_property(this_ce, getThis(), ZEND_STRL("number_of_detached_contexts"), 0, &rv), 1, 0);
+}
+
 
 PHP_V8_ZEND_BEGIN_ARG_WITH_CONSTRUCTOR_INFO_EX(arginfo___construct, 0)
                 ZEND_ARG_TYPE_INFO(0, total_heap_size, IS_DOUBLE, 0)
@@ -202,6 +232,12 @@ ZEND_END_ARG_INFO()
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_doesZapGarbage, ZEND_RETURN_VALUE, 0, _IS_BOOL, 0)
 ZEND_END_ARG_INFO()
 
+PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_getNumberOfNativeContexts, ZEND_RETURN_VALUE, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
+PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_getNumberOfDetachedContexts, ZEND_RETURN_VALUE, 0, IS_DOUBLE, 0)
+ZEND_END_ARG_INFO()
+
 
 static const zend_function_entry php_v8_heap_statistics_methods[] = {
         PHP_V8_ME(HeapStatistics, __construct, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
@@ -215,6 +251,8 @@ static const zend_function_entry php_v8_heap_statistics_methods[] = {
         PHP_V8_ME(HeapStatistics, getMallocedMemory, ZEND_ACC_PUBLIC)
         PHP_V8_ME(HeapStatistics, getPeakMallocedMemory, ZEND_ACC_PUBLIC)
         PHP_V8_ME(HeapStatistics, doesZapGarbage, ZEND_ACC_PUBLIC)
+        PHP_V8_ME(HeapStatistics, getNumberOfNativeContexts, ZEND_ACC_PUBLIC)
+        PHP_V8_ME(HeapStatistics, getNumberOfDetachedContexts, ZEND_ACC_PUBLIC)
 
         PHP_FE_END
 };
@@ -236,5 +274,8 @@ PHP_MINIT_FUNCTION (php_v8_heap_statistics) {
 
     zend_declare_property_bool(this_ce, ZEND_STRL("does_zap_garbage"), false, ZEND_ACC_PRIVATE);
 
+    zend_declare_property_double(this_ce, ZEND_STRL("number_of_native_contexts"), 0, ZEND_ACC_PRIVATE);
+    zend_declare_property_double(this_ce, ZEND_STRL("number_of_detached_contexts"), 0, ZEND_ACC_PRIVATE);
+
     return SUCCESS;
 }

src/php_v8_script_compiler.cc

@@ -268,6 +268,39 @@ static PHP_METHOD(ScriptCompiler, compileFunctionInContext)
     php_v8_get_or_create_value(return_value, local_function, php_v8_context->php_v8_isolate);
 }
 
+static PHP_METHOD(ScriptCompiler, createCodeCache)
+{
+    zval rv;
+
+    zval *php_v8_unbound_script_zv;
+    zval *php_v8_source_string_zv;
+
+    if (zend_parse_parameters(ZEND_NUM_ARGS(), "oo", &php_v8_unbound_script_zv, &php_v8_source_string_zv) == FAILURE) {
+        return;
+    }
+
+    php_v8_init();
+
+    PHP_V8_FETCH_UNBOUND_SCRIPT_WITH_CHECK(php_v8_unbound_script_zv, php_v8_unbound_script);
+    PHP_V8_VALUE_FETCH_WITH_CHECK(php_v8_source_string_zv, php_v8_source_string);
+
+    PHP_V8_DATA_ISOLATES_CHECK(php_v8_unbound_script, php_v8_source_string);
+
+    PHP_V8_ENTER_STORED_ISOLATE(php_v8_unbound_script);
+
+    v8::Local<v8::UnboundScript> local_unbound_script = php_v8_unbound_script_get_local(php_v8_unbound_script);
+    v8::Local<v8::String> local_source_string = php_v8_value_get_local_as<v8::String>(php_v8_source_string);
+
+    v8::ScriptCompiler::CachedData* cached_data = v8::ScriptCompiler::CreateCodeCache(local_unbound_script, local_source_string);
+
+    if (!cached_data) {
+        PHP_V8_THROW_VALUE_EXCEPTION("Failed to create code cache");
+        return;
+    }
+
+    php_v8_create_cached_data(return_value, cached_data);
+}
+
 
 PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_getCachedDataVersionTag, ZEND_RETURN_VALUE, 0, IS_DOUBLE, 0)
 ZEND_END_ARG_INFO()
@@ -291,12 +324,18 @@ PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_compileFunctionInContext,
                 ZEND_ARG_TYPE_INFO(0, context_extensions, IS_ARRAY, 0)
 ZEND_END_ARG_INFO()
 
+PHP_V8_ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_createCodeCache, ZEND_RETURN_VALUE, 2, V8\\ScriptCompiler\\CachedData, 0)
+                ZEND_ARG_OBJ_INFO(0, unbound_script, V8\\UnboundScript, 0)
+                ZEND_ARG_OBJ_INFO(0, source_string, V8\\StringValue, 0)
+ZEND_END_ARG_INFO()
+
 
 static const zend_function_entry php_v8_script_compiler_methods[] = {
     PHP_V8_ME(ScriptCompiler, getCachedDataVersionTag,  ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
     PHP_V8_ME(ScriptCompiler, compileUnboundScript,     ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
     PHP_V8_ME(ScriptCompiler, compile,                  ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
     PHP_V8_ME(ScriptCompiler, compileFunctionInContext, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
+    PHP_V8_ME(ScriptCompiler, createCodeCache,          ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
 
     PHP_FE_END
 };
@@ -315,6 +354,7 @@ PHP_MINIT_FUNCTION(php_v8_script_compiler)
     zend_declare_class_constant_long(this_ce, ZEND_STRL("OPTION_PRODUCE_CODE_CACHE"),      static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kProduceCodeCache));
     zend_declare_class_constant_long(this_ce, ZEND_STRL("OPTION_PRODUCE_FULL_CODE_CACHE"), static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kProduceFullCodeCache));
     zend_declare_class_constant_long(this_ce, ZEND_STRL("OPTION_CONSUME_CODE_CACHE"),      static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kConsumeCodeCache));
+    zend_declare_class_constant_long(this_ce, ZEND_STRL("OPTION_EAGER_COMPILE"),           static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kEagerCompile));
 
     return SUCCESS;
 }

src/php_v8_script_compiler.h

@@ -27,8 +27,8 @@ extern "C" {
 extern zend_class_entry *php_v8_script_compiler_class_entry;
 
 #define PHP_V8_CHECK_COMPILER_OPTIONS_RANGE(options, message) \
-    if (options < static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kNoCompileOptions) \
-         || options > static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kConsumeCodeCache)) { \
+    if ((options) < static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kNoCompileOptions) \
+        || (options) > static_cast<zend_long>(v8::ScriptCompiler::CompileOptions::kEagerCompile)) { \
         PHP_V8_THROW_VALUE_EXCEPTION(message); \
         return; \
     }

stubs/src/HeapStatistics.php

@@ -60,6 +60,14 @@ class  HeapStatistics
      * @var bool
      */
     private $does_zap_garbage;
+    /**
+     * @var float
+     */
+    private $number_of_native_contexts;
+    /**
+     * @var float
+     */
+    private $number_of_detached_contexts;
 
     /**
      * @param float $total_heap_size
@@ -69,7 +77,10 @@ class  HeapStatistics
      * @param float $used_heap_size
      * @param float $heap_size_limit
      * @param float $malloced_memory
+     * @param float $peak_malloced_memory
      * @param bool  $does_zap_garbage
+     * @param float $number_of_native_contexts
+     * @param float $number_of_detached_contexts
      */
     public function __construct(
         float $total_heap_size,
@@ -80,17 +91,21 @@ public function __construct(
         float $heap_size_limit,
         float $malloced_memory,
         float $peak_malloced_memory,
-        bool $does_zap_garbage
+        bool $does_zap_garbage,
+        float $number_of_native_contexts,
+        float $number_of_detached_contexts
     ) {
-        $this->total_heap_size            = $total_heap_size;
-        $this->total_heap_size_executable = $total_heap_size_executable;
-        $this->total_physical_size        = $total_physical_size;
-        $this->total_available_size       = $total_available_size;
-        $this->used_heap_size             = $used_heap_size;
-        $this->heap_size_limit            = $heap_size_limit;
-        $this->malloced_memory            = $malloced_memory;
-        $this->peak_malloced_memory       = $peak_malloced_memory;
-        $this->does_zap_garbage           = $does_zap_garbage;
+        $this->total_heap_size             = $total_heap_size;
+        $this->total_heap_size_executable  = $total_heap_size_executable;
+        $this->total_physical_size         = $total_physical_size;
+        $this->total_available_size        = $total_available_size;
+        $this->used_heap_size              = $used_heap_size;
+        $this->heap_size_limit             = $heap_size_limit;
+        $this->malloced_memory             = $malloced_memory;
+        $this->peak_malloced_memory        = $peak_malloced_memory;
+        $this->does_zap_garbage            = $does_zap_garbage;
+        $this->number_of_native_contexts   = $number_of_native_contexts;
+        $this->number_of_detached_contexts = $number_of_detached_contexts;
     }
 
     /**
@@ -166,4 +181,22 @@ public function doesZapGarbage(): bool
     {
         return $this->does_zap_garbage;
     }
+
+    /**
+     * The total number of native contexts object on the heap
+     * @return float
+     */
+    public function getNumberOfNativeContexts(): float
+    {
+        return $this->number_of_native_contexts;
+    }
+
+    /**
+     * The total number of native contexts that were detached but were not garbage collected yet
+     * @return float
+     */
+    public function getNumberOfDetachedContexts(): float
+    {
+        return $this->number_of_detached_contexts;
+    }
 }