В этой статье предлагаю на примере простого массива рассмотреть как именно работают внутренние интерфейсы Traversable и ArrayAccess.

Сразу приведу список ресурсов, на которые далее по тексту будет множество ссылок.

• lxr.php.net — Удобнейший поиск по исходному коду php;
• phpinternalsbook — Полезнейший ресурс по внутренностям php. А конкретно нас интересует раздел по классам;
• Руководство по ядру PHP.

И про платформу: я писал код по ubuntu, так что для других linux дистрибутивов (да и OS X) понадобится минимум изменений (поменять apt-get). Если хотите писать под Windows, то придется поискать информацию в других интернетах (все равно никто не пишет код по windows).

Собираем PHP

Для начала соберем debug-версию PHP. Можно, конечно, писать расширение и с обычной версией, но после пары debug-флагов PHP становится намного разговорчивей.

Открываем консоль, идем в директорию, в которую собираемся стянуть исходники PHP (например ~/dev/c/) и берем код php из git-репозитория.

git clone http://git.php.net/repository/php-src.git cd php-src 

Переключаемся на свежую ветку.

git checkout PHP-5.6 

Устанавливаем необходимые для сборки PHP программы (скорей всего они у вас уже есть).

sudo apt-get install build-essential autoconf automake libtool 

Теперь осталось установить bison. В ubuntu с 14 версии идет bison идет версии 3 и выше, которую PHP не переваривает. Нам нужна версия 2.7.

wget http://launchpadlibrarian.net/140087283/libbison-dev_2.7.1.dfsg-1_amd64.deb wget http://launchpadlibrarian.net/140087282/bison_2.7.1.dfsg-1_amd64.deb  sudo dpkg -i libbison-dev_2.7.1.dfsg-1_amd64.deb sudo dpkg -i bison_2.7.1.dfsg-1_amd64.deb 

Так как мы будем собирать версию без расширений по умолчанию, нам libxml2 не понадобится. Иначе нужно будет установить libxml2-dev.

sudo apt-get install libxml2-dev 

Configure указываем, что нам нужна debug-версия, без расширений. В параметре —prefix указываем директорию, в которую будет установлен PHP.

./buildconf ./configure --disable-all --enable-debug --prefix=$HOME/dev/bin/php make && make install 

Оке, PHP готов. Запустим свежесобранный php c флагом -v и убедимся, что собрали мы то что нужно и куда нужно (а то мало ли).

~/dev/bin/php/bin/php -v 

Собираем расширение

«Скелет» расширения можно быстро сгенерировать используя ext_skel, который лежит в директории с исходниками PHP. Мы от ext_skel откажемся, потому что кроме полезного .gitignore он напихает нам сотни ненужных комментарив в файлы. А .gitignore можно взять тут.

Если все же очень хочется ext_skel, то запускать его нужно со следующими параметрами: в —extname указывается название расширения, а в —skel путь до папки skeleton.

~/dev/c/php-src/ext/ext_skel --extname=jco --skel=$HOME/dev/c/php-src/ext/skeleton/ 

Так или иначе, должна получиться директория со следующими файлами.

jco/     .gitignore     config.m4     config.w32     jco.c     php_jco.h 

Открываем config.m4 и пишем:

if test "$PHP_JCO" = "yes"; then   AC_DEFINE(HAVE_JCO, 1, [Whether you have Jco])   PHP_NEW_EXTENSION(jco, jco.c, $ext_shared) fi 

Все, дальше в config.m4 будем трогать только строчку с PHP_NEW_EXTENSION, добавляя туда новые файлы.

Теперь напишем основной заголовочный файл нашего расширения: php_jco.h. Называться он должен обязательно php_%название расширения%.h

#ifndef PHP_JCO_H #define PHP_JCO_H 1  extern zend_module_entry jco_module_entry; #define phpext_jco_ptr &jco_module_entry  //Если будем компилировать потоко-безопасную версию, то подключим нужный заголовчный файл. #ifdef ZTS #include "TSRM.h" #endif  #endif 

В этом файле мы объявляем переменную типа zend_module_entry с информацией о нашем расширении. Название переменной должно быть вида %название расширения%_module_entry.

Открываем jco.c и пишем в него следущее.

#ifdef HAVE_CONFIG_H #include "config.h" #endif  #include "php.h" #include "php_jco.h"  // Определим тестовую функцию  PHP_FUNCTION(hello_from_jco) {     // Второй параметр указывает, что мы хотим скопировать строку в памяти.     RETURN_STRING("JCO ENABLED! YEY!", 1); }  // Дадим PHP знать о нашей функции, указав ее в таблице функций модуля. const zend_function_entry jco_functions[] = {     PHP_FE(hello_from_jco,  NULL)     PHP_FE_END };  // Определим функцию, которую php будет вызывать при подключении нашего расширения PHP_MINIT_FUNCTION(jco_init) {     return SUCCESS; }   zend_module_entry jco_module_entry = {     STANDARD_MODULE_HEADER,     "jco", // название асширения     jco_functions,     PHP_MINIT(jco_init),     NULL, // MSHUTDOWN     NULL, // RINIT     NULL, // RSHUTDOWN     NULL, // MINFO     "0.1", //версия расширения     STANDARD_MODULE_PROPERTIES };  #ifdef COMPILE_DL_JCO ZEND_GET_MODULE(jco) #endif 

