Implemented a faster way to access predefined TSRM resources - CG(), EG(), etc.

diff --git a/TSRM/TSRM.c b/TSRM/TSRM.c
index 67f6722945cda8cab0ea827c41dcf0c338bbf703..670c260678d426997cbb0b1179d1cf48850828d4 100644 (file)
--- a/TSRM/TSRM.c
+++ b/TSRM/TSRM.c
@@ -34,6 +34,7 @@ typedef struct {
        size_t size;
        ts_allocate_ctor ctor;
        ts_allocate_dtor dtor;
+       size_t fast_offset;
        int done;
 } tsrm_resource_type;
 
@@ -47,6 +48,9 @@ static ts_rsrc_id             id_count;
 static tsrm_resource_type      *resource_types_table=NULL;
 static int                                     resource_types_table_size;
 
+/* Reserved space for fast globals access */
+static size_t tsrm_reserved_pos  = 0;
+static size_t tsrm_reserved_size = 0;
 
 static MUTEX_T tsmm_mutex;     /* thread-safe memory manager mutex */
 
@@ -160,6 +164,10 @@ TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debu
        tsmm_mutex = tsrm_mutex_alloc();
 
        TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Started up TSRM, %d expected threads, %d expected resources", expected_threads, expected_resources));
+
+       tsrm_reserved_pos  = 0;
+       tsrm_reserved_size = 0;
+
        return 1;
 }/*}}}*/
 
@@ -187,7 +195,9 @@ TSRM_API void tsrm_shutdown(void)
                                                if (resource_types_table && !resource_types_table[j].done && resource_types_table[j].dtor) {
                                                        resource_types_table[j].dtor(p->storage[j]);
                                                }
-                                               free(p->storage[j]);
+                                               if (!resource_types_table[j].fast_offset) {
+                                                       free(p->storage[j]);
+                                               }
                                        }
                                }
                                free(p->storage);
@@ -222,14 +232,46 @@ TSRM_API void tsrm_shutdown(void)
        tsrm_new_thread_begin_handler = NULL;
        tsrm_new_thread_end_handler = NULL;
        tsrm_shutdown_handler = NULL;
+
+       tsrm_reserved_pos  = 0;
+       tsrm_reserved_size = 0;
 }/*}}}*/
 
 
-/* allocates a new thread-safe-resource id */
-TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
+/* enlarge the arrays for the already active threads */
+static void tsrm_update_active_threads(void)
 {/*{{{*/
        int i;
 
+       for (i=0; i<tsrm_tls_table_size; i++) {
+               tsrm_tls_entry *p = tsrm_tls_table[i];
+
+               while (p) {
+                       if (p->count < id_count) {
+                               int j;
+
+                               p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
+                               for (j=p->count; j<id_count; j++) {
+                                       if (resource_types_table[j].fast_offset) {
+                                               p->storage[j] = (void *) (((char*)p) + resource_types_table[j].fast_offset);
+                                       } else {
+                                               p->storage[j] = (void *) malloc(resource_types_table[j].size);
+                                       }
+                                       if (resource_types_table[j].ctor) {
+                                               resource_types_table[j].ctor(p->storage[j]);
+                                       }
+                               }
+                               p->count = id_count;
+                       }
+                       p = p->next;
+               }
+       }
+}/*}}}*/
+
+
+/* allocates a new thread-safe-resource id */
+TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
+{/*{{{*/
        TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size));
 
        tsrm_mutex_lock(tsmm_mutex);
@@ -254,28 +296,68 @@ TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate
        resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
        resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
        resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].fast_offset = 0;
        resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].done = 0;
 
-       /* enlarge the arrays for the already active threads */
-       for (i=0; i<tsrm_tls_table_size; i++) {
-               tsrm_tls_entry *p = tsrm_tls_table[i];
+       tsrm_update_active_threads();
+       tsrm_mutex_unlock(tsmm_mutex);
 
-               while (p) {
-                       if (p->count < id_count) {
-                               int j;
+       TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
+       return *rsrc_id;
+}/*}}}*/
 
-                               p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
-                               for (j=p->count; j<id_count; j++) {
-                                       p->storage[j] = (void *) malloc(resource_types_table[j].size);
-                                       if (resource_types_table[j].ctor) {
-                                               resource_types_table[j].ctor(p->storage[j]);
-                                       }
-                               }
-                               p->count = id_count;
-                       }
-                       p = p->next;
+
+/* Reserve space for fast thread-safe-resources */
+TSRM_API void tsrm_reserve(size_t size)
+{/*{{{*/
+       tsrm_reserved_pos  = 0;
+       tsrm_reserved_size = TSRM_ALIGNED_SIZE(size);
+}/*}}}*/
+
+
+/* allocates a new fast thread-safe-resource id */
+TSRM_API ts_rsrc_id ts_allocate_fast_id(ts_rsrc_id *rsrc_id, size_t *offset, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
+{/*{{{*/
+       TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new fast resource id, %d bytes", size));
+
+       tsrm_mutex_lock(tsmm_mutex);
+
+       /* obtain a resource id */
+       *rsrc_id = TSRM_SHUFFLE_RSRC_ID(id_count++);
+       TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));
+
+       size = TSRM_ALIGNED_SIZE(size);
+       if (tsrm_reserved_size - tsrm_reserved_pos < size) {
+               tsrm_mutex_unlock(tsmm_mutex);
+               TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate space for fast resource"));
+               *rsrc_id = 0;
+               *offset = 0;
+               return 0;
+       }
+
+       *offset = TSRM_ALIGNED_SIZE(sizeof(tsrm_tls_entry)) + tsrm_reserved_pos;
+       tsrm_reserved_pos += size;
+
+       /* store the new resource type in the resource sizes table */
+       if (resource_types_table_size < id_count) {
+               tsrm_resource_type *_tmp;
+               _tmp = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
+               if (!_tmp) {
+                       tsrm_mutex_unlock(tsmm_mutex);
+                       TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource"));
+                       *rsrc_id = 0;
+                       return 0;
                }
+               resource_types_table = _tmp;
+               resource_types_table_size = id_count;
        }
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].fast_offset = *offset;
+       resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].done = 0;
+
+       tsrm_update_active_threads();
        tsrm_mutex_unlock(tsmm_mutex);
 
        TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
