Changeset 1062 for trunk/mod_cacher/xc_cacher.c

Timestamp:

2012-07-27T17:10:17+02:00 (10 months ago)

Author:

moo

Message:

const some mem handlers
split non-shared data from shm
make editor goto file correctly

Location:

trunk

Files:

• . (modified) (1 prop)
• mod_cacher/xc_cacher.c (modified) (58 diffs)

trunk

@@ -18 +18 @@
 devel.ini
 devel.php
+devel.fpm
 .gdb_history
 include

@@ -18 +18 @@
 devel.ini
 devel.php
+devel.fpm
 .gdb_history
 include

trunk/mod_cacher/xc_cacher.c

@@ -59 +59 @@
 /* }}} */
 
-/* {{{ types */
-struct _xc_hash_t {
+struct _xc_hash_t { /* {{{ */
     size_t bits;
     size_t size;
     xc_hash_value_t mask;
+};
+/* }}} */
+struct _xc_cached_t { /* {{{ stored in shm */
+    int cacheid;
+
+    time_t     compiling;
+    zend_ulong updates;
+    zend_ulong hits;
+    zend_ulong clogs;
+    zend_ulong ooms;
+    zend_ulong errors;
+
+    xc_entry_t **entries;
+    int entries_count;
+    xc_entry_data_php_t **phps;
+    int phps_count;
+    xc_entry_t *deletes;
+    int deletes_count;
+
+    time_t     last_gc_deletes;
+    time_t     last_gc_expires;
+
+    time_t     hits_by_hour_cur_time;
+    zend_uint  hits_by_hour_cur_slot;
+    zend_ulong hits_by_hour[24];
+    time_t     hits_by_second_cur_time;
+    zend_uint  hits_by_second_cur_slot;
+    zend_ulong hits_by_second[5];
 };
 /* }}} */
@@ -88 +115 @@
 static zend_ulong xc_var_size  = 0;
 
-static xc_cache_t **xc_php_caches = NULL;
-static xc_cache_t **xc_var_caches = NULL;
+static xc_cache_t *xc_php_caches = NULL;
+static xc_cache_t *xc_var_caches = NULL;
 
 static zend_bool xc_initized = 0;
@@ -114 +141 @@
 /* any function in *_unlocked is only safe be called within locked (single thread access) area */
 
-static void xc_php_add_unlocked(xc_cache_t *cache, xc_entry_data_php_t *php) /* {{{ */
-{
-    xc_entry_data_php_t **head = &(cache->phps[php->hvalue]);
+static void xc_php_add_unlocked(xc_cached_t *cached, xc_entry_data_php_t *php) /* {{{ */
+{
+    xc_entry_data_php_t **head = &(cached->phps[php->hvalue]);
     php->next = *head;
     *head = php;
-    cache->phps_count ++;
+    cached->phps_count ++;
 }
 /* }}} */
@@ -130 +157 @@
     stored_php = xc_processor_store_xc_entry_data_php_t(cache, php TSRMLS_CC);
     if (stored_php) {
-        xc_php_add_unlocked(cache, stored_php);
+        xc_php_add_unlocked(cache->cached, stored_php);
         return stored_php;
     }
     else {
-        cache->ooms ++;
+        cache->cached->ooms ++;
         return NULL;
     }
 }
 /* }}} */
-static xc_entry_data_php_t *xc_php_find_unlocked(xc_cache_t *cache, xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
+static xc_entry_data_php_t *xc_php_find_unlocked(xc_cached_t *cached, xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */
 {
     xc_entry_data_php_t *p;
-    for (p = cache->phps[php->hvalue]; p; p = (xc_entry_data_php_t *) p->next) {
+    for (p = cached->phps[php->hvalue]; p; p = (xc_entry_data_php_t *) p->next) {
         if (memcmp(&php->md5.digest, &p->md5.digest, sizeof(php->md5.digest)) == 0) {
             p->hits ++;
@@ -164 +191 @@
 {
     if (-- php->refcount == 0) {
-        xc_entry_data_php_t **pp = &(cache->phps[php->hvalue]);
+        xc_entry_data_php_t **pp = &(cache->cached->phps[php->hvalue]);
         xc_entry_data_php_t *p;
         for (p = *pp; p; pp = &(p->next), p = p->next) {
@@ -259 +286 @@
 }
 /* }}} */
-static void xc_entry_add_unlocked(xc_cache_t *cache, xc_hash_value_t entryslotid, xc_entry_t *entry) /* {{{ */
-{
-    xc_entry_t **head = &(cache->entries[entryslotid]);
+static void xc_entry_add_unlocked(xc_cached_t *cached, xc_hash_value_t entryslotid, xc_entry_t *entry) /* {{{ */
+{
+    xc_entry_t **head = &(cached->entries[entryslotid]);
     entry->next = *head;
     *head = entry;
-    cache->entries_count ++;
+    cached->entries_count ++;
 }
 /* }}} */
@@ -278 +305 @@
         : (xc_entry_t *) xc_processor_store_xc_entry_var_t(cache, (xc_entry_var_t *) entry TSRMLS_CC);
     if (stored_entry) {
-        xc_entry_add_unlocked(cache, entryslotid, stored_entry);
-        ++cache->updates;
+        xc_entry_add_unlocked(cache->cached, entryslotid, stored_entry);
+        ++cache->cached->updates;
         return stored_entry;
     }
     else {
-        cache->ooms ++;
+        cache->cached->ooms ++;
         return NULL;
     }
@@ -308 +335 @@
 static void xc_entry_free_unlocked(xc_entry_type_t type, xc_cache_t *cache, xc_entry_t *entry TSRMLS_DC) /* {{{ */
 {
-    cache->entries_count --;
+    cache->cached->entries_count --;
     if ((type == XC_TYPE_PHP ? ((xc_entry_php_t *) entry)->refcount : 0) == 0) {
         xc_entry_free_real_unlocked(type, cache, entry);
     }
     else {
-        entry->next = cache->deletes;
-        cache->deletes = entry;
+        entry->next = cache->cached->deletes;
+        cache->cached->deletes = entry;
         entry->dtime = XG(request_time);
-        cache->deletes_count ++;
+        cache->cached->deletes_count ++;
     }
     return;
@@ -323 +350 @@
 static void xc_entry_remove_unlocked(xc_entry_type_t type, xc_cache_t *cache, xc_hash_value_t entryslotid, xc_entry_t *entry TSRMLS_DC) /* {{{ */
 {
-    xc_entry_t **pp = &(cache->entries[entryslotid]);
+    xc_entry_t **pp = &(cache->cached->entries[entryslotid]);
     xc_entry_t *p;
     for (p = *pp; p; pp = &(p->next), p = p->next) {
@@ -339 +366 @@
 {
     xc_entry_t *p;
-    for (p = cache->entries[entryslotid]; p; p = p->next) {
+    for (p = cache->cached->entries[entryslotid]; p; p = p->next) {
         if (xc_entry_equal_unlocked(type, entry, p TSRMLS_CC)) {
             zend_bool fresh;
@@ -407 +434 @@
 }
 /* }}} */
-static inline void xc_cache_hit_unlocked(xc_cache_t *cache TSRMLS_DC) /* {{{ */
-{
-    cache->hits ++;
-
-    xc_counters_inc(&cache->hits_by_hour_cur_time
-            , &cache->hits_by_hour_cur_slot, 60 * 60
-            , cache->hits_by_hour
-            , sizeof(cache->hits_by_hour) / sizeof(cache->hits_by_hour[0])
+static inline void xc_cached_hit_unlocked(xc_cached_t *cached TSRMLS_DC) /* {{{ */
+{
+    cached->hits ++;
+
+    xc_counters_inc(&cached->hits_by_hour_cur_time
+            , &cached->hits_by_hour_cur_slot, 60 * 60
+            , cached->hits_by_hour
+            , sizeof(cached->hits_by_hour) / sizeof(cached->hits_by_hour[0])
             TSRMLS_CC);
 
-    xc_counters_inc(&cache->hits_by_second_cur_time
-            , &cache->hits_by_second_cur_slot, 1
-            , cache->hits_by_second
-            , sizeof(cache->hits_by_second) / sizeof(cache->hits_by_second[0])
+    xc_counters_inc(&cached->hits_by_second_cur_time
+            , &cached->hits_by_second_cur_slot, 1
+            , cached->hits_by_second
+            , sizeof(cached->hits_by_second) / sizeof(cached->hits_by_second[0])
             TSRMLS_CC);
 }
@@ -434 +461 @@
 
     for (i = 0, c = cache->hentry->size; i < c; i ++) {
-        pp = &(cache->entries[i]);
+        pp = &(cache->cached->entries[i]);
         for (p = *pp; p; p = *pp) {
             if (apply_func(p TSRMLS_CC)) {
@@ -473 +500 @@
 static void xc_gc_expires_one(xc_entry_type_t type, xc_cache_t *cache, zend_ulong gc_interval, cache_apply_unlocked_func_t apply_func TSRMLS_DC) /* {{{ */
 {
-    TRACE("interval %lu, %lu %lu", (zend_ulong) XG(request_time), (zend_ulong) cache->last_gc_expires, gc_interval);
-    if (XG(request_time) >= cache->last_gc_expires + (time_t) gc_interval) {
+    TRACE("interval %lu, %lu %lu", (zend_ulong) XG(request_time), (zend_ulong) cache->cached->last_gc_expires, gc_interval);
+    if (XG(request_time) >= cache->cached->last_gc_expires + (time_t) gc_interval) {
         ENTER_LOCK(cache) {
-            if (XG(request_time) >= cache->last_gc_expires + (time_t) gc_interval) {
-                cache->last_gc_expires = XG(request_time);
+            if (XG(request_time) >= cache->cached->last_gc_expires + (time_t) gc_interval) {
+                cache->cached->last_gc_expires = XG(request_time);
                 xc_entry_apply_unlocked(type, cache, apply_func TSRMLS_CC);
             }
@@ -493 +520 @@
 
     for (i = 0, c = xc_php_hcache.size; i < c; i ++) {
-        xc_gc_expires_one(XC_TYPE_PHP, xc_php_caches[i], xc_php_gc_interval, xc_gc_expires_php_entry_unlocked TSRMLS_CC);
+        xc_gc_expires_one(XC_TYPE_PHP, &xc_php_caches[i], xc_php_gc_interval, xc_gc_expires_php_entry_unlocked TSRMLS_CC);
     }
 }
@@ -506 +533 @@
 
     for (i = 0, c = xc_var_hcache.size; i < c; i ++) {
-        xc_gc_expires_one(XC_TYPE_VAR, xc_var_caches[i], xc_var_gc_interval, xc_gc_expires_var_entry_unlocked TSRMLS_CC);
+        xc_gc_expires_one(XC_TYPE_VAR, &xc_var_caches[i], xc_var_gc_interval, xc_gc_expires_var_entry_unlocked TSRMLS_CC);
     }
 }
@@ -515 +542 @@
     xc_entry_t *p, **pp;
 
-    pp = &cache->deletes;
+    pp = &cache->cached->deletes;
     for (p = *pp; p; p = *pp) {
         xc_entry_php_t *entry = (xc_entry_php_t *) p;
@@ -525 +552 @@
             /* unlink */
             *pp = p->next;
-            cache->deletes_count --;
+            cache->cached->deletes_count --;
             xc_entry_free_real_unlocked(XC_TYPE_PHP, cache, p);
         }
@@ -536 +563 @@
 static XC_CACHE_APPLY_FUNC(xc_gc_deletes_one) /* {{{ */
 {
-    if (cache->deletes && XG(request_time) - cache->last_gc_deletes > xc_deletes_gc_interval) {
+    if (cache->cached->deletes && XG(request_time) - cache->cached->last_gc_deletes > xc_deletes_gc_interval) {
         ENTER_LOCK(cache) {
-            if (cache->deletes && XG(request_time) - cache->last_gc_deletes > xc_deletes_gc_interval) {
-                cache->last_gc_deletes = XG(request_time);
+            if (cache->cached->deletes && XG(request_time) - cache->cached->last_gc_deletes > xc_deletes_gc_interval) {
+                cache->cached->last_gc_deletes = XG(request_time);
                 xc_gc_delete_unlocked(cache TSRMLS_CC);
             }
@@ -552 +579 @@
     if (xc_php_caches) {
         for (i = 0, c = xc_php_hcache.size; i < c; i ++) {
-            xc_gc_deletes_one(xc_php_caches[i] TSRMLS_CC);
+            xc_gc_deletes_one(&xc_php_caches[i] TSRMLS_CC);
         }
     }
@@ -558 +585 @@
     if (xc_var_caches) {
         for (i = 0, c = xc_var_hcache.size; i < c; i ++) {
-            xc_gc_deletes_one(xc_var_caches[i] TSRMLS_CC);
+            xc_gc_deletes_one(&xc_var_caches[i] TSRMLS_CC);
         }
     }
@@ -573 +600 @@
     xc_memsize_t avail = 0;
 #endif
-    xc_mem_t *mem = cache->mem;
+    const xc_mem_t *mem = cache->mem;
     const xc_mem_handlers_t *handlers = mem->handlers;
     zend_ulong interval;
+    const xc_cached_t *cached = cache->cached;
+
     if (cachetype == XC_TYPE_PHP) {
         interval = xc_php_ttl ? xc_php_gc_interval : 0;
@@ -584 +613 @@
 
     add_assoc_long_ex(return_value, ZEND_STRS("slots"),     cache->hentry->size);
-    add_assoc_long_ex(return_value, ZEND_STRS("compiling"), cache->compiling);
-    add_assoc_long_ex(return_value, ZEND_STRS("updates"),   cache->updates);
-    add_assoc_long_ex(return_value, ZEND_STRS("misses"),    cache->updates); /* deprecated */
-    add_assoc_long_ex(return_value, ZEND_STRS("hits"),      cache->hits);
-    add_assoc_long_ex(return_value, ZEND_STRS("clogs"),     cache->clogs);
-    add_assoc_long_ex(return_value, ZEND_STRS("ooms"),      cache->ooms);
-    add_assoc_long_ex(return_value, ZEND_STRS("errors"),    cache->errors);
-
-    add_assoc_long_ex(return_value, ZEND_STRS("cached"),    cache->entries_count);
-    add_assoc_long_ex(return_value, ZEND_STRS("deleted"),   cache->deletes_count);
+    add_assoc_long_ex(return_value, ZEND_STRS("compiling"), cached->compiling);
+    add_assoc_long_ex(return_value, ZEND_STRS("updates"),   cached->updates);
+    add_assoc_long_ex(return_value, ZEND_STRS("misses"),    cached->updates); /* deprecated */
+    add_assoc_long_ex(return_value, ZEND_STRS("hits"),      cached->hits);
+    add_assoc_long_ex(return_value, ZEND_STRS("clogs"),     cached->clogs);
+    add_assoc_long_ex(return_value, ZEND_STRS("ooms"),      cached->ooms);
+    add_assoc_long_ex(return_value, ZEND_STRS("errors"),    cached->errors);
+
+    add_assoc_long_ex(return_value, ZEND_STRS("cached"),    cached->entries_count);
+    add_assoc_long_ex(return_value, ZEND_STRS("deleted"),   cached->deletes_count);
     if (interval) {
-        time_t gc = (cache->last_gc_expires + interval) - XG(request_time);
+        time_t gc = (cached->last_gc_expires + interval) - XG(request_time);
         add_assoc_long_ex(return_value, ZEND_STRS("gc"),    gc > 0 ? gc : 0);
     }
@@ -603 +632 @@
     MAKE_STD_ZVAL(hits);
     array_init(hits);
-    for (i = 0; i < sizeof(cache->hits_by_hour) / sizeof(cache->hits_by_hour[0]); i ++) {
-        add_next_index_long(hits, (long) cache->hits_by_hour[i]);
+    for (i = 0; i < sizeof(cached->hits_by_hour) / sizeof(cached->hits_by_hour[0]); i ++) {
+        add_next_index_long(hits, (long) cached->hits_by_hour[i]);
     }
     add_assoc_zval_ex(return_value, ZEND_STRS("hits_by_hour"), hits);
@@ -610 +639 @@
     MAKE_STD_ZVAL(hits);
     array_init(hits);
-    for (i = 0; i < sizeof(cache->hits_by_second) / sizeof(cache->hits_by_second[0]); i ++) {
-        add_next_index_long(hits, (long) cache->hits_by_second[i]);
+    for (i = 0; i < sizeof(cached->hits_by_second) / sizeof(cached->hits_by_second[0]); i ++) {
+        add_next_index_long(hits, (long) cached->hits_by_second[i]);
     }
     add_assoc_zval_ex(return_value, ZEND_STRS("hits_by_second"), hits);
@@ -721 +750 @@
 
     for (i = 0, c = cache->hentry->size; i < c; i ++) {
-        for (e = cache->entries[i]; e; e = e->next) {
+        for (e = cache->cached->entries[i]; e; e = e->next) {
             xc_fillentry_unlocked(type, e, i, 0, list TSRMLS_CC);
         }
@@ -729 +758 @@
     ALLOC_INIT_ZVAL(list);
     array_init(list);
-    for (e = cache->deletes; e; e = e->next) {
+    for (e = cache->cached->deletes; e; e = e->next) {
         xc_fillentry_unlocked(XC_TYPE_PHP, e, 0, 1, list TSRMLS_CC);
     }
@@ -817 +846 @@
 /* }}} */
 
-static inline void xc_entry_unholds_real(xc_stack_t *holds, xc_cache_t **caches, int cachecount TSRMLS_DC) /* {{{ */
+static inline void xc_entry_unholds_real(xc_stack_t *holds, xc_cache_t *caches, int cachecount TSRMLS_DC) /* {{{ */
 {
     int i;
@@ -828 +857 @@
         TRACE("holded %d items", xc_stack_count(s));
         if (xc_stack_count(s)) {
-            cache = caches[i];
+            cache = &caches[i];
             ENTER_LOCK(cache) {
                 while (xc_stack_count(s)) {
@@ -1024 +1053 @@
     *entry_resolve_path_data->stored_entry = (xc_entry_php_t *) xc_entry_find_unlocked(
             XC_TYPE_PHP
-            , xc_php_caches[compiler->entry_hash.cacheid]
+            , &xc_php_caches[compiler->entry_hash.cacheid]
             , compiler->entry_hash.entryslotid
             , (xc_entry_t *) &compiler->new_entry
@@ -1889 +1918 @@
     xc_compiler_t *compiler = sandboxed_compiler->compiler;
     zend_bool catched = 0;
-    xc_cache_t *cache = xc_php_caches[compiler->entry_hash.cacheid];
+    xc_cache_t *cache = &xc_php_caches[compiler->entry_hash.cacheid];
     xc_entry_php_t *stored_entry;
     xc_entry_data_php_t *stored_php;
@@ -1950 +1979 @@
     }
 
-    cache->compiling = 0;
+    cache->cached->compiling = 0;
     xc_free_php(&compiler->new_php TSRMLS_CC);
 
@@ -1975 +2004 @@
     xc_free_php(&compiler->new_php TSRMLS_CC);
 
-    cache->compiling = 0;
+    cache->cached->compiling = 0;
     if (catched) {
-        cache->errors ++;
+        cache->cached->errors ++;
         zend_bailout();
     }
@@ -2016 +2045 @@
     zend_bool catched = 0;
     zend_op_array *op_array;
-    xc_cache_t *cache = xc_php_caches[compiler->entry_hash.cacheid];
+    xc_cache_t *cache = &xc_php_caches[compiler->entry_hash.cacheid];
     xc_sandboxed_compiler_t sandboxed_compiler;
 
     /* stale clogs precheck */
-    if (XG(request_time) - cache->compiling < 30) {
-        cache->clogs ++;
+    if (XG(request_time) - cache->cached->compiling < 30) {
+        cache->cached->clogs ++;
         return old_compile_file(h, type TSRMLS_CC);
     }
@@ -2047 +2076 @@
 
         if (stored_entry) {
-            xc_cache_hit_unlocked(cache TSRMLS_CC);
+            xc_cached_hit_unlocked(cache->cached TSRMLS_CC);
 
             TRACE(" hit %d:%s, holding", compiler->new_entry.file_inode, stored_entry->entry.name.str.val);
@@ -2062 +2091 @@
         }
 
-        stored_php = xc_php_find_unlocked(cache, &compiler->new_php TSRMLS_CC);
+        stored_php = xc_php_find_unlocked(cache->cached, &compiler->new_php TSRMLS_CC);
 
         if (stored_php) {
@@ -2079 +2108 @@
         }
 
-        if (XG(request_time) - cache->compiling < 30) {
+        if (XG(request_time) - cache->cached->compiling < 30) {
             TRACE("%s", "miss php, but compiling");
-            cache->clogs ++;
+            cache->cached->clogs ++;
             gaveup = 1;
             break;
@@ -2087 +2116 @@
 
         TRACE("%s", "miss php, going to compile");
-        cache->compiling = XG(request_time);
+        cache->cached->compiling = XG(request_time);
     } LEAVE_LOCK_EX(cache);
 
     if (catched) {
-        cache->compiling = 0;
+        cache->cached->compiling = 0;
         zend_bailout();
     }
@@ -2172 +2201 @@
     if (xc_php_caches) {
         for (i = 0; i < xc_php_hcache.size; i ++) {
-            shm = xc_php_caches[i]->shm;
+            shm = xc_php_caches[i].shm;
             if (shm->handlers->is_readwrite(shm, p)) {
                 return 1;
@@ -2181 +2210 @@
     if (xc_var_caches) {
         for (i = 0; i < xc_var_hcache.size; i ++) {
-            shm = xc_var_caches[i]->shm;
+            shm = xc_var_caches[i].shm;
             if (shm->handlers->is_readwrite(shm, p)) {
                 return 1;
@@ -2197 +2226 @@
     if (xc_php_caches) {
         for (i = 0; i < xc_php_hcache.size; i ++) {
-            shm = xc_php_caches[i]->shm;
+            shm = xc_php_caches[i].shm;
             if (shm->handlers->is_readonly(shm, p)) {
                 return 1;
@@ -2206 +2235 @@
     if (xc_var_caches) {
         for (i = 0; i < xc_var_hcache.size; i ++) {
-            shm = xc_var_caches[i]->shm;
+            shm = xc_var_caches[i].shm;
             if (shm->handlers->is_readonly(shm, p)) {
                 return 1;
@@ -2255 +2284 @@
 }
 /* }}} */
-static xc_shm_t *xc_cache_destroy(xc_cache_t **caches, xc_hash_t *hcache) /* {{{ */
+static xc_shm_t *xc_cache_destroy(xc_cache_t *caches, xc_hash_t *hcache) /* {{{ */
 {
     size_t i;
-    xc_cache_t *cache;
     xc_shm_t *shm = NULL;
 
-    if (!caches) {
-        return shm;
-    }
+    assert(caches);
 
     for (i = 0; i < hcache->size; i ++) {
-        cache = caches[i];
+        xc_cache_t *cache = &caches[i];
         if (cache) {
             if (cache->lck) {
@@ -2285 +2311 @@
 }
 /* }}} */
-static xc_cache_t **xc_cache_init(xc_shm_t *shm, xc_hash_t *hcache, xc_hash_t *hentry, xc_hash_t *hphp, xc_shmsize_t shmsize) /* {{{ */
-{
-    xc_cache_t **caches = NULL, *cache;
+static xc_cache_t *xc_cache_init(xc_shm_t *shm, xc_hash_t *hcache, xc_hash_t *hentry, xc_hash_t *hphp, xc_shmsize_t shmsize) /* {{{ */
+{
+    xc_cache_t *caches = NULL;
     xc_mem_t *mem;
     time_t now = time(NULL);
@@ -2306 +2332 @@
     }
 
-    CHECK(caches = calloc(hcache->size, sizeof(xc_cache_t *)), "caches OOM");
+    CHECK(caches = calloc(hcache->size, sizeof(xc_cache_t)), "caches OOM");
 
     for (i = 0; i < hcache->size; i ++) {
-        CHECK(mem            = shm->handlers->meminit(shm, memsize), "Failed init memory allocator");
-        CHECK(cache          = mem->handlers->calloc(mem, 1, sizeof(xc_cache_t)), "cache OOM");
-        CHECK(cache->entries = mem->handlers->calloc(mem, hentry->size, sizeof(xc_entry_t*)), "entries OOM");
+        xc_cache_t *cache = &caches[i];
+        CHECK(mem                     = shm->handlers->meminit(shm, memsize), "Failed init memory allocator");
+        CHECK(cache->cached           = mem->handlers->calloc(mem, 1, sizeof(xc_cached_t)), "cache OOM");
+        CHECK(cache->cached->entries  = mem->handlers->calloc(mem, hentry->size, sizeof(xc_entry_t*)), "entries OOM");
         if (hphp) {
-            CHECK(cache->phps= mem->handlers->calloc(mem, hphp->size, sizeof(xc_entry_data_php_t*)), "phps OOM");
-        }
-        CHECK(cache->lck     = xc_lock_init(NULL), "can't create lock");
+            CHECK(cache->cached->phps = mem->handlers->calloc(mem, hphp->size, sizeof(xc_entry_data_php_t*)), "phps OOM");
+        }
+        CHECK(cache->lck              = xc_lock_init(NULL), "can't create lock");
 
         cache->hcache  = hcache;
@@ -2323 +2350 @@
         cache->mem     = mem;
         cache->cacheid = i;
-        cache->last_gc_deletes = now;
-        cache->last_gc_expires = now;
-        caches[i] = cache;
+        cache->cached->last_gc_deletes = now;
+        cache->cached->last_gc_expires = now;
     }
     return caches;
@@ -2577 +2603 @@
     ENTER_LOCK(cache) {
         for (entryslotid = 0, c = cache->hentry->size; entryslotid < c; entryslotid ++) {
-            for (e = cache->entries[entryslotid]; e; e = next) {
+            for (e = cache->cached->entries[entryslotid]; e; e = next) {
                 next = e->next;
                 xc_entry_remove_unlocked(type, cache, entryslotid, e TSRMLS_CC);
             }
-            cache->entries[entryslotid] = NULL;
+            cache->cached->entries[entryslotid] = NULL;
         }
     } LEAVE_LOCK(cache);
@@ -2591 +2617 @@
     long type;
     int size;
-    xc_cache_t **caches, *cache;
+    xc_cache_t *caches, *cache;
     long id = 0;
 
@@ -2648 +2674 @@
             array_init(return_value);
 
-            cache = caches[id];
+            cache = &caches[id];
             ENTER_LOCK(cache) {
                 if (optype == XC_OP_INFO) {
@@ -2667 +2693 @@
             if (id == -1) {
                 for (id = 0; id < size; ++id) {
-                    xc_clear(type, caches[id] TSRMLS_CC);
+                    xc_clear(type, &caches[id] TSRMLS_CC);
                 }
             }
             else {
-                xc_clear(type, caches[id] TSRMLS_CC);
+                xc_clear(type, &caches[id] TSRMLS_CC);
             }
 
@@ -2763 +2789 @@
     }
     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
-    cache = xc_var_caches[entry_hash.cacheid];
+    cache = &xc_var_caches[entry_hash.cacheid];
 
     ENTER_LOCK(cache) {
@@ -2770 +2796 @@
             /* return */
             xc_processor_restore_zval(return_value, stored_entry_var->value, stored_entry_var->have_references TSRMLS_CC);
-            xc_cache_hit_unlocked(cache TSRMLS_CC);
+            xc_cached_hit_unlocked(cache->cached TSRMLS_CC);
         }
         else {
@@ -2809 +2835 @@
 
     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
-    cache = xc_var_caches[entry_hash.cacheid];
+    cache = &xc_var_caches[entry_hash.cacheid];
 
     ENTER_LOCK(cache) {
@@ -2839 +2865 @@
     }
     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
-    cache = xc_var_caches[entry_hash.cacheid];
+    cache = &xc_var_caches[entry_hash.cacheid];
 
     ENTER_LOCK(cache) {
         stored_entry_var = (xc_entry_var_t *) xc_entry_find_unlocked(XC_TYPE_VAR, cache, entry_hash.entryslotid, (xc_entry_t *) &entry_var TSRMLS_CC);
         if (stored_entry_var) {
-            xc_cache_hit_unlocked(cache TSRMLS_CC);
+            xc_cached_hit_unlocked(cache->cached TSRMLS_CC);
             RETVAL_TRUE;
             /* return */
@@ -2873 +2899 @@
     }
     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
-    cache = xc_var_caches[entry_hash.cacheid];
+    cache = &xc_var_caches[entry_hash.cacheid];
 
     ENTER_LOCK(cache) {
@@ -2904 +2930 @@
 
     for (i = 0, iend = xc_var_hcache.size; i < iend; i ++) {
-        xc_cache_t *cache = xc_var_caches[i];
+        xc_cache_t *cache = &xc_var_caches[i];
         ENTER_LOCK(cache) {
             int entryslotid, jend;
             for (entryslotid = 0, jend = cache->hentry->size; entryslotid < jend; entryslotid ++) {
                 xc_entry_t *entry, *next;
-                for (entry = cache->entries[entryslotid]; entry; entry = next) {
+                for (entry = cache->cached->entries[entryslotid]; entry; entry = next) {
                     next = entry->next;
                     if (xc_entry_has_prefix_unlocked(XC_TYPE_VAR, entry, prefix)) {
@@ -2946 +2972 @@
 
     xc_entry_var_init_key(&entry_var, &entry_hash, name TSRMLS_CC);
-    cache = xc_var_caches[entry_hash.cacheid];
+    cache = &xc_var_caches[entry_hash.cacheid];
 
     ENTER_LOCK(cache) {
@@ -2964 +2990 @@
                 zv = (zval *) cache->shm->handlers->to_readwrite(cache->shm, (char *) stored_entry_var->value);
                 Z_LVAL_P(zv) = value;
-                ++cache->updates;
+                ++cache->cached->updates;
                 break; /* leave lock */
             }
@@ -3208 +3234 @@
     if (ext) {
         /* zend_optimizer.optimization_level>0 is not compatible with other cacher, disabling */
+#if 0
         ext->op_array_handler = NULL;
+#endif
     }
     /* cache if there's an op_array_ctor */

@@ -18 +18 @@
 devel.ini
 devel.php
+devel.fpm
 .gdb_history
 include