Основным здесь является определение переменной с информацией о нашем модуле, в которой мы указали таблицу функций, функцию запуска и прочие необходимые данные (или не указали, заменив NULL`ами). А ZEND_GET_MODULE просто создает для нашей библиотеки функцию get_module, которая возвращает переменную jco_module_entry;

Отлично, теперь мы готовы собрать наше расширение. Запустим phpize, который сделает нам конфиги для сборщика конфигов для сборщика расширения (we need to go deeper!)

~/dev/bin/php/bin/phpize 

И собираем расширение. В параметре —with-php-config указываем путь до файла php-config собраной нами debug-версии PHP

./configure --with-php-config=$HOME/dev/bin/php/bin/php-config make && make install 

Если все собралось без ошибок, то запускаем php с расширением (если нет, правим и все равно запускаем).

~/dev/bin/php/bin/php -dextension=jco.so --r "hello_from_jco();" JCO ENABLED! YEY! 

Кратко про zval и функции

Прежде чем мы перейдем к классам, кратко просмотрим что нам предлагает PHP для работы с функциями и переменными.

Для объявления функции следует пользоваться макросами PHP_FUNCTION, PHP_NAMED_FUNCTION или PHP_METHOD. Различаются они только именем полученной функции.

void prefix_name(int ht, zval *return_value, zval **return_value_ptr, zval *this_ptr, int return_value_used void ***tsrm_ls) 

Где

• ht — количество аргументов, с которыми вызвается функция
• return_value — указатель на переменную, в которую записывается результат
• return_value_ptr — указатель на указатель на возвращаемую переменную, (в случае если нужно вернуть результат по ссылке)
• this_ptr — указатель на объект, если вызывается метод
• return_value_is_used — флаг, указывающий используется ли далее возвращаемая переменная
• tsrm_ls — Thread Safe Resourse Manager Local Storage! Указатель на переменные потока

Аргументы функций определяются с помощью макросов ZEND_ARG_INFO_*.

//имя переменной, _, возвращается ли ссылка, количество обязательных переменных ZEND_BEGIN_ARG_INFO_EX(arginfo_construct, 0, 0, 1) //передается ли по ссылке, имя аргумента ZEND_ARG_INFO(0, var1) ZEND_ARG_INFO(0, var2) ZEND_END_ARG_INFO()  /* Макросы отдадут нам static const zend_arg_info arginfo_construct[] = {                                                                            { NULL, 0, NULL, 2, 0, 0, 0, 0 },     { "var1", sizeof("var1")-1, NULL, 0, 0, 0, 0, 0 },     { "var2", sizeof("var2")-1, NULL, 0, 0, 0, 0, 0 }, } */ 

ZEND_BEGIN_ARG_INFO_EX, ZEND_ARG_INFO и ZEND_END_ARG_INFO в результате дадут массив структур zend_arg_info. Причем, первый элемент массива приводится к типу zend_internal_function_info. Количество и типы полей у них одинаковые, различаются только названия.

Далее функции, с помощью макосов PHP_FE, PHP_ME, PHP_ME_MAPPING, перечисляются в таблице функций модуля/класса элементами типа zend_function_entry.

typedef struct _zend_function_entry {     const char *fname; // Имя функции доступное в PHP     void (*handler)(INTERNAL_FUNCTION_PARAMETERS); //Указатель на функцию     const struct _zend_arg_info *arg_info; //Указатель на массив агументов     zend_uint num_args; // количество аргументов (в массиве, на который указывает arg_info)     zend_uint flags; // Различные флаги } zend_function_entry 

При регистрации модуля функции заносятся в глобальную таблицу функций (function_table). При регистрации класса — в таблицу функций класса.

Чтобы получить аргументы используется функция zend_parse_parameters, которая вызывается со следующими параметрами.

• num_args — количество аргументов
• tsrm_ls — описано выше
• type_spec — строка, в которой указываются типы аргументов
• … — далее перечисляются указатели на переменные, в которые будут записаные полученные аргументы

Про zend_parse_parameters прочитать можно тут.

Для работы со переменными PHP использует zval, который хранит само значение в zvalue_value, его тип, счетчик ссылок и флаг, указывающий что перемменая используется по ссылке.

struct _zval_struct {     /* Variable information */     zvalue_value value;     /* value */     zend_uint refcount__gc;     zend_uchar type;    /* active type */     zend_uchar is_ref__gc; }; 

Для выделения памяти под zval следует использовать макросы ALLOC_ZVAL (просто выделяет память), MAKE_STD_ZVAL(ALLOC_ZVAL + инициализация значений) и другие.

Делать это следует потому, что вместо zval ALLOC_ZVAL выделит память под _zval_gc_info, который дополнительно хранит информацию для поиска циклических ссылок.

Для удаления zval используется функция zval_ptr_dtor. В отличие от zval_dtor, zval_ptr_dtor сначала уменьшает счетчик ссылок и удаляет zval только если счетчик становится равен нулю.

Так же стоит учитывать, что zvalue_value для всех значений сложнее числа хранит указатели. И потому, если у вас два zval ссылаются на одну и ту же строку в памяти, то при удалении одного их них второй будет уже ссылаться на некорректный участок памяти.

Подробнее о zval Можно почитать в phpintenralsbook. А про циклические ссылки в руководстве по PHP.

Классы

Вернемся к нашему расширению и добавим первый класс. Создаем файл jco_darray.h и пишем туда следующее.

#ifndef PHP_JCO_DARRAY_H #define PHP_JCO_DARRAY_H 1  extern zend_class_entry *jco_darray_ce;  void jco_darray_init(TSRMLS_D);  #endif 

Здесь мы поросто объявили для класса переменную jco_darray_ce типа zend_class_entry и функцию для инициализации.

Теперь создадим файл jco_darray.с.

#include "php.h" #include "jco_darray.h"  zend_class_entry *jco_darray_ce;  PHP_METHOD(jco_darray, sayHello) {     RETURN_STRING("Hello from darray!", 1); }  const zend_function_entry jco_darray_functions[] = {     // имя класса, имя функции, arginfo, флаги     PHP_ME(jco_darray, sayHello, NULL, ZEND_ACC_PUBLIC)     PHP_FE_END };  void jco_darray_init(TSRMLS_D) {     zend_class_entry tmp_ce;     INIT_CLASS_ENTRY(tmp_ce, "JCO\\DArray", jco_darray_functions);      jco_darray_ce = zend_register_internal_class(&tmp_ce TSRMLS_CC);      return; } 

Здесь интересна только функция jco_darray_init. Сначала мы создаем временную структуру для нашего класса tmp_ce и заполняем ее с помощью INIT_CLASS_ENTRY. Во втором параметре макроса указывается имя класса, которое доступно из PHP, включая namespace.

Используем функцию zend_register_internal_class, которая регистрирует наш класс в таблице классов (class_table).

Теперь добавим вызов функции jco_darray_init в функцию jco_init (файл jco.h).

PHP_MINIT_FUNCTION(jco_init) {     jco_darray_init(TSRMLS_C);     return SUCCESS; } 

И добавим новый файл jco_darray.c в config.m4 (список файлов указывается БЕЗ запятых).

PHP_NEW_EXTENSION(jco, jco.c jco_darray.c, $ext_shared) 

Так как мы изменили config.m4, нам нужно еще раз запустить phpize

~/dev/bin/php/bin/phpize --clean ~/dev/bin/php/bin/phpize   ./configure --with-php-config=$HOME/dev/bin/php/bin/php-config make && make install 

Сделаем php скрипт для тестирования нашего расширения (назовем его оригинально: jco.php)

<?php $darray = new \JCO\DArray(); echo $darray->sayHello() . PHP_EOL;  ?> 

И запускаем скрипт с нашим расширением

~/dev/bin/php/bin/php -dextension=jco.so jco.php 

D for Dynamic

С классом, который только и умеет, что говорить «Hello», далеко не уедешь. Особенно если он задумывался как массив. Время взять и этот массив написать.

Создаем дирректорию ds и добавляем туда файл darray.h, в котором объявим структуру и функции для нашего массива.

#ifndef PHP_JCO_DS_DARRAY_H #define PHP_JCO_DS_DARRAY_H 1  #include "php.h"  typedef  struct jco_ds_darray {     size_t count; // количество неNULLевых элементов     size_t length; // текущий размер массива     size_t min_length; // минимальный размер массива     size_t capacity; // мощность - на сколько будет увеличиться размер     void *elements; // массив елементов (zval) } jco_ds_darray;  jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity); void jco_ds_darray_destroy(jco_ds_darray *array);  #define jco_ds_darray_length(array) ((array)->length) #define jco_ds_darray_min_length(array) ((array)->min_length) #define jco_ds_darray_capacity(array) ((array)->capacity) #define jco_ds_darray_count(array) ((array)->count) #define jco_ds_darray_first(array) ((zval *)(array)->elements)  #endif 

Теперь в файле ds/darray.c определим объявленные выше функции. Пока что это только создание и удаление структуры.

#include "ds/darray.h" #include "php.h"  jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity) {     jco_ds_darray *array = emalloc(sizeof(jco_ds_darray));     if (!array) {         return NULL;     }      array->count = 0;     array->length = 0;     array->min_length = size;     array->capacity = capacity;     array->elements = NULL;       return array; }   void jco_ds_darray_destroy(jco_ds_darray *array) {     if (!array) {         return;     }      efree(array); } 

У нас есть класс, есть массив, и нужно их как-то связать. Для этого давайте проясним как php работает с объектами.

Для хранения объектов в переменных (которые zval) используется структура zend_object_value, которая имеет следующие поля.

typedef struct _zend_object_value {     zend_object_handle handle;     const zend_object_handlers *handlers; } zend_object_value; 

• handlers — структура с указателями на функции, которые вызывает php когда мы что-нибудь делаем с объектом (читаем свойство, вызываем метод и т.п.). Подробней про zend_object_handlers мы поговорим чуть позже.
• handle — это обычный int, «id» объекта в хранилище объектов object_store. При создании объекта php помещает структуру zend_object в object_store и возвращает нам целочисленный handle. При этом, если у класса есть функция create_object, то для создания zend_object вызывается она. Подробней про все это можно прочитать в php internals book

Итак, все что нам нужно — это отдавать свою структуру, которая расширяет zend_object. Для этого напишем свою функцию create_object и функцию для освобождения выделенной под структуру памяти. Добавим их после объявления jco_darray_ce.

 zend_object_handlers jco_darray_handlers;  typedef struct jco_darray {     zend_object std;     jco_ds_darray *array; } jco_darray;  static void jco_darray_free_object_storage(jco_darray *intern TSRMLS_DC) {     zend_object_std_dtor(&intern->std TSRMLS_CC);      if (intern->array) {         jco_ds_darray_destroy(intern->array);     }      efree(intern); }  zend_object_value jco_darray_create_object(zend_class_entry *class_type TSRMLS_DC) {     zend_object_value retval;      jco_darray *intern = emalloc(sizeof(jco_darray));     memset(intern, 0, sizeof(jco_darray));      //Инициализирует объект: указавает ссылку на класс и обнуляет прочие поля     zend_object_std_init(&intern->std, class_type TSRMLS_CC);     //Копируем свойства класса в объект     object_properties_init(&intern->std, class_type);      // добавляет объект в хранилище объектов (object_store)     retval.handle = zend_objects_store_put(         intern,         (zend_objects_store_dtor_t) zend_objects_destroy_object, // стандартный деструктор объекта         (zend_objects_free_object_storage_t) jco_darray_free_object_storage, //наша функция бля освобождения памяти объекта         NULL // функция копирования, нам не нужна         TSRMLS_CC     );      //указываем ссылку на структуру с функциями-обаботчиками для объектов     retval.handlers = &jco_darray_handlers;      return retval; } 

zend_objects_store_put принимает три функции:

• dtor (zend_objects_destroy_object) — деструктор объекта, который вызывается когда счетчик ссылок на объект становится 0, либо при завершении скрипта. Деструктор так же отвечает за выполнение пользовательского кода (__destruct). При этом, в определенном случае php может опустить вызов деструктора (например, если при вызове другого __destruct было выброшено исключение или вызван exit())
• free_storage (zend_objects_free_object_storage) — функция, которая освобождает память выделенную под объект (zend_object). Вызывается всегда: либо когда счетчик ссылок на объект становится 0, либо при завершении скрипта.
• clone — функция, которая вызвается при копировании объекта. По умолчанию игнорируется, и чтобы ее использовать нужно явно указать обработчиком копирования функцию zend_objects_store_clone_obj. Намного проще просто взять и использовать собственную функцию сразу. Поэтому в 99% случаев в clone просто передаем NULL.

В функцию jco_darray_init добавим следующие строки

    //Указываем собственную функцию для создания zend_object     jco_darray_ce->create_object = jco_darray_create_object;      //Копируем стандартные обаботчики для объектов     memcpy(&jco_darray_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); 

А где же массив? А массив мы будем создавать в конструкторе.

PHP_METHOD(jco_darray, __construct) {     jco_darray *intern;     long size = 0;     long capacity = 0;      zend_error_handling error_handling;      //Заменим обработчик ошибок так, чтобы при ошибке получения аргументов конструктора было выброшено исключение     zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);      //третий параметр указывает на типы переменных (l - long), последующие - указатели на переменные     if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &size, &capacity) == FAILURE) {         zend_restore_error_handling(&error_handling TSRMLS_CC);         return;     }      // Восстанавливаем стандартный обработчик ошибок     zend_restore_error_handling(&error_handling TSRMLS_CC);      if (size <= 0) {         zend_throw_exception(NULL, "Array size must be positive", 0 TSRMLS_CC);         return;     }      if (capacity < 0) {         zend_throw_exception(NULL, "Array capacity must be positive or 0", 0 TSRMLS_CC);         return;     }      // получаем объект по handle     intern = zend_object_store_get_object(getThis() TSRMLS_CC);      intern->array = jco_ds_darray_create((size_t)size, (size_t)capacity);     if (!intern->array) {         zend_throw_exception(NULL, "Failed to allocate array", 0 TSRMLS_CC);     }      return; } 

,
Добавляем __construct в таблицу функций.

 ZEND_BEGIN_ARG_INFO_EX(arginfo_construct, 0, 0, 1) //передается ли по ссылке, имя аргумента ZEND_ARG_INFO(0, size) ZEND_ARG_INFO(0, capacity) ZEND_END_ARG_INFO()  const zend_function_entry jco_darray_functions[] = {     PHP_ME(jco_darray, __construct, arginfo_construct, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, sayHello, arginfo_void, ZEND_ACC_PUBLIC)     PHP_FE_END }; 

Время собрать extension и убедится, что все компилируется нормально. Запускаем phpize, чтобы подхватить изменения config.m4 (Обещаю, это в последний раз)

~/dev/bin/php/bin/phpize --clean ~/dev/bin/php/bin/phpize  ./configure --with-php-config=$HOME/dev/bin/php/bin/php-config make && make install 

И запускаем тестовый скрипт

~/dev/bin/php/bin/php -dextension=jco.so jco.php 

ArrayAccess

В файле ds/darray.h добавим объявления функций для работы с массивом: get, set, unset (и clone заодно).

jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity); jco_ds_darray *jco_ds_darray_clone(jco_ds_darray *array); void jco_ds_darray_destroy(jco_ds_darray *array); zval *jco_ds_darray_get(jco_ds_darray *array, size_t index); zval *jco_ds_darray_set(jco_ds_darray *array, size_t index, zval *value); void jco_ds_darray_unset(jco_ds_darray *array, size_t index); 

И напишем эти функции

    #include "ds/darray.h" #include "php.h"  #define ELEM_SIZE (sizeof(zval))  // Увеличиваем память под элементы массива.  // Если указан index, то выделяем память кратно capacity настолько, // чтобы было место для index-го элемента static inline int _jco_ds_darray_expand(jco_ds_darray *array, size_t index) {     if (array && array->capacity > 0) {         size_t capacity = array->capacity;         size_t max_elements = array->length;         size_t expand_count;         if (index) {             expand_count = ((index + 1) / capacity) * capacity + capacity;         } else {             expand_count = (max_elements + capacity);         }          zval *elements;         if (max_elements == 0 && !array->elements) {             elements = (zval *)emalloc(ELEM_SIZE * expand_count);         } else {             elements = (zval *)erealloc((void *)array->elements, ELEM_SIZE * expand_count);         }          if (elements) {             zval *ptr = (elements + max_elements);             memset(ptr, 0, array->capacity * ELEM_SIZE);              array->length = expand_count;             array->elements = elements;              return 1;         }          return 0;     }      return 0; }   jco_ds_darray *jco_ds_darray_create(size_t size, size_t capacity) {     jco_ds_darray *array = emalloc(sizeof(jco_ds_darray));     if (!array) {         return NULL;     }      array->length = 0;     array->min_length = size;     array->capacity = size;     array->count = 0;     array->elements = NULL;      if (size > 0 && !_jco_ds_darray_expand(array, 0)) {         efree(array);          return NULL;     }      array->length = size;     array->capacity = capacity;      return array; }   void jco_ds_darray_destroy(jco_ds_darray *array) {     if (!array) {         return;     }      if (array->length > 0) {         zval *elem = (zval *)array->elements;         while (array->length--) {             if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {                 zval_dtor(elem);             }             elem++;         }     }      if (array->elements) {         efree(array->elements);     }      efree(array); }  jco_ds_darray *jco_ds_darray_clone(jco_ds_darray *array) {     if (!array) {         return NULL;     }      jco_ds_darray *new_array = emalloc(sizeof(jco_ds_darray));     if (!new_array) {         return NULL;     }      new_array->count = array->count;     new_array->length = array->length;     new_array->min_length = array->min_length;     new_array->capacity = array->capacity;     new_array->elements = (zval *)emalloc(ELEM_SIZE * array->length);     if (!new_array->elements) {         efree(new_array);          return NULL;     }      memcpy(new_array->elements, array->elements, ELEM_SIZE * array->length);     //memcpy скопировал нам только zval`ы, но они указывают на одни те же значения     //Чтобы это исправить нужно пройтись по элементам функцией zval_copy_ctor     size_t index;     for (index = 0; index < array->length; index++) {         zval *elem = (zval *)new_array->elements + index;         if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {             zval_copy_ctor(elem);         }     }        return new_array;  }   zval *jco_ds_darray_get(jco_ds_darray *array, size_t index) {     if (!array || array->length < (index + 1)) {         return NULL;     }      zval *elem = (zval *)(array->elements) + index;     if (!elem || Z_TYPE_P(elem) == IS_NULL) {         return NULL;     }      //На всякий случай убедимся, что is_ref__gc = 0     Z_UNSET_ISREF_P(elem);     return elem; }   void jco_ds_darray_unset(jco_ds_darray *array, size_t index) {     if (!array || array->length < (index + 1)) {         return;     }      zval *elem = (zval *)array->elements + index;     if (elem != NULL && Z_REFCOUNT_P(elem) > 0) {         if (Z_TYPE_P(elem) != IS_NULL) {             array->count--;         }          zval_dtor(elem);         *elem = (zval) {0};     }  }   zval *jco_ds_darray_set(jco_ds_darray *array, size_t index, zval *value) {     if (!array) {         return;     }      if ((index + 1) > array->length) {         if (array->capacity == 0) {             return NULL;         }          if (!_jco_ds_darray_expand(array, index)) {             return NULL;         }     }     zval *elem = (zval *)array->elements + index;     int prev_is_not_null = 0;     if (Z_REFCOUNT_P(elem) > 0 && Z_TYPE_P(elem)) {         zval_dtor(elem);         prev_is_not_null = 1;     }      elem->value = value->value;     elem->type  = value->type;     elem->refcount__gc = 1;     elem->is_ref__gc = 0;     zval_copy_ctor(elem);      if (prev_is_not_null && Z_TYPE_P(elem) == IS_NULL) {         array->count--;     }     else if (!prev_is_not_null && Z_TYPE_P(elem) != IS_NULL) {         array->count++;     }       return elem; } 

Как видно, в jco_ds_darray_set ALLOC_ZVAL мы не использовали, а использовали ранее выделенную память. В нашем случае нам важно, чтобы массив элементов был непрерывным в памяти. К тому же напрямую элементы массива в пользовательский код мы отдавать не будем, так что GC будет лишним. Соответсвенно и для удаления мы используем zval_dtor вместо zval_ptr_dtor.

Теперь, используя новые функции, реализуем интерфейс ArrayAccess.

    PHP_METHOD(jco_darray, count) {     jco_darray *intern;     long count;      intern = zend_object_store_get_object(getThis() TSRMLS_CC);     count = (long)jco_ds_darray_count(intern->array);      ZVAL_LONG(return_value, count); }  PHP_METHOD(jco_darray, length) {     jco_darray *intern;     long length;      intern = zend_object_store_get_object(getThis() TSRMLS_CC);     length = (long) jco_ds_darray_length(intern->array);      ZVAL_LONG(return_value, length); }  PHP_METHOD(jco_darray, offsetSet) {     jco_darray *intern;     zval *val;     long index;       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz", &index, &val) == FAILURE) {         zend_throw_exception(NULL, "Failed to parse arguments", 0 TSRMLS_CC);         return;     }      intern = zend_object_store_get_object(getThis() TSRMLS_CC);     jco_ds_darray_set(intern->array, (size_t)index, val);  }  PHP_METHOD(jco_darray, offsetUnset) {     jco_darray *intern;     long index;      if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {         zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);         return;     }       intern = zend_object_store_get_object(getThis() TSRMLS_CC);     jco_ds_darray_unset(intern->array, (size_t)index); }  PHP_METHOD(jco_darray, offsetGet) {     jco_darray *intern;     long index;      if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {         zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);         return;     }       intern = zend_object_store_get_object(getThis() TSRMLS_CC);     zval *val = jco_ds_darray_get(intern->array, (size_t)index);      if (val) {         //назначиние, источник, вызвать zval_copy_ctor, вызвать zval_ptr_dtor         ZVAL_ZVAL(return_value, val, 1, 0);     } else {         ZVAL_NULL(return_value);     } }  PHP_METHOD(jco_darray, offsetExists) {     jco_darray *intern;     long index;      if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {         zend_throw_exception(NULL, "Invalid index passed", 0 TSRMLS_CC);         return;     }       intern = zend_object_store_get_object(getThis() TSRMLS_CC);     zval *val = jco_ds_darray_get(intern->array, (size_t)index);     if (val) {         ZVAL_TRUE(return_value);     } else {         ZVAL_FALSE(return_value);     } } 

Добавим функции в таблицу функций класса.

ZEND_BEGIN_ARG_INFO_EX(arginfo_jco_darray_offset, 0, 0, 1) ZEND_ARG_INFO(0, offset) ZEND_END_ARG_INFO()  ZEND_BEGIN_ARG_INFO_EX(arginfo_jco_darray_offset_value, 0, 0, 2) ZEND_ARG_INFO(0, offset) ZEND_ARG_INFO(0, value) ZEND_END_ARG_INFO()  const zend_function_entry jco_darray_functions[] = {     PHP_ME(jco_darray, __construct, arginfo_construct, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, offsetSet, arginfo_jco_darray_offset_value, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, offsetGet, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, offsetUnset, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, offsetExists, arginfo_jco_darray_offset, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, count, arginfo_void, ZEND_ACC_PUBLIC)     PHP_ME(jco_darray, length, arginfo_void, ZEND_ACC_PUBLIC)     PHP_FE_END }; 

Теперь, укажем php что наш класс реализует интерфейс ArrayAccess

    zend_class_implements(jco_darray_ce TSRMLS_CC, 1, zend_ce_arrayaccess); 

Последние параметры в функции — это количество интерфейсов и class_entry интерфейсов через запятую.

zend_ce_arrayaccess объявлен в файле zend_interfaces.h (вместе с zend_ce_traversable, zend_ce_aggregate, zend_ce_iterator и zend_ce_serializable), который нам нужно включить в файл jco_darray.c

#include "php.h" #include "zend_interfaces.h" #include "jco_darray.h" #include "ds/darray.h" 

Напишем тестовый код и заодно сравним с наш класс с обычным массивом

<?php ini_set("memory_limit", "512M");  $data = range(1, 500000);  $t1 = microtime(true); $m1 = memory_get_usage();  $jar = new \JCO\DArray(500000, 0); foreach($data as $index => &$val) {     $jar[$index] = $val * 3; }  echo "JCO\Darray" . PHP_EOL; echo "TIME: " . (microtime(true) - $t1) . PHP_EOL; echo "MEMORY: " . ((memory_get_usage() - $m1)/1048576) . PHP_EOL; gc_collect_cycles();   $t1 = microtime(true); $m1 = memory_get_usage(); $ar = []; foreach($data as $index => &$val) {     $ar[$index] = $val * 3; }  echo "AR" . PHP_EOL; echo "TIME: " . (microtime(true) - $t1) . PHP_EOL; echo "MEMORY: " . ((memory_get_usage() - $m1)/1048576) . PHP_EOL; gc_collect_cycles();  ?> 

Cкомпилируем и запустим php c нашим расширением

    make && make install 

~/dev/bin/php/bin/php -dextension=jco.so jco.php  JCO\Darray TIME: 0.43633484840393 MEMORY: 11.44548034668 Array TIME: 0.3345410823822 MEMORY: 137.51664733887 

Эй… Наш код получился медленней чем стандартный массив php!

Object Handlers

Давайте разберемся, почему наш массив получился таким медленным. Для этого вспомним про object_handlers, который упоминался выше.

ZEND_API zend_object_handlers std_object_handlers = {     zend_objects_store_add_ref,             /* add_ref */     zend_objects_store_del_ref,             /* del_ref */     zend_objects_clone_obj,                 /* clone_obj */      zend_std_read_property,                 /* read_property */     zend_std_write_property,                /* write_property */     zend_std_read_dimension,                /* read_dimension */     zend_std_write_dimension,               /* write_dimension */     zend_std_get_property_ptr_ptr,          /* get_property_ptr_ptr */     NULL,                                   /* get */     NULL,                                   /* set */     zend_std_has_property,                  /* has_property */     zend_std_unset_property,                /* unset_property */     zend_std_has_dimension,                 /* has_dimension */     zend_std_unset_dimension,               /* unset_dimension */     zend_std_get_properties,                /* get_properties */     zend_std_get_method,                    /* get_method */     NULL,                                   /* call_method */     zend_std_get_constructor,               /* get_constructor */     zend_std_object_get_class,              /* get_class_entry */     zend_std_object_get_class_name,         /* get_class_name */     zend_std_compare_objects,               /* compare_objects */     zend_std_cast_object_tostring,          /* cast_object */     NULL,                                   /* count_elements */     zend_std_get_debug_info,                /* get_debug_info */     zend_std_get_closure,                   /* get_closure */     zend_std_get_gc,                        /* get_gc */     NULL,                                   /* do_operation */     NULL,                                   /* compare */ }; 

Для того, чтобы работать с объектом как с массивом, используются следующие функции: read_dimension, write_dimension, has_dimension и unset_dimension.

Если мы посмотрим код zend_std_read_dimension, то увидим, что именно здесь происходит проверка на интерфейс ArrayAccess и вызывается соответсвующий метод offsetGet. А вызов php функции, как мы значем, это очень (ОЧЕНЬ!) медленно.

Решение очевидно: напишем свои функции (а заодно count и clone).

 //Вспомогательная функция, которая приведет zval к long static inline long zval_to_long(zval *zv) {     if (Z_TYPE_P(zv) == IS_LONG) {         return Z_LVAL_P(zv);     } else {         zval tmp = *zv;         zval_copy_ctor(&tmp);         convert_to_long(&tmp);         return Z_LVAL(tmp);     } }  static zend_object_value jco_darray_clone(zval *object TSRMLS_DC) {     jco_darray *old_object = zend_object_store_get_object(object TSRMLS_CC);      zend_object_value new_object_val = jco_darray_create_object(Z_OBJCE_P(object) TSRMLS_CC);     jco_darray *new_object = zend_object_store_get_object_by_handle(new_object_val.handle TSRMLS_CC);      //Копируем свойства объекта     zend_objects_clone_members(         &new_object->std, new_object_val,         &old_object->std, Z_OBJ_HANDLE_P(object) TSRMLS_CC     );      new_object->array = jco_ds_darray_clone(old_object->array);      if (!new_object->array) {         zend_throw_exception(NULL, "Failed to clone jco_darray", 0 TSRMLS_CC);     }      return new_object_val; }    static zval *jco_darray_read_dimension(zval *object, zval *zv_offset, int type TSRMLS_DC) {     jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);          if (intern->std.ce->parent) {         return zend_get_std_object_handlers()->read_dimension(object, zv_offset, type TSRMLS_CC);     }      if (!zv_offset) {         zend_throw_exception(NULL, "Cannot append to a jco_darray", 0 TSRMLS_CC);         return NULL;     }      long offset = zval_to_long(zv_offset);     if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {         zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);         return NULL;     }      zval *return_value;     zval *value = jco_ds_darray_get(intern->array, offset);      if (value) {          if (type != BP_VAR_R && type != BP_WAR_RW) {             return_value = value;             Z_SET_ISREF_P(return_value);         } else {             MAKE_STD_ZVAL(return_value);             ZVAL_ZVAL(return_value, value, 1, 0);             Z_DELREF_P(return_value);         }     } else {         MAKE_STD_ZVAL(return_value);         ZVAL_NULL(return_value);         Z_DELREF_P(return_value);     }      return return_value; }   static void jco_darray_write_dimension(zval *object, zval *zv_offset, zval *value TSRMLS_DC) {     jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);      if (intern->std.ce->parent) {         return zend_get_std_object_handlers()->write_dimension(object, zv_offset, value TSRMLS_CC);     }       if (!zv_offset) {         zend_throw_exception(NULL, "Cannot append to a jco_darray", 0 TSRMLS_CC);     }      long offset = zval_to_long(zv_offset);     if (offset < 0) {         zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);     }      zval *saved_val = jco_ds_darray_set(intern->array, (size_t)offset, value);     if (saved_val == NULL) {         zend_throw_exception(NULL, "Error occured during dimension write", 0 TSRMLS_CC);     } }    static int jco_darray_has_dimension(zval *object, zval *zv_offset, int check_empty TSRMLS_DC) {     jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);      if (intern->std.ce->parent) {         return zend_get_std_object_handlers()->has_dimension(object, zv_offset, check_empty TSRMLS_CC);     }      long offset = zval_to_long(zv_offset);     if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {         return 0;     }      zval *value = jco_ds_darray_get(intern->array, offset);     if (value == NULL) {         return 0;     }      if (check_empty) {         return zend_is_true(value);     } else {         return Z_TYPE_P(value) != IS_NULL;     }  }  static void jco_darray_unset_dimension(zval *object, zval *zv_offset TSRMLS_DC) {     jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);      if (intern->std.ce->parent) {         return zend_get_std_object_handlers()->unset_dimension(object, zv_offset TSRMLS_CC);     }      long offset = zval_to_long(zv_offset);     if (offset < 0 || offset > jco_ds_darray_length(intern->array)) {         zend_throw_exception(NULL, "Offset out of range", 0 TSRMLS_CC);     }      jco_ds_darray_unset(intern->array, offset); }  int jco_darray_count_elements(zval *object, long *count TSRMLS_DC) {     jco_darray *intern = zend_object_store_get_object(object TSRMLS_CC);      if (intern->std.ce->parent) {         return zend_get_std_object_handlers()->count_elements(object, count TSRMLS_CC);     }      if (intern && intern->array) {         *count = (long)jco_ds_darray_count(intern->array);         return SUCCESS;     } else {         *count = 0;         return FAILURE;     } } 

Здесь интересна функция jco_darray_read_dimension, которая третьим параметром принимает целочисленный type. Это флаг, указывающий в каком контексте была вызвана функция, и может примать значения BP_VAR_R, BP_VAR_W, BP_VAR_RW, BP_VAR_IS либо BP_VAR_UNSET.

$var[0][1]; // оба случая read_dimension BP_VAR_R $var[0][1] = 1; // [0] - read_dimension BP_VAR_W, а [1] - write_dimension  isset($var[0][1]); // [0] - read_dimension BP_VAR_IS, а[1] - has_dimension 

Если мы проигнорируем type и всегда будем возвращать копию значения, то во втором случае выше ничего не произойдет и значение массива внутри массива не поменяется. Чтобы это исправить в случае BP_VAR_W мы отдаем значение прямо из массива, а чтобы сборщик мусора не попытался его удалить, ставим zval->is_ref__gc = 1 (такой вот хак).

В каждой функции мы проверяем наличие (intern->std.ce->parent). Это на случай если кто-то отнаследуется от нашего класса и перезапишет методы ArrayAccess.

Чтобы php использовал наши функции вместо стандартных, добавим в jco_darray_init слудующие строчки

    jco_darray_handlers.has_dimension   = jco_darray_has_dimension;     jco_darray_handlers.read_dimension  = jco_darray_read_dimension;     jco_darray_handlers.write_dimension = jco_darray_write_dimension;     jco_darray_handlers.unset_dimension = jco_darray_unset_dimension;     jco_darray_handlers.count_elements  = jco_darray_count_elements;     jco_darray_handlers.clone_obj = jco_darray_clone; 

Cкомпилируем и запустим php c нашим расширением

    make && make install 

~/dev/bin/php/bin/php -dextension=jco.so jco.php  JCO\Darray TIME: 0.18597507476807 MEMORY: 11.44548034668 Array TIME: 0.33455300331116 MEMORY: 137.51664733887 

Потребление памяти на порядок ниже, а скорость выполнения выше почти в два раза. Успех!

Traversable

Чтобы наш объект был совсем массивом, нужно сделать его итерируемым. В object_handlers для итерации функций нет, но вот в zend_class_entry есть сразу функция get_iterator и структура iterator_funcs.

get_iterator возвращает zend_object_iterator, который используется для итерации (например в foreach).

struct _zend_object_iterator {     void *data; // указатель на доп. данные класса     zend_object_iterator_funcs *funcs; // указатель на функции итерирования и удаления итератора     ulong index; //поле для опкодов. Мы его трогать не будем }; 

iterator_funcs, насколько я понял, нужен для работы пользовательского кода: классов, которые реализуют интерфейсы Iterator или IteratorAggregate. Поля zf_* — (кэши?) соответвующих пользовательских php функций. А funcs аналогичен полю из _zend_object_iterator. Было бы хорошо, если бы в комментариях кто-нибудь дал более полное разъяснение как именно используется iterator_funcs.

В файле jco_darray.c после определения структуры jco_darray добавим структуру для хранения данных, нужных для итерирования.

typedef struct _jco_darray_iterator_data {     zval *object_zval; //указатель на php объект (нужен, чтобы в процессе итерирвания его внезапно не уничтожили)     jco_darray *object; // указатель на zend_object     size_t offset; // текущая позиция     zval *current; // текущее значение } jco_darray_iterator_data;  

Теперь напишем функцию get_iterator. В jco_darray.c после функции count_elements добавим функцию jco_darray_get_iterator.

//by_ref - флаг, указывающий что значения запрашиваются по ссылке. zend_object_iterator *jco_darray_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) {     zend_object_iterator *iter;     jco_darray_iterator_data *iter_data;      if (by_ref) {         zend_throw_exception(NULL, "UPS, no by reference iteration!", 0 TSRMLS_CC);         return NULL;     }      iter = emalloc(sizeof(zend_object_iterator));     iter->funcs = &jco_darray_iterator_funcs;      iter_data = emalloc(sizeof(jco_darray_iterator_data));     iter_data->object_zval = object;     Z_ADDREF_P(object);      iter_data->object = zend_object_store_get_object(object TSRMLS_CC);     iter_data->offset = 0;     iter_data->current = NULL;      iter->data = iter_data;      return iter; }  

И функции итерирования. Чтобы не объявлять их отдельно, добавим их перед функцией get_iterator.

static void jco_darray_iterator_dtor(zend_object_iterator *intern TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *)intern->data;      if (data->current != NULL) {         zval_ptr_dtor(&data->current);     }      zval_ptr_dtor((zval **)&data->object_zval);     efree(data);     efree(intern); }  static int jco_darray_iterator_valid(zend_object_iterator *intern TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *)intern->data;      return jco_ds_darray_length(data->object->array) > data->offset ? SUCCESS : FAILURE; }  // static void jco_darray_iterator_get_current_data(zend_object_iterator *intern, zval ***data TSRMLS_DC) {     jco_darray_iterator_data *iter_data = (jco_darray_iterator_data *)intern->data;      if (iter_data->current != NULL) {         zval_ptr_dtor(&iter_data->current);         iter_data->current = NULL;     }      if (iter_data->offset < jco_ds_darray_length(iter_data->object->array)) {         zval *value = jco_ds_darray_get(iter_data->object->array, iter_data->offset);         if (value != NULL) {             MAKE_STD_ZVAL(iter_data->current);             ZVAL_ZVAL(iter_data->current, value, 1, 0);              *data = &iter_data->current;         } else {             *data = NULL;         }      } else {         *data = NULL;     } }   #if ZEND_MODULE_API_NO >= 20121212 // версии php 5.5+ static void jco_darray_iterator_get_current_key(zend_object_iterator *intern, zval *key TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;     ZVAL_LONG(key, data->offset); } #else //В более ранних версиях строковые и численные ключи нужно отдавать в отдельных переменных // и возвращать HASH_KEY_IS_STRING, HASH_KEY_IS_LONG или HASH_KEY_NON_EXISTANT static int jco_darray_iterator_get_current_key(zend_object_iterator *intern, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;      *int_key = (ulong) data->offset;     return HASH_KEY_IS_LONG; } #endif  static void jco_darray_iterator_move_forward(zend_object_iterator *intern TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;      data->offset++; }  static void jco_darray_iterator_rewind(zend_object_iterator *intern TSRMLS_DC) {     jco_darray_iterator_data *data = (jco_darray_iterator_data *) intern->data;      data->offset = 0;     data->current = NULL; }  static zend_object_iterator_funcs jco_darray_iterator_funcs = {     jco_darray_iterator_dtor,     jco_darray_iterator_valid,     jco_darray_iterator_get_current_data,     jco_darray_iterator_get_current_key,     jco_darray_iterator_move_forward,     jco_darray_iterator_rewind,     NULL }; 

Осталось только в jco_darray_init указать для класса наш get_iterator.

    jco_darray_ce->get_iterator = jco_darray_get_iterator;     jco_darray_ce->iterator_funcs.funcs = &jco_darray_iterator_funcs; 

Добавим в тестовый скрипт foreach

foreach($jar as $val) {     if(($val % 100000) == 0) {         echo $val . PHP_EOL;     } } 

Cкомпилируем и запустим php c нашим расширением

    make && make install 

~/dev/bin/php/bin/php -dextension=jco.so jco.php 

Заключение

На этом, в принципе, все. С помощью интерфейсов Traversable и ArrayAccess мы написали быстрый индексный массив, который расходует на порядок меньше памяти, чем стандартный массив в PHP. За бортом осталась сериализация, но за ней советую обратиться к соответсвующей главе php internals book.

Несмотря на то, что в новом phpng изменилось очень многое (среди прочего сильно оптимизировали массивы), реализация внутренних интерфейсов для объектов, на момент написания статьи, не изменилась.

И да, я соврал. Вот вам картинка.

ссылка на оригинал статьи http://habrahabr.ru/post/260983/