@@ -288,7 +370,7 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
        int i;
 
        TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Creating data structures for thread %x", thread_id));
-       (*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry));
+       (*thread_resources_ptr) = (tsrm_tls_entry *) malloc(TSRM_ALIGNED_SIZE(sizeof(tsrm_tls_entry)) + tsrm_reserved_size);
        (*thread_resources_ptr)->storage = NULL;
        if (id_count > 0) {
                (*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count);
@@ -307,9 +389,12 @@ static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_
        for (i=0; i<id_count; i++) {
                if (resource_types_table[i].done) {
                        (*thread_resources_ptr)->storage[i] = NULL;
-               } else
-               {
-                       (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
+               } else {
+                       if (resource_types_table[i].fast_offset) {
+                               (*thread_resources_ptr)->storage[i] = (void *) (((char*)(*thread_resources_ptr)) + resource_types_table[i].fast_offset);
+                       } else {
+                               (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
+                       }
                        if (resource_types_table[i].ctor) {
                                resource_types_table[i].ctor((*thread_resources_ptr)->storage[i]);
                        }
@@ -402,7 +487,9 @@ void tsrm_free_interpreter_context(void *context)
                        }
                }
                for (i=0; i<thread_resources->count; i++) {
-                       free(thread_resources->storage[i]);
+                       if (!resource_types_table[i].fast_offset) {
+                               free(thread_resources->storage[i]);
+                       }
                }
                free(thread_resources->storage);
                free(thread_resources);
@@ -467,7 +554,9 @@ void ts_free_thread(void)
                                }
                        }
                        for (i=0; i<thread_resources->count; i++) {
-                               free(thread_resources->storage[i]);
+                               if (!resource_types_table[i].fast_offset) {
+                                       free(thread_resources->storage[i]);
+                               }
                        }
                        free(thread_resources->storage);
                        if (last) {
@@ -509,7 +598,9 @@ void ts_free_worker_threads(void)
                                }
                        }
                        for (i=0; i<thread_resources->count; i++) {
-                               free(thread_resources->storage[i]);
+                               if (!resource_types_table[i].fast_offset) {
+                                       free(thread_resources->storage[i]);
+                               }
                        }
                        free(thread_resources->storage);
                        if (last) {
@@ -553,7 +644,9 @@ void ts_free_id(ts_rsrc_id id)
                                        if (resource_types_table && resource_types_table[j].dtor) {
                                                resource_types_table[j].dtor(p->storage[j]);
                                        }
-                                       free(p->storage[j]);
+                                       if (!resource_types_table[j].fast_offset) {
+                                               free(p->storage[j]);
+                                       }
                                        p->storage[j] = NULL;
                                }
                                p = p->next;

diff --git a/TSRM/TSRM.h b/TSRM/TSRM.h
index 061459e77d5e071b1b313adbb7cb4d539f1aadd0..a14e31e1f00e09fb80e81f1b71b3c87220fb19b1 100644 (file)
--- a/TSRM/TSRM.h
+++ b/TSRM/TSRM.h
@@ -57,6 +57,14 @@ typedef uintptr_t tsrm_uintptr_t;
 #include <TLS.h>
 #endif
 
+#if SIZEOF_SIZE_T == 4
+# define TSRM_ALIGNED_SIZE(size) \
+       (((size) + INT32_C(15)) & ~INT32_C(15))
+#else
+# define TSRM_ALIGNED_SIZE(size) \
+       (((size) + INT64_C(15)) & ~INT64_C(15))
+#endif
+
 typedef int ts_rsrc_id;
 
 /* Define THREAD_T and MUTEX_T */
@@ -94,6 +102,10 @@ TSRM_API void tsrm_shutdown(void);
 /* allocates a new thread-safe-resource id */
 TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
 
+/* Fast resource in reserved (pre-allocated) space */
+TSRM_API void tsrm_reserve(size_t size);
+TSRM_API ts_rsrc_id ts_allocate_fast_id(ts_rsrc_id *rsrc_id, size_t *offset, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor);
+
 /* fetches the requested resource for the current thread */
 TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id);
 #define ts_resource(id)                        ts_resource_ex(id, NULL)
