Changeset 311

Timestamp:

12/09/2006 04:27:03 PM (2 years ago)

Author:

moo

Message:

restruct cached compile, add md5 table to recognize and merge file with same content

Location:

trunk

Files:

• graph (added)
• graph/cached_compile.dot (added)
• processor/dispatch.m4 (modified) (1 diff)
• processor/head.m4 (modified) (11 diffs)
• processor/main.m4 (modified) (2 diffs)
• processor/processor.m4 (modified) (7 diffs)
• xcache.c (modified) (33 diffs)
• xcache.h (modified) (6 diffs)

trunk/processor/dispatch.m4

@@ -23 +23 @@
     , `$1', `xc_entry_type_t',  `PROC_INT(`$2', `d',  `$1')'
     , `$1', `xc_hash_value_t',  `PROC_INT(`$2', `lu', `$1')'
+    , `$1', `xc_md5sum_t',      `/* is copying enough? */COPY(`$2')'
     , `', `', `m4_errprint(`Unknown type "$1"')'
     )

trunk/processor/head.m4

@@ -65 +65 @@
     zend_bool reference; /* enable if to deal with reference */
     zend_bool have_references;
-    const xc_entry_t *xce_src;
-    const xc_entry_t *xce_dst;
+    const xc_entry_data_php_t *php_src;
+    const xc_entry_data_php_t *php_dst;
+    const xc_cache_t          *cache;
     const zend_class_entry *cache_ce;
     zend_uint cache_class_num;
@@ -186 +187 @@
 static zend_ulong xc_get_class_num(xc_processor_t *processor, zend_class_entry *ce) {
     zend_ulong i;
-    const xc_entry_t *xce = processor->xce_src;
+    const xc_entry_data_php_t *php = processor->php_src;
     zend_class_entry *ceptr;
 
@@ -192 +193 @@
         return processor->cache_class_num;
     }
