MFH:

Hardwire function call instead of using callbacks. We don't actually need
callbacks, it was done for making 2 functions static, not to pollute the
global functions space but that had its price of 8 bytes overheat per
allocation, which is just too much. Also making the app member 32b instead
of 64b, which should save additional 4 byte, to the total of 12 byte per
allocation of a row buffer.

diff --git a/ext/mysqlnd/mysqlnd_block_alloc.c b/ext/mysqlnd/mysqlnd_block_alloc.c
index 4943624f47a6e541ce05115e12547401f465de8e..19442c5970a0946d312bd805361c5c2aa7a386b5 100644 (file)
--- a/ext/mysqlnd/mysqlnd_block_alloc.c
+++ b/ext/mysqlnd/mysqlnd_block_alloc.c
@@ -35,7 +35,7 @@ mysqlnd_mempool_free_contents(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
        DBG_ENTER("mysqlnd_mempool_dtor");
        for (i = 0; i < pool->free_chunk_list_elements; i++) {
                MYSQLND_MEMORY_POOL_CHUNK * chunk = pool->free_chunk_list[i];
-               chunk->free_chunk(chunk, FALSE TSRMLS_CC);
+               mysqlnd_mempool_free_chunk(chunk, FALSE TSRMLS_CC);
        }
        
        DBG_VOID_RETURN;
@@ -44,11 +44,14 @@ mysqlnd_mempool_free_contents(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
 
 
 /* {{{ mysqlnd_mempool_free_chunk */
-static void
+void
 mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it TSRMLS_DC)
 {
        MYSQLND_MEMORY_POOL * pool = chunk->pool;
        DBG_ENTER("mysqlnd_mempool_free_chunk");
+       if (!chunk) {
+               DBG_VOID_RETURN;
+       }
        if (chunk->from_pool) {
                /* Try to back-off and guess if this is the last block allocated */
                if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) {
@@ -60,14 +63,14 @@ mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it
                }
                pool->refcount--;
        } else {
-               mnd_free(chunk->ptr);
+               mnd_efree(chunk->ptr);
        }
        if (cache_it && pool->free_chunk_list_elements < MYSQLND_MEMORY_POOL_CHUNK_LIST_SIZE) {
                chunk->ptr = NULL;
                pool->free_chunk_list[pool->free_chunk_list_elements++] = chunk;
        } else {
                /* We did not cache it -> free it */
-               mnd_free(chunk);
+               mnd_efree(chunk);
        }
        DBG_VOID_RETURN;
 }
@@ -75,7 +78,7 @@ mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it
 
 
 /* {{{ mysqlnd_mempool_resize_chunk */