@@ -162,9 +174,13 @@ TSRM_API const char *tsrm_api_name(void);
 #define TSRMLS_SET_CTX(ctx)            ctx = (void ***) tsrm_get_ls_cache()
 #define TSRMG(id, type, element)       (TSRMG_BULK(id, type)->element)
 #define TSRMG_BULK(id, type)   ((type) (*((void ***) tsrm_get_ls_cache()))[TSRM_UNSHUFFLE_RSRC_ID(id)])
+#define TSRMG_FAST(offset, type, element)      (TSRMG_FAST_BULK(offset, type)->element)
+#define TSRMG_FAST_BULK(offset, type)  ((type) (((char*) tsrm_get_ls_cache())+(offset)))
 
 #define TSRMG_STATIC(id, type, element)        (TSRMG_BULK_STATIC(id, type)->element)
 #define TSRMG_BULK_STATIC(id, type)    ((type) (*((void ***) TSRMLS_CACHE))[TSRM_UNSHUFFLE_RSRC_ID(id)])
+#define TSRMG_FAST_STATIC(offset, type, element)       (TSRMG_FAST_BULK_STATIC(offset, type)->element)
+#define TSRMG_FAST_BULK_STATIC(offset, type)   ((type) (((char*) TSRMLS_CACHE)+(offset)))
 #define TSRMLS_CACHE_EXTERN() extern TSRM_TLS void *TSRMLS_CACHE;
 #define TSRMLS_CACHE_DEFINE() TSRM_TLS void *TSRMLS_CACHE = NULL;
 #if ZEND_DEBUG

diff --git a/Zend/zend.c b/Zend/zend.c
index 542ac9ff1d608be217c037e32244e4cad2e15ff7..2c2bd09081ff2bd6c58d3fbd5d33e4f18dee56a5 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -38,6 +38,8 @@ static size_t global_map_ptr_last = 0;
 #ifdef ZTS
 ZEND_API int compiler_globals_id;
 ZEND_API int executor_globals_id;
+ZEND_API size_t compiler_globals_offset;
+ZEND_API size_t executor_globals_offset;
 static HashTable *global_function_table = NULL;
 static HashTable *global_class_table = NULL;
 static HashTable *global_constants_table = NULL;
@@ -868,10 +870,10 @@ int zend_startup(zend_utility_functions *utility_functions) /* {{{ */
        zend_init_rsrc_list_dtors();
 
 #ifdef ZTS