-    for (i = 0; i < xce->data.php->classinfo_cnt; i ++) {
-        ceptr = CestToCePtr(xce->data.php->classinfos[i].cest);
+    for (i = 0; i < php->classinfo_cnt; i ++) {
+        ceptr = CestToCePtr(php->classinfos[i].cest);
         if (ZCEP_REFCOUNT_PTR(ceptr) == ZCEP_REFCOUNT_PTR(ce)) {
             processor->cache_ce = ceptr;
@@ -209 +210 @@
     /* must be parent or currrent class */
     assert(class_num <= processor->active_class_num);
-    return CestToCePtr(processor->xce_dst->data.php->classinfos[class_num - 1].cest);
+    return CestToCePtr(processor->php_dst->classinfos[class_num - 1].cest);
 }
 #endif
@@ -275 +276 @@
 /* }}} */
 dnl ================ export API
-/* export: xc_entry_t *xc_processor_store_xc_entry_t(xc_entry_t *src TSRMLS_DC); :export {{{ */
-xc_entry_t *xc_processor_store_xc_entry_t(xc_entry_t *src TSRMLS_DC) {
-    xc_entry_t *dst;
+define(`DEFINE_STORE_API', `
+/* export: $1 *xc_processor_store_$1($1 *src TSRMLS_DC); :export {{{ */
+$1 *xc_processor_store_$1($1 *src TSRMLS_DC) {
+    $1 *dst;
     xc_processor_t processor;
 
     memset(&processor, 0, sizeof(processor));
     processor.reference = 1;
+    processor.cache = src->cache;
 
     IFASSERT(`xc_stack_init(&processor.allocsizes);')
@@ -295 +298 @@
         processor.size = ALIGN(processor.size + sizeof(src[0]));
 
-        xc_calc_xc_entry_t(&processor, src TSRMLS_CC);
+        xc_calc_$1(&processor, src TSRMLS_CC);
         if (processor.reference) {
             zend_hash_destroy(&processor.zvalptrs);
@@ -302 +305 @@
     }
     src->size = processor.size;
-    src->have_references = processor.have_references;
+    ifelse(`$1', `xc_entry_t', `
+        src->data.var->have_references = processor.have_references;
+    ', `
+        src->have_references = processor.have_references;
+    ')
 
     IFASSERT(`xc_stack_reverse(&processor.allocsizes);')
@@ -314 +321 @@
 
         /* mem :) */
-        processor.p = (char *) src->cache->mem->handlers->malloc(src->cache->mem, processor.size);
+        processor.p = (char *) processor.cache->mem->handlers->malloc(processor.cache->mem, processor.size);
         if (processor.p == NULL) {
             dst = NULL;
@@ -323 +330 @@
 
         /* allocate */
-        dst = (xc_entry_t *) processor.p;
+        dst = ($1 *) processor.p;
         processor.p = (char *) ALIGN(processor.p + sizeof(dst[0]));
 
-        xc_store_xc_entry_t(&processor, dst, src TSRMLS_CC);
+        xc_store_$1(&processor, dst, src TSRMLS_CC);
         IFASSERT(` {
             int real = processor.p - oldp;
@@ -348 +355 @@
 }
 /* }}} */
-/* export: xc_entry_t *xc_processor_restore_xc_entry_t(xc_entry_t *dst, const xc_entry_t *src, zend_bool readonly_protection TSRMLS_DC); :export {{{ */
-xc_entry_t *xc_processor_restore_xc_entry_t(xc_entry_t *dst, const xc_entry_t *src, zend_bool readonly_protection TSRMLS_DC) {
+')
+DEFINE_STORE_API(`xc_entry_t')
+DEFINE_STORE_API(`xc_entry_data_php_t')
+/* export: xc_entry_t *xc_processor_restore_xc_entry_t(xc_entry_t *dst, const xc_entry_t *src TSRMLS_DC); :export {{{ */
+xc_entry_t *xc_processor_restore_xc_entry_t(xc_entry_t *dst, const xc_entry_t *src TSRMLS_DC) {
+    xc_processor_t processor;
+
+    memset(&processor, 0, sizeof(processor));
+    xc_restore_xc_entry_t(&processor, dst, src TSRMLS_CC);
+
+    return dst;
+}
+/* }}} */
+/* export: xc_entry_data_php_t *xc_processor_restore_xc_entry_data_php_t(xc_entry_data_php_t *dst, const xc_entry_data_php_t *src, zend_bool readonly_protection TSRMLS_DC); :export {{{ */
+xc_entry_data_php_t *xc_processor_restore_xc_entry_data_php_t(xc_entry_data_php_t *dst, const xc_entry_data_php_t *src, zend_bool readonly_protection TSRMLS_DC) {
     xc_processor_t processor;
 
     memset(&processor, 0, sizeof(processor));
     processor.readonly_protection = readonly_protection;
+    /* this function is used for php data only */
     if (src->have_references) {
         processor.reference = 1;
@@ -361 +382 @@
         zend_hash_init(&processor.zvalptrs, 0, NULL, NULL, 0);
     }
-    xc_restore_xc_entry_t(&processor, dst, src TSRMLS_CC);
+    xc_restore_xc_entry_data_php_t(&processor, dst, src TSRMLS_CC);
     if (processor.reference) {
         zend_hash_destroy(&processor.zvalptrs);

trunk/processor/main.m4

@@ -136 +136 @@
 define(`FIXPOINTER', `FIXPOINTER_EX(`$1', `dst->$2')')
 define(`FIXPOINTER_EX', `IFSTORE(`
-    $2 = ($1 *) processor->xce_src->cache->shm->handlers->to_readonly(processor->xce_src->cache->shm, (char *)$2);
+    $2 = ($1 *) processor->cache->shm->handlers->to_readonly(processor->cache->shm, (char *)$2);
 ')')
 define(`UNFIXPOINTER', `UNFIXPOINTER_EX(`$1', `dst->$2')')
 define(`UNFIXPOINTER_EX', `IFSTORE(`
-    $2 = ($1 *) processor->xce_src->cache->shm->handlers->to_readwrite(processor->xce_src->cache->shm, (char *)$2);
+    $2 = ($1 *) processor->cache->shm->handlers->to_readwrite(processor->cache->shm, (char *)$2);
 ')')
 dnl }}}
 dnl {{{ COPY
 define(`COPY', `IFNOTMEMCPY(`IFCOPY(`dst->$1 = src->$1;')')DONE(`$1')')
+dnl }}}
+dnl {{{ COPYPOINTER
+define(`COPYPOINTER', `COPY(`$1')')
+dnl }}}
+dnl {{{ COPYARRAY
+define(`COPYARRAY', `IFNOTMEMCPY(`IFCOPY(`memcpy(dst->$1, src->$1, sizeof(dst->$1));')')DONE(`$1')')
 dnl }}}
 dnl {{{ SETNULL_EX
@@ -223 +229 @@
 EXPORT(`xc_funcinfo_t')
 EXPORT(`xc_entry_t')
+EXPORT(`xc_entry_data_php_t')
 EXPORT(`zval')
 

trunk/processor/processor.m4

@@ -479 +479 @@
     dnl readonly_protection=on
     dnl main op_array && have early binding
-    if (!processor->readonly_protection && !(src == processor->xce_src->data.php->op_array && processor->xce_src->data.php->have_early_binding)) {
+    if (!processor->readonly_protection && !(src == processor->php_src->op_array && processor->php_src->have_early_binding)) {
         /* really fast shallow copy */
         memcpy(dst, src, sizeof(src[0]));
@@ -719 +719 @@
     zend_uint i;
 
-#ifdef HAVE_INODE
-    DISPATCH(int, device)
-    DISPATCH(int, inode)
-#endif
+    IFCOPY(`
+        processor->php_dst = dst;
+        processor->php_src = src;
+    ')
+
+    DISPATCH(xc_hash_value_t, hvalue)
+    /* skip */
+    DONE(next)
+    COPY(cache)
+    DISPATCH(xc_md5sum_t, md5)
+    DISPATCH(zend_ulong, refcount)
+
     DISPATCH(size_t, sourcesize)
-
-    DISPATCH(time_t, mtime)
+    DISPATCH(zend_ulong, hits)
+    DISPATCH(size_t, size)
 
     STRUCT_P(zend_op_array, op_array)
@@ -750 +758 @@
     DISPATCH(zend_bool, have_early_binding)
     popdef(`BEFORE_LOOP')
+    DISPATCH(zend_bool, have_references)
 ')
 dnl }}}
@@ -755 +764 @@
     IFDPRINT(`INDENT()`'fprintf(stderr, "zval:value");')
     STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
+    DISPATCH(zend_bool, have_references)
     DONE(value)
 ')
@@ -760 +770 @@
 dnl {{{ xc_entry_t
 DEF_STRUCT_P_FUNC(`xc_entry_t', , `
-    IFCOPY(`
-        processor->xce_dst = dst;
-        processor->xce_src = src;
-    ')
     DISPATCH(xc_entry_type_t, type)
     DISPATCH(size_t, size)
@@ -809 +815 @@
         switch (src->type) {
         case XC_TYPE_PHP:
-            STRUCT_P(xc_entry_data_php_t, data.php)
+            IFCALCCOPY(`DONE(data.php)', `STRUCT_P(xc_entry_data_php_t, data.php)')
             break;
+
         case XC_TYPE_VAR:
             STRUCT_P(xc_entry_data_var_t, data.var)
             break;
+
         default:
             assert(0);
@@ -820 +828 @@
     DONE(data)
     dnl }}}
-    DISPATCH(zend_bool, have_references)
+    DISPATCH(time_t, mtime)
+#ifdef HAVE_INODE
+    DISPATCH(int, device)
+    DISPATCH(int, inode)
+#endif
 ')
 dnl }}}

trunk/xcache.c

@@ -106 +106 @@
 /* any function in *_dmz is only safe be called within locked(single thread) area */
 
+static void xc_php_add_dmz(xc_entry_data_php_t *php) /* {{{ */
+{
+    xc_entry_data_php_t **head = &(php->cache->phps[php->hvalue]);
+    php->next = *head;
+    *head = php;
+    php->cache->phps_count ++;
+}
+/* }}} */
+static xc_entry_data_php_t *xc_php_store_dmz(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
+{
+    xc_entry_data_php_t *stored_php;
+
+    php->hits     = 0;
+    php->refcount = 0;
+    stored_php = xc_processor_store_xc_entry_data_php_t(php TSRMLS_CC);
+    if (stored_php) {
+        xc_php_add_dmz(stored_php);
+        return stored_php;
+    }
+    else {
+        php->cache->ooms ++;
+        return NULL;
+    }
+}
+/* }}} */
+static xc_entry_data_php_t *xc_php_find_dmz(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
+{
+    xc_entry_data_php_t *p;
+    for (p = php->cache->phps[php->hvalue]; p; p = p->next) {
+        if (memcmp(php->md5, p->md5, sizeof(php->md5)) == 0) {
+            p->hits ++;
+            return p;
+        }
+    }
+    return NULL;
+}
+/* }}} */
+static void xc_php_free_dmz(xc_entry_data_php_t *php) /* {{{ */
+{
+    php->cache->mem->handlers->free(php->cache->mem, (xc_entry_data_php_t *)php);
+}
+/* }}} */
+static void xc_php_remove_dmz(xc_entry_data_php_t *php) /* {{{ */
+{
+    if (-- php->refcount == 0) {
+        xc_entry_data_php_t **pp = &(php->cache->phps[php->hvalue]);
+        xc_entry_data_php_t *p;
+        for (p = *pp; p; pp = &(p->next), p = p->next) {
+            if (memcmp(php->md5, p->md5, sizeof(php->md5)) == 0) {
+                /* unlink */
+                *pp = p->next;
+                xc_php_free_dmz(php);
+                return;
+            }
+        }
+        assert(0);
+    }
+}
+/* }}} */
+
 static inline int xc_entry_equal_dmz(xc_entry_t *a, xc_entry_t *b) /* {{{ */
 {
@@ -117 +177 @@
 #ifdef HAVE_INODE
             do {
-                xc_entry_data_php_t *ap = a->data.php;
-                xc_entry_data_php_t *bp = b->data.php;
-                if (ap->inode) {
-                    return ap->inode == bp->inode
-                        && ap->device == bp->device;
+                if (a->inode) {
+                    return a->inode == b->inode
+                        && a->device == b->device;
                 }
             } while(0);
@@ -150 +208 @@
 }
 /* }}} */
-static void xc_entry_free_real_dmz(volatile xc_entry_t *xce) /* {{{ */
-{
-    xce->cache->mem->handlers->free(xce->cache->mem, (xc_entry_t *)xce);
-}
-/* }}} */
 static void xc_entry_add_dmz(xc_entry_t *xce) /* {{{ */
 {
@@ -179 +232 @@
         return NULL;
     }
+}
+/* }}} */
+static void xc_entry_free_real_dmz(volatile xc_entry_t *xce) /* {{{ */
+{
+    if (xce->type == XC_TYPE_PHP) {
+        xc_php_remove_dmz(xce->data.php);
+    }
+    xce->cache->mem->handlers->free(xce->cache->mem, (xc_entry_t *)xce);
 }
 /* }}} */
@@ -216 +277 @@
     for (p = xce->cache->entries[xce->hvalue]; p; p = p->next) {
         if (xc_entry_equal_dmz(xce, p)) {
-            if (p->type == XC_TYPE_VAR || /* PHP */ p->data.php->mtime == xce->data.php->mtime) {
+            if (p->type == XC_TYPE_VAR || /* PHP */ p->mtime == xce->mtime) {
                 p->hits ++;
                 p->atime = XG(request_time);
@@ -474 +535 @@
             add_assoc_long_ex(ei, ZEND_STRS("sourcesize"),    php->sourcesize);
 #ifdef HAVE_INODE
-            add_assoc_long_ex(ei, ZEND_STRS("device"),        php->device);
-            add_assoc_long_ex(ei, ZEND_STRS("inode"),         php->inode);
-#endif
-            add_assoc_long_ex(ei, ZEND_STRS("mtime"),         php->mtime);
+            add_assoc_long_ex(ei, ZEND_STRS("device"),        entry->device);
+            add_assoc_long_ex(ei, ZEND_STRS("inode"),         entry->inode);
+#endif
+            add_assoc_long_ex(ei, ZEND_STRS("mtime"),         entry->mtime);
 
 #ifdef HAVE_XCACHE_CONSTANT
@@ -644 +705 @@
         if (VCWD_STAT(filepath, pbuf) == 0) {
             free_alloca(paths);
-            return 0;
+            return FAILURE;
         }
     }
@@ -650 +711 @@
     free_alloca(paths);
 
-    return 1;
+    return SUCCESS;
 }
 /* }}} */
@@ -656 +717 @@
 #define HASH(i) (i)
 #define HASH_USTR_L(t, s, l) HASH(zend_u_inline_hash_func(t, s, (l + 1) * sizeof(UChar)))
-#define HASH_STR_L(s, l) HASH(zend_inline_hash_func(s, l + 1))
+#define HASH_STR_S(s, l) HASH(zend_inline_hash_func(s, l))
+#define HASH_STR_L(s, l) HASH_STR_S(s, l + 1)
 #define HASH_STR(s) HASH_STR_L(s, strlen(s) + 1)
 #define HASH_NUM(n) HASH(n)
@@ -669 +731 @@
 {
 #ifdef HAVE_INODE
-    if (xce->data.php->inode) {
-        return HASH(xce->data.php->device + xce->data.php->inode);
+    if (xce->inode) {
+        return HASH(xce->device + xce->inode);
     }
 #endif
@@ -685 +747 @@
 
     if (!filename || !SG(request_info).path_translated) {
-        return 0;
+        return FAILURE;
     }
 
@@ -703 +765 @@
         if (IS_ABSOLUTE_PATH(filename, strlen(filename))) {
             if (VCWD_STAT(filename, pbuf) != 0) {
-                return 0;
+                return FAILURE;
             }
             goto stat_done;
@@ -719 +781 @@
 
             if (VCWD_STAT(filename, pbuf) != 0) {
-                return 0;
+                return FAILURE;
             }
             goto stat_done;
@@ -726 +788 @@
 
         /* use include_path */
-        if (xc_stat(filename, PG(include_path), pbuf TSRMLS_CC) != 0) {   
-            return 0;
+        if (xc_stat(filename, PG(include_path), pbuf TSRMLS_CC) != SUCCESS) {
+            return FAILURE;
         }
 
@@ -734 +796 @@
 stat_done:
         if (XG(request_time) - pbuf->st_mtime < 2 && !xc_test) {
-            return 0;
-        }
-
-        php->mtime        = pbuf->st_mtime;
+            return FAILURE;
+        }
+
+        xce->mtime        = pbuf->st_mtime;
 #ifdef HAVE_INODE
-        php->device       = pbuf->st_dev;
-        php->inode        = pbuf->st_ino;
+        xce->device       = pbuf->st_dev;
+        xce->inode        = pbuf->st_ino;
 #endif
         php->sourcesize   = pbuf->st_size;
     }
     else { /* XG(inode) */
-        php->mtime        = 0;
+        xce->mtime        = 0;
 #ifdef HAVE_INODE
-        php->device       = 0;
-        php->inode        = 0;
+        xce->device       = 0;
+        xce->inode        = 0;
 #endif
         php->sourcesize   = 0;
@@ -754 +816 @@
 
 #ifdef HAVE_INODE
-    if (!php->inode)
+    if (!xce->inode)
 #endif
     {
@@ -760 +822 @@
         filename = expand_filepath(filename, opened_path_buffer TSRMLS_CC);
         if (filename == NULL) {
-            return 0;
+            return FAILURE;
         }
     }
@@ -775 +837 @@
 
     xce->type = XC_TYPE_PHP;
-    return 1;
+    return SUCCESS;
+}
+/* }}} */
+static inline xc_hash_value_t xc_php_hash_md5(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
+{
+    return HASH_STR_S(php->md5, sizeof(php->md5));
+}
+/* }}} */
+static int xc_entry_init_key_php_md5(xc_entry_data_php_t *php, xc_entry_t *xce TSRMLS_DC) /* {{{ */
+{
+    unsigned char   buf[1024];
+    PHP_MD5_CTX     context;
+    int             n;
+    php_stream     *stream;
+    xc_hash_value_t hv;
+
+    stream = php_stream_open_wrapper(xce->name.str.val, "rb", REPORT_ERRORS | ENFORCE_SAFE_MODE, NULL);
+    if (!stream) {
+        return FAILURE;
+    }
+
+    PHP_MD5Init(&context);
+    while ((n = php_stream_read(stream, (char *) buf, sizeof(buf))) > 0) {
+        PHP_MD5Update(&context, buf, n);
+    }
+    PHP_MD5Final((unsigned char *) php->md5, &context);
+
+    php_stream_close(stream);
+
+    if (n < 0) {
+        return FAILURE;
+    }
+
+    hv = xc_php_hash_md5(php TSRMLS_CC);
+    php->cache  = xce->cache;
+    php->hvalue = (hv & php->cache->hphp->mask);
+#ifdef DEBUG
+    {
+        char md5str[33];
+        make_digest(md5str, (unsigned char *) php->md5);
+        TRACE("md5 %s", md5str);
+    }
+#endif
+
+    return SUCCESS;
 }
 /* }}} */
@@ -805 +911 @@
 }
 /* }}} */
-static zend_op_array *xc_compile_file(zend_file_handle *h, int type TSRMLS_DC) /* {{{ */
-{
-    xc_sandbox_t sandbox;
+static void xc_free_php(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
+{
+#define X_FREE(var) do {\
+    if (php->var) { \
+        efree(php->var); \
+    } \
+} while (0)
+
+#ifdef ZEND_ENGINE_2_1
+    X_FREE(autoglobals);
+#endif
+    X_FREE(classinfos);
+    X_FREE(funcinfos);
+#ifdef HAVE_XCACHE_CONSTANT
+    X_FREE(constinfos);
+#endif
+#undef X_FREE
+}
+/* }}} */
+static zend_op_array *xc_compile_php(xc_entry_data_php_t *php, zend_file_handle *h, int type TSRMLS_DC) /* {{{ */
+{
     zend_op_array *op_array;
-    xc_entry_t xce, *stored_xce;
-    xc_entry_data_php_t php;
-    xc_cache_t *cache;
-    zend_bool clogged = 0;
-    zend_bool catched = 0;
-    char *filename;
-    char opened_path_buffer[MAXPATHLEN];
     int old_constinfo_cnt, old_funcinfo_cnt, old_classinfo_cnt;
     int i;
-
-    if (!xc_initized) {
-        assert(0);
-    }
-
-    if (!XG(cacher)) {
-        op_array = origin_compile_file(h, type TSRMLS_CC);
-#ifdef HAVE_XCACHE_OPTIMIZER
-        if (XG(optimizer)) {
-            xc_optimize(op_array TSRMLS_CC);
-        }
-#endif
-        return op_array;
-    }
-
-    /* {{{ prepare key
-     * include_once() and require_once() gives us opened_path
-     * however, include() and require() non-absolute path which break
-     * included_files, and may confuse with (include|require)_once
-     * -- Xuefer
-     */
-
-    filename = h->opened_path ? h->opened_path : h->filename;
-    xce.data.php = &php;
-    if (!xc_entry_init_key_php(&xce, filename, opened_path_buffer TSRMLS_CC)) {
-        return origin_compile_file(h, type TSRMLS_CC);
-    }
-    cache = xce.cache;
-    /* }}} */
-    /* {{{ restore */
-    /* stale precheck */
-    if (cache->compiling) {
-        cache->clogs ++; /* is it safe here? */
-        return origin_compile_file(h, type TSRMLS_CC);
-    }
-
-    stored_xce = NULL;
-    op_array = NULL;
-    ENTER_LOCK_EX(cache) {
-        /* clogged */
-        if (cache->compiling) {
-            cache->clogs ++;
-            op_array = NULL;
-            clogged = 1;
-            break;
-        }
-
-        stored_xce = xc_entry_find_dmz(&xce TSRMLS_CC);
-        /* found */
-        if (stored_xce) {
-            TRACE("found %s, catch it", stored_xce->name.str.val);
-            xc_entry_hold_php_dmz(stored_xce TSRMLS_CC);
-            cache->hits ++;
-            break;
-        }
-
-        cache->compiling = XG(request_time);
-        cache->misses ++;
-    } LEAVE_LOCK_EX(cache);
-
-    if (catched) {
-        cache->compiling = 0;
-        zend_bailout();
-    }
-
-    /* found */
-    if (stored_xce) {
-        goto restore;
-    }
-
-    /* clogged */
-    if (clogged) {
-        return origin_compile_file(h, type TSRMLS_CC);
-    }
-    /* }}} */
+    zend_bool catched = 0;
 
     /* {{{ compile */
-    TRACE("compiling %s", filename);
-
-    /* make compile inside sandbox */
-    xc_sandbox_init(&sandbox, filename TSRMLS_CC);
+    TRACE("compiling %s", h->opened_path ? h->opened_path : h->filename);
 
     old_classinfo_cnt = zend_hash_num_elements(CG(class_table));
@@ -915 +955 @@
 
     if (op_array == NULL) {
-        goto err_oparray;