php-src/Zend/zend_list.c
Dmitry Stogov 90b7bde615 Use more compact representation for packed arrays.
- for packed arrays we store just an array of zvals without keys.
- the elements of packed array are accessible throuf as ht->arPacked[i]
  instead of ht->arData[i]
- in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar
  familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes
  (ZEND_HASH_MAP_FOREACH_*)
- introduced an additional family of macros to access elements of array
  (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX,
  ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT
- zend_hash_minmax() prototype was changed to compare only values

Because of smaller data set, this patch may show performance improvement
on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser)

TODO:
    - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET).
    - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 15:18:26 +03:00

349 lines
9.2 KiB
C

/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
| Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Authors: Andi Gutmans <andi@php.net> |
| Zeev Suraski <zeev@php.net> |
+----------------------------------------------------------------------+
*/
/* resource lists */
#include "zend.h"
#include "zend_list.h"
#include "zend_API.h"
#include "zend_globals.h"
ZEND_API int le_index_ptr;
/* true global */
static HashTable list_destructors;
ZEND_API zval* ZEND_FASTCALL zend_list_insert(void *ptr, int type)
{
zval zv;
zend_long index = zend_hash_next_free_element(&EG(regular_list));
if (index == 0) {
index = 1;
} else if (index == ZEND_LONG_MAX) {
zend_error_noreturn(E_ERROR, "Resource ID space overflow");
}
ZVAL_NEW_RES(&zv, index, ptr, type);
return zend_hash_index_add_new(&EG(regular_list), index, &zv);
}
ZEND_API zend_result ZEND_FASTCALL zend_list_delete(zend_resource *res)
{
if (GC_DELREF(res) <= 0) {
return zend_hash_index_del(&EG(regular_list), res->handle);
} else {
return SUCCESS;
}
}
ZEND_API void ZEND_FASTCALL zend_list_free(zend_resource *res)
{
ZEND_ASSERT(GC_REFCOUNT(res) == 0);
zend_hash_index_del(&EG(regular_list), res->handle);
}
static void zend_resource_dtor(zend_resource *res)
{
zend_rsrc_list_dtors_entry *ld;
zend_resource r = *res;
res->type = -1;
res->ptr = NULL;
ld = zend_hash_index_find_ptr(&list_destructors, r.type);
ZEND_ASSERT(ld && "Unknown list entry type");
if (ld->list_dtor_ex) {
ld->list_dtor_ex(&r);
}
}
ZEND_API void ZEND_FASTCALL zend_list_close(zend_resource *res)
{
if (GC_REFCOUNT(res) <= 0) {
zend_list_free(res);
} else if (res->type >= 0) {
zend_resource_dtor(res);
}
}
ZEND_API zend_resource* zend_register_resource(void *rsrc_pointer, int rsrc_type)
{
zval *zv;
zv = zend_list_insert(rsrc_pointer, rsrc_type);
return Z_RES_P(zv);
}
ZEND_API void *zend_fetch_resource2(zend_resource *res, const char *resource_type_name, int resource_type1, int resource_type2)
{
if (res) {
if (resource_type1 == res->type) {
return res->ptr;
}
if (resource_type2 == res->type) {
return res->ptr;
}
}
if (resource_type_name) {
const char *space;
const char *class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
ZEND_API void *zend_fetch_resource(zend_resource *res, const char *resource_type_name, int resource_type)
{
if (resource_type == res->type) {
return res->ptr;
}
if (resource_type_name) {
const char *space;
const char *class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): supplied resource is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
ZEND_API void *zend_fetch_resource_ex(zval *res, const char *resource_type_name, int resource_type)
{
const char *space, *class_name;
if (res == NULL) {
if (resource_type_name) {
class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
if (Z_TYPE_P(res) != IS_RESOURCE) {
if (resource_type_name) {
class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
return zend_fetch_resource(Z_RES_P(res), resource_type_name, resource_type);
}
ZEND_API void *zend_fetch_resource2_ex(zval *res, const char *resource_type_name, int resource_type1, int resource_type2)
{
const char *space, *class_name;
if (res == NULL) {
if (resource_type_name) {
class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
if (Z_TYPE_P(res) != IS_RESOURCE) {
if (resource_type_name) {
class_name = get_active_class_name(&space);
zend_type_error("%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(), resource_type_name);
}
return NULL;
}
return zend_fetch_resource2(Z_RES_P(res), resource_type_name, resource_type1, resource_type2);
}
void list_entry_destructor(zval *zv)
{
zend_resource *res = Z_RES_P(zv);
ZVAL_UNDEF(zv);
if (res->type >= 0) {
zend_resource_dtor(res);
}
efree_size(res, sizeof(zend_resource));
}
void plist_entry_destructor(zval *zv)
{
zend_resource *res = Z_RES_P(zv);
if (res->type >= 0) {
zend_rsrc_list_dtors_entry *ld;
ld = zend_hash_index_find_ptr(&list_destructors, res->type);
ZEND_ASSERT(ld && "Unknown list entry type");
if (ld->plist_dtor_ex) {
ld->plist_dtor_ex(res);
}
}
free(res);
}
ZEND_API void zend_init_rsrc_list(void)
{
zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0);
EG(regular_list).nNextFreeElement = 0;
}
void zend_init_rsrc_plist(void)
{
zend_hash_init(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1);
}
void zend_close_rsrc_list(HashTable *ht)
{
/* Reload ht->arData on each iteration, as it may be reallocated. */
uint32_t i = ht->nNumUsed;
while (i-- > 0) {
zval *p = ZEND_HASH_ELEMENT(ht, i);
if (Z_TYPE_P(p) != IS_UNDEF) {
zend_resource *res = Z_PTR_P(p);
if (res->type >= 0) {
zend_resource_dtor(res);
}
}
}
}
void zend_destroy_rsrc_list(HashTable *ht)
{
zend_hash_graceful_reverse_destroy(ht);
}
/* int return due to HashTable API */
static int clean_module_resource(zval *zv, void *arg)
{
int resource_id = *(int *)arg;
return Z_RES_TYPE_P(zv) == resource_id;
}
/* int return due to HashTable API */
static int zend_clean_module_rsrc_dtors_cb(zval *zv, void *arg)
{
zend_rsrc_list_dtors_entry *ld = (zend_rsrc_list_dtors_entry *)Z_PTR_P(zv);
int module_number = *(int *)arg;
if (ld->module_number == module_number) {
zend_hash_apply_with_argument(&EG(persistent_list), clean_module_resource, (void *) &(ld->resource_id));
return 1;
} else {
return 0;
}
}
void zend_clean_module_rsrc_dtors(int module_number)
{
zend_hash_apply_with_argument(&list_destructors, zend_clean_module_rsrc_dtors_cb, (void *) &module_number);
}
ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, const char *type_name, int module_number)
{
zend_rsrc_list_dtors_entry *lde;
zval zv;
lde = malloc(sizeof(zend_rsrc_list_dtors_entry));
lde->list_dtor_ex = ld;
lde->plist_dtor_ex = pld;
lde->module_number = module_number;
lde->resource_id = list_destructors.nNextFreeElement;
lde->type_name = type_name;
ZVAL_PTR(&zv, lde);
if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
return FAILURE;
}
return list_destructors.nNextFreeElement-1;
}
ZEND_API int zend_fetch_list_dtor_id(const char *type_name)
{
zend_rsrc_list_dtors_entry *lde;
ZEND_HASH_PACKED_FOREACH_PTR(&list_destructors, lde) {
if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) {
return lde->resource_id;
}
} ZEND_HASH_FOREACH_END();
return 0;
}
static void list_destructors_dtor(zval *zv)
{
free(Z_PTR_P(zv));
}
void zend_init_rsrc_list_dtors(void)
{
zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1);
list_destructors.nNextFreeElement=1; /* we don't want resource type 0 */
}
void zend_destroy_rsrc_list_dtors(void)
{
zend_hash_destroy(&list_destructors);
}
const char *zend_rsrc_list_get_rsrc_type(zend_resource *res)
{
zend_rsrc_list_dtors_entry *lde;
lde = zend_hash_index_find_ptr(&list_destructors, res->type);
if (lde) {
return lde->type_name;
} else {
return NULL;
}
}
ZEND_API zend_resource* zend_register_persistent_resource_ex(zend_string *key, void *rsrc_pointer, int rsrc_type)
{
zval *zv;
zval tmp;
ZVAL_NEW_PERSISTENT_RES(&tmp, -1, rsrc_pointer, rsrc_type);
GC_MAKE_PERSISTENT_LOCAL(Z_COUNTED(tmp));
GC_MAKE_PERSISTENT_LOCAL(key);
zv = zend_hash_update(&EG(persistent_list), key, &tmp);
return Z_RES_P(zv);
}
ZEND_API zend_resource* zend_register_persistent_resource(const char *key, size_t key_len, void *rsrc_pointer, int rsrc_type)
{
zend_string *str = zend_string_init(key, key_len, 1);
zend_resource *ret = zend_register_persistent_resource_ex(str, rsrc_pointer, rsrc_type);
zend_string_release_ex(str, 1);
return ret;
}