-       ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
-       ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
-       ts_allocate_id(&language_scanner_globals_id, sizeof(zend_php_scanner_globals), (ts_allocate_ctor) php_scanner_globals_ctor, NULL);
-       ts_allocate_id(&ini_scanner_globals_id, sizeof(zend_ini_scanner_globals), (ts_allocate_ctor) ini_scanner_globals_ctor, NULL);
+       ts_allocate_fast_id(&compiler_globals_id, &compiler_globals_offset, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
+       ts_allocate_fast_id(&executor_globals_id, &executor_globals_offset, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
+       ts_allocate_fast_id(&language_scanner_globals_id, &language_scanner_globals_offset, sizeof(zend_php_scanner_globals), (ts_allocate_ctor) php_scanner_globals_ctor, NULL);
+       ts_allocate_fast_id(&ini_scanner_globals_id, &ini_scanner_globals_offset, sizeof(zend_ini_scanner_globals), (ts_allocate_ctor) ini_scanner_globals_ctor, NULL);
        compiler_globals = ts_resource(compiler_globals_id);
        executor_globals = ts_resource(executor_globals_id);
 

diff --git a/Zend/zend.h b/Zend/zend.h
index 4839b994b9deded01896451556d3200d27dee700..73a56a0ccb6429ac90b7cff8b5fa447785636522 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -55,12 +55,14 @@
 
 #ifdef ZEND_ENABLE_STATIC_TSRMLS_CACHE
 #define ZEND_TSRMG TSRMG_STATIC
+#define ZEND_TSRMG_FAST TSRMG_FAST_STATIC
 #define ZEND_TSRMLS_CACHE_EXTERN() TSRMLS_CACHE_EXTERN()
 #define ZEND_TSRMLS_CACHE_DEFINE() TSRMLS_CACHE_DEFINE()
 #define ZEND_TSRMLS_CACHE_UPDATE() TSRMLS_CACHE_UPDATE()
 #define ZEND_TSRMLS_CACHE TSRMLS_CACHE
 #else
 #define ZEND_TSRMG TSRMG
+#define ZEND_TSRMG_FAST TSRMG_FAST
 #define ZEND_TSRMLS_CACHE_EXTERN()
 #define ZEND_TSRMLS_CACHE_DEFINE()
 #define ZEND_TSRMLS_CACHE_UPDATE()

diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c
index 27879dae038c8bfea70550c0d2697d164fe348f4..dabf48150cec13361181ce58556f2af97238fb12 100644 (file)
--- a/Zend/zend_alloc.c
+++ b/Zend/zend_alloc.c
@@ -2371,7 +2371,8 @@ typedef struct _zend_alloc_globals {
 
 #ifdef ZTS
 static int alloc_globals_id;
-# define AG(v) ZEND_TSRMG(alloc_globals_id, zend_alloc_globals *, v)
+static size_t alloc_globals_offset;
+# define AG(v) ZEND_TSRMG_FAST(alloc_globals_offset, zend_alloc_globals *, v)
 #else
 # define AG(v) (alloc_globals.v)
 static zend_alloc_globals alloc_globals;
@@ -2736,7 +2737,7 @@ static void alloc_globals_dtor(zend_alloc_globals *alloc_globals)
 ZEND_API void start_memory_manager(void)
 {
 #ifdef ZTS
-       ts_allocate_id(&alloc_globals_id, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, (ts_allocate_dtor) alloc_globals_dtor);
+       ts_allocate_fast_id(&alloc_globals_id, &alloc_globals_offset, sizeof(zend_alloc_globals), (ts_allocate_ctor) alloc_globals_ctor, (ts_allocate_dtor) alloc_globals_dtor);
 #else
        alloc_globals_ctor(&alloc_globals);
 #endif
@@ -2958,3 +2959,10 @@ ZEND_API void * __zend_realloc(void *p, size_t len)
        }
        zend_out_of_memory();
 }
+
+#ifdef ZTS
+size_t zend_mm_globals_size(void)
+{
+       return sizeof(zend_alloc_globals);
+}
+#endif

diff --git a/Zend/zend_alloc.h b/Zend/zend_alloc.h
index abe6ec8e12a65f55bb33e16842f60e3c19a4f795..075aac656187de61b6a0060f2267d27f0753a111 100644 (file)
--- a/Zend/zend_alloc.h
+++ b/Zend/zend_alloc.h
@@ -398,6 +398,10 @@ static void apc_init_heap(void)
 
 */
 
+#ifdef ZTS
+size_t zend_mm_globals_size(void);
+#endif
+
 END_EXTERN_C()
 
 #endif

diff --git a/Zend/zend_gc.c b/Zend/zend_gc.c
index bc1fa4b82f2fcd58c8b5a138e8d07ab885aca478..edb952c2cd120d6e151ab0d16fb68d9f225beff2 100644 (file)
--- a/Zend/zend_gc.c
+++ b/Zend/zend_gc.c
@@ -211,7 +211,8 @@ typedef struct _zend_gc_globals {
 
 #ifdef ZTS
 static int gc_globals_id;
-#define GC_G(v) ZEND_TSRMG(gc_globals_id, zend_gc_globals *, v)
+static size_t gc_globals_offset;
+#define GC_G(v) ZEND_TSRMG_FAST(gc_globals_offset, zend_gc_globals *, v)
 #else
 #define GC_G(v) (gc_globals.v)
 static zend_gc_globals gc_globals;
@@ -442,7 +443,7 @@ static void gc_globals_ctor_ex(zend_gc_globals *gc_globals)
 void gc_globals_ctor(void)
 {
 #ifdef ZTS
-       ts_allocate_id(&gc_globals_id, sizeof(zend_gc_globals), (ts_allocate_ctor) gc_globals_ctor_ex, (ts_allocate_dtor) root_buffer_dtor);
+       ts_allocate_fast_id(&gc_globals_id, &gc_globals_offset, sizeof(zend_gc_globals), (ts_allocate_ctor) gc_globals_ctor_ex, (ts_allocate_dtor) root_buffer_dtor);
 #else
        gc_globals_ctor_ex(&gc_globals);
 #endif
@@ -1585,3 +1586,10 @@ ZEND_API void zend_gc_get_status(zend_gc_status *status)
        status->threshold = GC_G(gc_threshold);
        status->num_roots = GC_G(num_roots);
 }
+
+#ifdef ZTS
+size_t zend_gc_globals_size(void)
+{
+       return sizeof(zend_gc_globals);
+}
+#endif

diff --git a/Zend/zend_gc.h b/Zend/zend_gc.h
index 377bd4298a2590dc3a3db5eeab4b4f10a552ba15..e83e874e07f7fc39bec2e94559a171bf1d580170 100644 (file)
--- a/Zend/zend_gc.h
+++ b/Zend/zend_gc.h
@@ -51,6 +51,10 @@ void gc_globals_ctor(void);
 void gc_globals_dtor(void);
 void gc_reset(void);
 
+#ifdef ZTS
+size_t zend_gc_globals_size(void);
+#endif
+
 END_EXTERN_C()
 
 #define GC_REMOVE_FROM_BUFFER(p) do { \

diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 2f46da0c2d3f633f11d4bf2be98b494619685ee5..5a7686219401d4adea33b69e9386a90fec10857f 100644 (file)
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -45,6 +45,8 @@
 BEGIN_EXTERN_C()
 ZEND_API extern int compiler_globals_id;
 ZEND_API extern int executor_globals_id;
+ZEND_API extern size_t compiler_globals_offset;
+ZEND_API extern size_t executor_globals_offset;
 END_EXTERN_C()
 
 #endif

diff --git a/Zend/zend_globals_macros.h b/Zend/zend_globals_macros.h
index 18181a433e06ce81ae9e5065162c20c76a444922..59b3daca53fd49c6a0ffb913554210ae7aad0941 100644 (file)
--- a/Zend/zend_globals_macros.h
+++ b/Zend/zend_globals_macros.h
@@ -29,7 +29,7 @@ BEGIN_EXTERN_C()
 
 /* Compiler */
 #ifdef ZTS
-# define CG(v) ZEND_TSRMG(compiler_globals_id, zend_compiler_globals *, v)
+# define CG(v) ZEND_TSRMG_FAST(compiler_globals_offset, zend_compiler_globals *, v)
 #else
 # define CG(v) (compiler_globals.v)
 extern ZEND_API struct _zend_compiler_globals compiler_globals;
@@ -39,7 +39,7 @@ ZEND_API int zendparse(void);
 
 /* Executor */
 #ifdef ZTS
-# define EG(v) ZEND_TSRMG(executor_globals_id, zend_executor_globals *, v)
+# define EG(v) ZEND_TSRMG_FAST(executor_globals_offset, zend_executor_globals *, v)
 #else
 # define EG(v) (executor_globals.v)
 extern ZEND_API zend_executor_globals executor_globals;
@@ -47,8 +47,9 @@ extern ZEND_API zend_executor_globals executor_globals;
 
 /* Language Scanner */
 #ifdef ZTS
-# define LANG_SCNG(v) ZEND_TSRMG(language_scanner_globals_id, zend_php_scanner_globals *, v)
+# define LANG_SCNG(v) ZEND_TSRMG_FAST(language_scanner_globals_offset, zend_php_scanner_globals *, v)
 extern ZEND_API ts_rsrc_id language_scanner_globals_id;
+extern ZEND_API size_t language_scanner_globals_offset;
 #else
 # define LANG_SCNG(v) (language_scanner_globals.v)
 extern ZEND_API zend_php_scanner_globals language_scanner_globals;
@@ -57,8 +58,9 @@ extern ZEND_API zend_php_scanner_globals language_scanner_globals;
 
 /* INI Scanner */
 #ifdef ZTS
-# define INI_SCNG(v) ZEND_TSRMG(ini_scanner_globals_id, zend_ini_scanner_globals *, v)
+# define INI_SCNG(v) ZEND_TSRMG_FAST(ini_scanner_globals_offset, zend_ini_scanner_globals *, v)
 extern ZEND_API ts_rsrc_id ini_scanner_globals_id;
+extern ZEND_API size_t ini_scanner_globals_offset;
 #else
 # define INI_SCNG(v) (ini_scanner_globals.v)
 extern ZEND_API zend_ini_scanner_globals ini_scanner_globals;

diff --git a/Zend/zend_ini_scanner.l b/Zend/zend_ini_scanner.l
index 23a5a7f14c917ca046ec54931f9839010e5daf80..f71f0b9193e9c7cdf6e507a6f76d243a12bb3b6d 100644 (file)
--- a/Zend/zend_ini_scanner.l
+++ b/Zend/zend_ini_scanner.l
@@ -104,6 +104,7 @@
 #define SCNG   INI_SCNG
 #ifdef ZTS
 ZEND_API ts_rsrc_id ini_scanner_globals_id;
+ZEND_API size_t ini_scanner_globals_offset;
 #else
 ZEND_API zend_ini_scanner_globals ini_scanner_globals;
 #endif

diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index e93431de24f0bfcdac35ec79cd2b52ee24bf81a4..b1e25ebae51b3b2ea18bbeaa236e79571b68d7e3 100644 (file)
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -85,6 +85,7 @@
 #define SCNG   LANG_SCNG
 #ifdef ZTS
 ZEND_API ts_rsrc_id language_scanner_globals_id;
+ZEND_API size_t language_scanner_globals_offset;
 #else
 ZEND_API zend_php_scanner_globals language_scanner_globals;
 #endif

diff --git a/Zend/zend_signal.c b/Zend/zend_signal.c
index a0dccd58195244ceba9390a5d3249b97fbe20afb..571d85f848036b592c766db2af559c9696c7f5ec 100644 (file)
--- a/Zend/zend_signal.c
+++ b/Zend/zend_signal.c
@@ -45,6 +45,7 @@
 
 #ifdef ZTS
 ZEND_API int zend_signal_globals_id;
+ZEND_API size_t zend_signal_globals_offset;
 #else
 ZEND_API zend_signal_globals_t zend_signal_globals;
 #endif /* not ZTS */
@@ -403,7 +404,7 @@ ZEND_API void zend_signal_startup(void)
 {
 
 #ifdef ZTS
-       ts_allocate_id(&zend_signal_globals_id, sizeof(zend_signal_globals_t), (ts_allocate_ctor) zend_signal_globals_ctor, NULL);
+       ts_allocate_fast_id(&zend_signal_globals_id, &zend_signal_globals_offset, sizeof(zend_signal_globals_t), (ts_allocate_ctor) zend_signal_globals_ctor, NULL);
 #else
        zend_signal_globals_ctor(&zend_signal_globals);
 #endif

diff --git a/Zend/zend_signal.h b/Zend/zend_signal.h
index 7ecdde3cd6b248d399634254d2feaacf14232677..1c234b0a0c6f5f8f4a58af09306eb041acefe8c5 100644 (file)
--- a/Zend/zend_signal.h
+++ b/Zend/zend_signal.h
@@ -65,9 +65,10 @@ typedef struct _zend_signal_globals_t {
 } zend_signal_globals_t;
 
 # ifdef ZTS
-#  define SIGG(v) ZEND_TSRMG(zend_signal_globals_id, zend_signal_globals_t *, v)
+#  define SIGG(v) ZEND_TSRMG_FAST(zend_signal_globals_offset, zend_signal_globals_t *, v)
 BEGIN_EXTERN_C()
 ZEND_API extern int zend_signal_globals_id;
+ZEND_API extern size_t zend_signal_globals_offset;
 END_EXTERN_C()
 # else
 #  define SIGG(v) (zend_signal_globals.v)

diff --git a/Zend/zend_virtual_cwd.c b/Zend/zend_virtual_cwd.c
index 3998b46aa1c5b6c0fb4bb0d110d2f8dbc307d184..8f8514ba235f8648f5820094fedfd3cdf5a62a5c 100644 (file)
--- a/Zend/zend_virtual_cwd.c
+++ b/Zend/zend_virtual_cwd.c
@@ -82,6 +82,7 @@ MUTEX_T cwd_mutex;
 
 #ifdef ZTS
 ts_rsrc_id cwd_globals_id;
+size_t     cwd_globals_offset;
 #else
 virtual_cwd_globals cwd_globals;
 #endif
@@ -185,7 +186,7 @@ CWD_API void virtual_cwd_startup(void) /* {{{ */
 {
        virtual_cwd_main_cwd_init(0);
 #ifdef ZTS
-       ts_allocate_id(&cwd_globals_id, sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
+       ts_allocate_fast_id(&cwd_globals_id, &cwd_globals_offset, sizeof(virtual_cwd_globals), (ts_allocate_ctor) cwd_globals_ctor, (ts_allocate_dtor) cwd_globals_dtor);
 #else
        cwd_globals_ctor(&cwd_globals);
 #endif

diff --git a/Zend/zend_virtual_cwd.h b/Zend/zend_virtual_cwd.h
index c6c06f63325eee9255bc9fa7cab9d3bf2dfc05b6..dd8567cc51c231e179f5bd02024c73480855fe53 100644 (file)
--- a/Zend/zend_virtual_cwd.h
+++ b/Zend/zend_virtual_cwd.h
@@ -212,7 +212,8 @@ typedef struct _virtual_cwd_globals {
 
 #ifdef ZTS
 extern ts_rsrc_id cwd_globals_id;
-# define CWDG(v) ZEND_TSRMG(cwd_globals_id, virtual_cwd_globals *, v)
+extern size_t cwd_globals_offset;
+# define CWDG(v) ZEND_TSRMG_FAST(cwd_globals_offset, virtual_cwd_globals *, v)
 #else
 extern virtual_cwd_globals cwd_globals;
 # define CWDG(v) (cwd_globals.v)

diff --git a/main/SAPI.c b/main/SAPI.c
index 6a272d4c643206d1b60daaad1607806a075091fd..05b7bbbbec7b131a4ff0dc9eae56da0ec21c03eb 100644 (file)
--- a/main/SAPI.c
+++ b/main/SAPI.c
@@ -45,6 +45,7 @@
 
 #ifdef ZTS
 SAPI_API int sapi_globals_id;
+SAPI_API size_t sapi_globals_offset;
 #else
 sapi_globals_struct sapi_globals;
 #endif
@@ -76,7 +77,7 @@ SAPI_API void sapi_startup(sapi_module_struct *sf)
        sapi_module = *sf;
 
 #ifdef ZTS
-       ts_allocate_id(&sapi_globals_id, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, (ts_allocate_dtor) sapi_globals_dtor);
+       ts_allocate_fast_id(&sapi_globals_id, &sapi_globals_offset, sizeof(sapi_globals_struct), (ts_allocate_ctor) sapi_globals_ctor, (ts_allocate_dtor) sapi_globals_dtor);
 # ifdef PHP_WIN32
        _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
 # endif

diff --git a/main/SAPI.h b/main/SAPI.h
index f3479a22e63e21184d8cff7d66d2e89553332218..fe8bfd62442997d052e521554b384d67a4329de1 100644 (file)
--- a/main/SAPI.h
+++ b/main/SAPI.h
@@ -137,8 +137,9 @@ typedef struct _sapi_globals_struct {
 
 BEGIN_EXTERN_C()
 #ifdef ZTS
-# define SG(v) ZEND_TSRMG(sapi_globals_id, sapi_globals_struct *, v)
+# define SG(v) ZEND_TSRMG_FAST(sapi_globals_offset, sapi_globals_struct *, v)
 SAPI_API extern int sapi_globals_id;
+SAPI_API extern size_t sapi_globals_offset;
 #else
 # define SG(v) (sapi_globals.v)
 extern SAPI_API sapi_globals_struct sapi_globals;

diff --git a/main/main.c b/main/main.c
index 5e18630bd90caf6d2b24521db67d3d68626756d0..6286990f62f8994ce7e07f9b48fdd45656877a97 100644 (file)
--- a/main/main.c
+++ b/main/main.c
@@ -116,6 +116,7 @@ PHPAPI int (*php_register_internal_extensions_func)(void) = php_register_interna
 php_core_globals core_globals;
 #else
 PHPAPI int core_globals_id;
+PHPAPI size_t core_globals_offset;
 #endif
 
 #define SAFE_FILENAME(f) ((f)?(f):"-")
@@ -2151,7 +2152,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
        php_output_startup();
 
 #ifdef ZTS
-       ts_allocate_id(&core_globals_id, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, (ts_allocate_dtor) core_globals_dtor);
+       ts_allocate_fast_id(&core_globals_id, &core_globals_offset, sizeof(php_core_globals), (ts_allocate_ctor) core_globals_ctor, (ts_allocate_dtor) core_globals_dtor);
 #ifdef PHP_WIN32
        ts_allocate_id(&php_win32_core_globals_id, sizeof(php_win32_core_globals), (ts_allocate_ctor) php_win32_core_globals_ctor, (ts_allocate_dtor) php_win32_core_globals_dtor);
 #endif
@@ -2774,3 +2775,37 @@ PHPAPI int php_lint_script(zend_file_handle *file)
        return retval;
 }
 /* }}} */
+
+#ifdef ZTS
+/* {{{ php_reserve_tsrm_memory
+ */
+PHPAPI void php_reserve_tsrm_memory(void)
+{
+       tsrm_reserve(
+               TSRM_ALIGNED_SIZE(sizeof(zend_compiler_globals)) +
+               TSRM_ALIGNED_SIZE(sizeof(zend_executor_globals)) +
+               TSRM_ALIGNED_SIZE(sizeof(zend_php_scanner_globals)) +
+               TSRM_ALIGNED_SIZE(sizeof(zend_ini_scanner_globals)) +
+               TSRM_ALIGNED_SIZE(sizeof(virtual_cwd_globals)) +
+#ifdef ZEND_SIGNALS
+               TSRM_ALIGNED_SIZE(sizeof(zend_signal_globals_t)) +
+#endif
+               TSRM_ALIGNED_SIZE(zend_mm_globals_size()) +
+               TSRM_ALIGNED_SIZE(zend_gc_globals_size()) +
+               TSRM_ALIGNED_SIZE(sizeof(php_core_globals)) +
+               TSRM_ALIGNED_SIZE(sizeof(sapi_globals_struct))
+       );
+}
+/* }}} */
+
+/* {{{ php_tsrm_startup
+ */
+PHPAPI int php_tsrm_startup(void)
+{
+       int ret = tsrm_startup(1, 1, 0, NULL);
+       php_reserve_tsrm_memory();
+       (void)ts_resource(0);
+       return ret;
+}
+/* }}} */
+#endif

diff --git a/main/php_globals.h b/main/php_globals.h
index ad24618eae46250e7bd2effd4fc32a970b77f5cd..6b31d9eaa644a3b67a89cc335dad01d7444bc35b 100644 (file)
--- a/main/php_globals.h
+++ b/main/php_globals.h
@@ -24,8 +24,9 @@
 typedef struct _php_core_globals php_core_globals;
 
 #ifdef ZTS
-# define PG(v) ZEND_TSRMG(core_globals_id, php_core_globals *, v)
+# define PG(v) ZEND_TSRMG_FAST(core_globals_offset, php_core_globals *, v)
 extern PHPAPI int core_globals_id;
+extern PHPAPI size_t core_globals_offset;
 #else
 # define PG(v) (core_globals.v)
 extern ZEND_API struct _php_core_globals core_globals;

diff --git a/main/php_main.h b/main/php_main.h
index 8f440de82090cbdf0cd538fe4174b6d445b8feb5..6f2f9c5856a83358732b42476d03aa13b30a5b95 100644 (file)
--- a/main/php_main.h
+++ b/main/php_main.h
@@ -49,6 +49,12 @@ PHPAPI int php_stream_open_for_zend_ex(const char *filename, zend_file_handle *h
 /* environment module */
 extern int php_init_environ(void);
 extern int php_shutdown_environ(void);
+
+#ifdef ZTS
+PHPAPI void php_reserve_tsrm_memory(void);
+PHPAPI int php_tsrm_startup(void);
+#endif
+
 END_EXTERN_C()
 
 #endif

diff --git a/sapi/apache2handler/sapi_apache2.c b/sapi/apache2handler/sapi_apache2.c
index 81198af56261e093274c8cf1779950faf420c50c..193420eca42509214042b4b2ce1bbdf2fc044d40 100644 (file)
--- a/sapi/apache2handler/sapi_apache2.c
+++ b/sapi/apache2handler/sapi_apache2.c
@@ -474,8 +474,7 @@ php_apache_server_startup(apr_pool_t *pconf, apr_pool_t *plog, apr_pool_t *ptemp
                apache2_sapi_module.php_ini_path_override = apache2_php_ini_path_override;
        }
 #ifdef ZTS
-       tsrm_startup(1, 1, 0, NULL);
-       (void)ts_resource(0);
+       php_tsrm_startup();
 # ifdef PHP_WIN32
        ZEND_TSRMLS_CACHE_UPDATE();
 # endif

diff --git a/sapi/cgi/cgi_main.c b/sapi/cgi/cgi_main.c
index 84d2213cd63d4682a686b8ac8c54e0f05ae4bfc1..b22d37f89b2f4e90899f943ca1d907d821153f9a 100644 (file)
--- a/sapi/cgi/cgi_main.c
+++ b/sapi/cgi/cgi_main.c
@@ -1791,8 +1791,7 @@ int main(int argc, char *argv[])
 #endif
 
 #ifdef ZTS
-       tsrm_startup(1, 1, 0, NULL);
-       (void)ts_resource(0);
+       php_tsrm_startup();
 # ifdef PHP_WIN32
        ZEND_TSRMLS_CACHE_UPDATE();
 # endif

diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c
index 2cc83a5d6dbde5bef67517a312788c7f474a4bdb..4333487a0b2aba1553d74b7eca57fe61fcc042df 100644 (file)
--- a/sapi/cli/php_cli.c
+++ b/sapi/cli/php_cli.c
@@ -1246,8 +1246,7 @@ int main(int argc, char *argv[])
 
 
 #ifdef ZTS
-       tsrm_startup(1, 1, 0, NULL);
-       (void)ts_resource(0);
+       php_tsrm_startup();
 # ifdef PHP_WIN32
        ZEND_TSRMLS_CACHE_UPDATE();
 # endif

diff --git a/sapi/embed/php_embed.c b/sapi/embed/php_embed.c
index 4221e6e0ebc7389efb60b40b82d8501596a53cd8..4fcb181cc0c9a66f4921ca5e0312ea755c4dd61e 100644 (file)
--- a/sapi/embed/php_embed.c
+++ b/sapi/embed/php_embed.c
@@ -171,8 +171,7 @@ EMBED_SAPI_API int php_embed_init(int argc, char **argv)
 #endif
 
 #ifdef ZTS
-  tsrm_startup(1, 1, 0, NULL);
-  (void)ts_resource(0);
+  php_tsrm_startup();
 # ifdef PHP_WIN32
   ZEND_TSRMLS_CACHE_UPDATE();
 # endif

diff --git a/sapi/fpm/fpm/fpm_main.c b/sapi/fpm/fpm/fpm_main.c
index 843e5d913f22cb66cab0a2cdd473925e9b4516de..307c02ed7c647cfc24785d493756efb3ffd0eebd 100644 (file)
--- a/sapi/fpm/fpm/fpm_main.c
+++ b/sapi/fpm/fpm/fpm_main.c
@@ -1550,10 +1550,6 @@ int main(int argc, char *argv[])
        int ini_entries_len = 0;
        /* end of temporary locals */
 
-#ifdef ZTS
-       void ***tsrm_ls;
-#endif
-
        int max_requests = 0;
        int requests = 0;
        int fcgi_fd = 0;
@@ -1583,8 +1579,7 @@ int main(int argc, char *argv[])
 #endif
 
 #ifdef ZTS
-       tsrm_startup(1, 1, 0, NULL);
-       tsrm_ls = ts_resource(0);
+       php_tsrm_startup();
 #endif
 
        zend_signal_startup();

diff --git a/sapi/litespeed/lsapi_main.c b/sapi/litespeed/lsapi_main.c
index be97c46ff4a92f34e7b20ccaf50313771261b703..64e95d5cebf3523ce1ccdca0ec8adb4e601f8ff6 100644 (file)
--- a/sapi/litespeed/lsapi_main.c
+++ b/sapi/litespeed/lsapi_main.c
@@ -86,7 +86,6 @@ zend_compiler_globals    *compiler_globals;
 zend_executor_globals    *executor_globals;
 php_core_globals         *core_globals;
 sapi_globals_struct      *sapi_globals;
-void ***tsrm_ls;
 #endif
 
 zend_module_entry litespeed_module_entry;
@@ -1234,7 +1233,7 @@ int main( int argc, char * argv[] )
 #endif
 
 #ifdef ZTS
-    tsrm_startup(1, 1, 0, NULL);
+    php_tsrm_startup();
 #endif
 
 #if PHP_MAJOR_VERSION >= 7
@@ -1262,7 +1261,6 @@ int main( int argc, char * argv[] )
     executor_globals = ts_resource(executor_globals_id);
     core_globals = ts_resource(core_globals_id);
     sapi_globals = ts_resource(sapi_globals_id);
-    tsrm_ls = ts_resource(0);
 
     SG(request_info).path_translated = NULL;
 #endif

diff --git a/sapi/phpdbg/phpdbg.c b/sapi/phpdbg/phpdbg.c
index 11e1fcf57416fa7f3d73acb8562dbbb12ca5fc19..51c6cde122271e55c32cd729f71317b0ae07c1c2 100644 (file)
--- a/sapi/phpdbg/phpdbg.c
+++ b/sapi/phpdbg/phpdbg.c
@@ -1416,8 +1416,7 @@ int main(int argc, char **argv) /* {{{ */
 
 phpdbg_main:
 #ifdef ZTS
-       tsrm_startup(1, 1, 0, NULL);
-       (void)ts_resource(0);
+       php_tsrm_startup();
 # ifdef PHP_WIN32
        ZEND_TSRMLS_CACHE_UPDATE();
 # endif