-static void
+void
 mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC)
 {
        DBG_ENTER("mysqlnd_mempool_resize_chunk");
@@ -132,11 +135,9 @@ MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool
        if (pool->free_chunk_list_elements) {
                chunk = pool->free_chunk_list[--pool->free_chunk_list_elements];
        } else {
-               chunk = mnd_malloc(sizeof(MYSQLND_MEMORY_POOL_CHUNK));
+               chunk = mnd_emalloc(sizeof(MYSQLND_MEMORY_POOL_CHUNK));
        }
 
-       chunk->free_chunk = mysqlnd_mempool_free_chunk;
-       chunk->resize_chunk = mysqlnd_mempool_resize_chunk;
        chunk->size = size;
        /*
          Should not go over MYSQLND_MAX_PACKET_SIZE, since we
@@ -145,7 +146,7 @@ MYSQLND_MEMORY_POOL_CHUNK * mysqlnd_mempool_get_chunk(MYSQLND_MEMORY_POOL * pool
        */
        chunk->pool = pool;
        if (size > pool->free_size) {
-               chunk->ptr = mnd_malloc(size);
+               chunk->ptr = mnd_emalloc(size);
                chunk->from_pool = FALSE;
        } else {
                chunk->from_pool = TRUE;
@@ -164,13 +165,13 @@ MYSQLND_MEMORY_POOL *
 mysqlnd_mempool_create(size_t arena_size TSRMLS_DC)
 {
        /* We calloc, because we free(). We don't mnd_calloc()  for a reason. */
-       MYSQLND_MEMORY_POOL * ret = mnd_calloc(1, sizeof(MYSQLND_MEMORY_POOL));
+       MYSQLND_MEMORY_POOL * ret = mnd_ecalloc(1, sizeof(MYSQLND_MEMORY_POOL));
        DBG_ENTER("mysqlnd_mempool_create");
 
        ret->free_size = ret->arena_size = arena_size;
        ret->refcount = 0;
        /* OOM ? */
-       ret->arena = mnd_malloc(ret->arena_size);
+       ret->arena = mnd_emalloc(ret->arena_size);
        ret->get_chunk = mysqlnd_mempool_get_chunk;
 
        DBG_RETURN(ret);
@@ -186,8 +187,8 @@ mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC)
        if (pool) {
                /* mnd_free will reference LOCK_access and might crash, depending on the caller...*/
                mysqlnd_mempool_free_contents(pool TSRMLS_CC);
-               mnd_free(pool->arena);
-               mnd_free(pool);
+               mnd_efree(pool->arena);
+               mnd_efree(pool);
        }
        DBG_VOID_RETURN;
 }

diff --git a/ext/mysqlnd/mysqlnd_block_alloc.h b/ext/mysqlnd/mysqlnd_block_alloc.h
index 505a23b2ee3ba26b1b1d663f24431fd1fab2608f..feace674513144feb04faa2cba706f6e86ab9fc4 100644 (file)
--- a/ext/mysqlnd/mysqlnd_block_alloc.h
+++ b/ext/mysqlnd/mysqlnd_block_alloc.h
@@ -25,6 +25,9 @@
 
 MYSQLND_MEMORY_POOL *  mysqlnd_mempool_create(size_t arena_size TSRMLS_DC);
 void                                   mysqlnd_mempool_destroy(MYSQLND_MEMORY_POOL * pool TSRMLS_DC);
+void                                   mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC);
+void                                   mysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it TSRMLS_DC);
+
 
 #endif /* MYSQLND_BLOCK_ALLOC_H */
 

diff --git a/ext/mysqlnd/mysqlnd_ps.c b/ext/mysqlnd/mysqlnd_ps.c
index ba4ea3120f936eee024f5ab91fe0b38ca317169b..36ad6888c9294ee9cdb120a11080d3cb954e6e84 100644 (file)
--- a/ext/mysqlnd/mysqlnd_ps.c
+++ b/ext/mysqlnd/mysqlnd_ps.c
@@ -885,7 +885,7 @@ mysqlnd_stmt_fetch_row_unbuffered(MYSQLND_RES *result, void *param, unsigned int
                          the bound variables. Thus we need to do part of what it does or Zend will
                          report leaks.
                        */
-                       row_packet->row_buffer->free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
+                       mysqlnd_mempool_free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
                        row_packet->row_buffer = NULL;
                }
        } else if (ret == FAIL) {
@@ -1060,13 +1060,13 @@ mysqlnd_fetch_stmt_row_cursor(MYSQLND_RES *result, void *param, unsigned int fla
                          the bound variables. Thus we need to do part of what it does or Zend will
                          report leaks.
                        */
-                       row_packet->row_buffer->free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
+                       mysqlnd_mempool_free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
                        row_packet->row_buffer = NULL;
                }
                /* We asked for one row, the next one should be EOF, eat it */
                ret = PACKET_READ(row_packet, result->conn);
                if (row_packet->row_buffer) {
-                       row_packet->row_buffer->free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
+                       mysqlnd_mempool_free_chunk(row_packet->row_buffer, TRUE TSRMLS_CC);
                        row_packet->row_buffer = NULL;
                }
                MYSQLND_INC_CONN_STATISTIC(&stmt->conn->stats, STAT_ROWS_FETCHED_FROM_CLIENT_PS_CURSOR);

diff --git a/ext/mysqlnd/mysqlnd_result.c b/ext/mysqlnd/mysqlnd_result.c
index bafc0ce0645a494bae592b38ca26f0c7bbdf974a..8166406c6c01cc1c0f75f3272c852528aaee8ff4 100644 (file)
--- a/ext/mysqlnd/mysqlnd_result.c
+++ b/ext/mysqlnd/mysqlnd_result.c
@@ -177,7 +177,7 @@ void mysqlnd_unbuffered_free_last_data(MYSQLND_RES *result TSRMLS_DC)
        if (unbuf->last_row_buffer) {
                DBG_INF("Freeing last row buffer");
                /* Nothing points to this buffer now, free it */
-               unbuf->last_row_buffer->free_chunk(unbuf->last_row_buffer, TRUE TSRMLS_CC);
+               mysqlnd_mempool_free_chunk(unbuf->last_row_buffer, TRUE TSRMLS_CC);
                unbuf->last_row_buffer = NULL;
        }
 
@@ -219,7 +219,7 @@ void mysqlnd_free_buffered_data(MYSQLND_RES *result TSRMLS_DC)
 #if MYSQLND_DEBUG_MEMORY
                DBG_INF("Freeing current_row & current_buffer");
 #endif
-               current_buffer->free_chunk(current_buffer, TRUE TSRMLS_CC);
+               mysqlnd_mempool_free_chunk(current_buffer, TRUE TSRMLS_CC);
        }
        DBG_INF("Freeing data & row_buffer");
        if (set->data) {

diff --git a/ext/mysqlnd/mysqlnd_structs.h b/ext/mysqlnd/mysqlnd_structs.h
index d9f9dfcdb5ad9c73b1462be0339619b97cdd93ee..0c80a5316c99d34688831f7f90ca9057513cea73 100644 (file)
--- a/ext/mysqlnd/mysqlnd_structs.h
+++ b/ext/mysqlnd/mysqlnd_structs.h
@@ -45,12 +45,10 @@ struct st_mysqlnd_memory_pool
 
 struct st_mysqlnd_memory_pool_chunk
 {
-       uint64_t                        app;
+       uint32_t                        app;
        MYSQLND_MEMORY_POOL *pool;
        zend_uchar                      *ptr;
-       unsigned int                            size;
-       void                            (*resize_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, unsigned int size TSRMLS_DC);
-       void                            (*free_chunk)(MYSQLND_MEMORY_POOL_CHUNK * chunk, zend_bool cache_it TSRMLS_DC);
+       uint32_t                        size;
        zend_bool                       from_pool;
 };
 

diff --git a/ext/mysqlnd/mysqlnd_wireprotocol.c b/ext/mysqlnd/mysqlnd_wireprotocol.c
index 9ff74f078c4861a051a0fa1adafa7939a9dc817f..a7bf808d639b2c3cc58701d1705f77277d99d18f 100644 (file)
--- a/ext/mysqlnd/mysqlnd_wireprotocol.c
+++ b/ext/mysqlnd/mysqlnd_wireprotocol.c
@@ -1326,7 +1326,7 @@ php_mysqlnd_read_row_ex(MYSQLND *conn, MYSQLND_MEMORY_POOL_CHUNK **buffer,
                          We need a trailing \0 for the last string, in case of text-mode,
                          to be able to implement read-only variables.
                        */
-                       (*buffer)->resize_chunk((*buffer), *data_size + 1 TSRMLS_CC);
+                       mysqlnd_mempool_resize_chunk((*buffer), *data_size + 1 TSRMLS_CC);
                        /* The position could have changed, recalculate */
                        p = (*buffer)->ptr + (*data_size - header.size);
                }
@@ -1343,7 +1343,7 @@ php_mysqlnd_read_row_ex(MYSQLND *conn, MYSQLND_MEMORY_POOL_CHUNK **buffer,
                }
        }
        if (ret == FAIL && (*buffer)) {
-               (*buffer)->free_chunk((*buffer), TRUE TSRMLS_CC);
+               mysqlnd_mempool_free_chunk(*buffer, TRUE TSRMLS_CC);
                *buffer = NULL;
        }
        *data_size -= prealloc_more_bytes;
@@ -1826,7 +1826,7 @@ void php_mysqlnd_rowp_free_mem(void *_packet, zend_bool alloca TSRMLS_DC)
        DBG_ENTER("php_mysqlnd_rowp_free_mem");
        p = (php_mysql_packet_row *) _packet;
        if (p->row_buffer) {
-               p->row_buffer->free_chunk(p->row_buffer, TRUE TSRMLS_CC);
+               mysqlnd_mempool_free_chunk(p->row_buffer, TRUE TSRMLS_CC);
                p->row_buffer = NULL;
        }
        DBG_INF_FMT("alloca=%d persistent=%d", (int)alloca, (int)p->header.persistent);