Analyse du code source du gestionnaire de sécurité des threads PHP-TSRM

Lors de la visualisation du code source PHP ou du développement d'extensions PHP, un grand nombre de macros TSRMLS_ apparaîtront à la position des paramètres de fonction. Ces macros sont fournies par Zend pour le mécanisme de sécurité des threads (Zend Thread `Safety, ZTS en abrégé). assurer Thread safety est une solution fournie pour empêcher que l'interpréteur PHP soit chargé et exécuté sous la forme d'un module dans un environnement multithread, provoquant des erreurs de lecture dans certaines ressources publiques internes.

Quand avez-vous besoin d'utiliser l'environnement TSRM ? Thread), dans ce cas, vous devez utiliser une version thread-safe de PHP, c'est-à-dire activer TSRM. Sous Linux, vous spécifiez si vous souhaitez activer TSRM. lors de la compilation de PHP Sous Windows, une version thread-safe et une version non thread-safe de PHP sont fournies.

Comment implémenter TSRM en PHP

Dans un environnement multithread normal, les verrous mutex sont ajoutés aux ressources publiques, mais PHP ne choisit pas de verrouiller, car le verrouillage peut entraîner une perte de performances. La solution de PHP consiste à copier toutes les ressources publiques du noyau PHP actuel pour chaque thread. Chaque thread pointe vers sa propre zone de ressources publiques sans s'affecter les uns les autres, et chacun exploite ses propres ressources publiques.

Que sont les ressources publiques ?

Il s'agit d'une variété de définitions de structure de structure

Structure de données TSRM

structure de thread tsrm_tls_entry, chaque thread Il y a une copie de cette structure

description du champ

typedef struct _tsrm_tls_entry tsrm_tls_entry;
struct _tsrm_tls_entry {
    void **storage;   
    int count;
    THREAD_T thread_id;
    tsrm_tls_entry *next;
}
static tsrm_tls_entry   **tsrm_tls_table = NULL //线程指针表头指针
static int  tsrm_tls_table_size;  //当前线程结构体数量

void **storage ：资源指针、就是指向自己的公共资源内存区
int count : 资源数、就是 PHP内核 + 扩展模块 共注册了多少公共资源
THREAD_T thread_id ： 线程id
tsrm_tls_entry *next：指向下一个线程指针，因为当前每一个线程指针都存在一个线程指针表里（类似于hash表），这个next可以理解成是hash冲突链式解决法.
tsrm_resource_type 公共资源类型结构体、注册了多少公共资源就有多少个该结构体

description du champ

typedef struct {
    size_t size;
    ts_allocate_ctor ctor;
    ts_allocate_dtor dtor;
    int done; 
} tsrm_resource_type;
static tsrm_resource_type   *resource_types_table=NULL;  //公共资源类型表头指针
static int  resource_types_table_size; //当前公共资源类型数量

identifiant global de la ressource

size_t size : 资源大小
ts_allocate_ctor ctor: 构造函数指针、在给每一个线程创建该资源的时候会调用一下当前ctor指针
ts_allocate_dtor dtor : 析构函数指针、释放该资源的时候会调用一下当前dtor指针
int done : 资源是否已经销毁 0:正常 1:已销毁

Quoi est un identifiant de ressource global

typedef int ts_rsrc_id;
static ts_rsrc_id   id_count;

TSRM générera un identifiant unique pour chaque ressource lors de l'enregistrement des ressources publiques. Vous devez spécifier l'identifiant de ressource correspondant lors de l'obtention de la ressource à l'avenir.

Pourquoi avons-nous besoin d'un identifiant de ressource global

Parce que chacun de nos fils copiera toutes les ressources publiques actuellement enregistrées, c'est-à-dire un malloc() et un grand tableau. L'index du tableau, c'est-à-dire que pour obtenir la ressource correspondante, vous devez spécifier l'identifiant de la ressource correspondante.

C'est facile à comprendre :

Parce que TSRM permet à chaque thread de pointer vers sa propre pile de ressources publiques (tableau), et que vous voulez trouver ce que vous voulez dans cette pile de ressources publiques. obtenues via l'identifiant de ressource correspondant. S'il ne s'agit pas de cette version thread-safe, alors ces ressources publiques ne seront pas regroupées dans une pile et elles pourront être obtenues directement via le nom correspondant.

Processus d'exécution approximatif

Lors de l'initialisation du noyau, initialisez TSRM, enregistrez les ressources publiques impliquées dans le noyau et enregistrez les ressources publiques impliquées dans les extensions externes.

Le thread correspondant appelle la position d'entrée de la fonction de l'interpréteur PHP pour initialiser les données de ressources publiques du thread actuel.

Si vous avez besoin de la ressource publique, obtenez-la simplement via l'ID de ressource correspondant.

Diagramme de la structure d'initialisation TSRM

Chemin du fichier source TSRM

TSRM implique le la fonction principale

/php-5.3.27/TSRM/TSRM.c
/php-5.3.27/TSRM/TSRM.h

initialise tsrm

enregistre les ressources publiques

tsrm_startup()

obtient et enregistre toutes les ressources publiques, et les initialise si elles le font n'existe pas. Retour et pointeur de stockage

ts_allocate_id()

Obtenez la ressource correspondante en spécifiant l'identifiant de la ressource

#define TSRMLS_FETCH() void ***tsrm_ls = (void ***) ts_resource_ex(0, NULL)

Initialisez le fil de discussion actuel et copiez les données de la ressource publique existante. vers le pointeur de stockage

#define ts_resource(id)    ts_resource_ex(id, NULL)

TSRM Quelques définitions de macros courantes

allocate_new_resource()

Vous pouvez voir que si TSRM est activé et que ZTS est vrai, alors cet ensemble de macros TSRM sera défini, souvent Ces macros dans la liste des paramètres de fonction vue dans l'extension seront remplacées par le pointeur void ***tsrm_ls En fait, le thread actuel appelle cette fonction et transmet l'adresse de zone de ressources publique &storage** du thread à. assurez-vous que le processus d'exécution interne de la fonction obtient avec précision les ressources publiques du thread correspondant

#ifdef ZTS
#define TSRMLS_D   void ***tsrm_ls
#define TSRMLS_DC  , TSRMLS_D
#define TSRMLS_C   tsrm_ls
#define TSRMLS_CC  , TSRMLS_C
#else
#define TSRMLS_D   void
#define TSRMLS_DC
#define TSRMLS_C
#define TSRMLS_CC
#endif

TSRM La méthode approximative d'appel de la fonction

appelle

TSRMLS_FETCH() et remplace void ** *tsrm_ls

exécution

Remplacer

->  test(int a  TSRMLS_CC) -> test_1(int b TSRMLS_CC)

TSRM Comment libérer

->  test(int a  ,tsrm_ls) -> test_1(int b ,tsrm_ls)

Comme mentionné ci-dessus, le travailleur d'Apache Le mode multi-processus multi-threading consiste à démarrer un processus. Plusieurs threads appellent l'interpréteur PHP. Lorsque chaque thread se termine, les données de ressources créées par le thread actuel ne seront pas détruites immédiatement (car le thread peut être réutilisé immédiatement, donc il y en a). pas besoin de réinitialiser toutes les ressources correspondant au thread). Les données des ressources publiques peuvent être utilisées directement), mais lorsque le processus est sur le point de se terminer, il traversera tous les threads et libérera tous les threads et les données de ressources correspondantes.

Commentaires sur le code source

Description de la fonction tsrm_startup

Généralement, cette fonction est appelée lors de l'initialisation du noyau PHP Afin d'économiser de la mémoire, la valeur par défaut est un. nombre de threads et un Le nombre de types de ressources, qui sera étendu plus tard s'il n'est pas suffisant

TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename)
{
    //省略...
    
    //默认线程数
    tsrm_tls_table_size = expected_threads;
    //创建tsrm_tls_entry指针数组
    tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));
    //省略...
    
    //全局资源唯一ID初始化
    id_count=0;
    //默认资源类型数
    resource_types_table_size = expected_resources;
    //省略...
    
    //创建tsrm_resource_type结构体数组
    resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));
    //省略...
    
    return 1;
}

Description de la fonction ts_allocate_id

Cette fonction doit être appelée lors de l'enregistrement et de la création d'une ressource publique data, généralement dans plusieurs Il ne sera appelé que dans un environnement de thread.On peut également voir que cette fonction traversera tous les pointeurs de structure de thread et ralloc et malloc en permanence. Par conséquent, les appels répétés à cette fonction entraîneront également des pertes de performances. >

TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
{
    int i;
    //省略...
    //生成当前资源的唯一id
    *rsrc_id = TSRM_SHUFFLE_RSRCidD(id_count++);
    TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));
    
    //判断当前资源类型表是否小于当前资源数
    //如果小于则对资源类型表进行扩容
    if (resource_types_table_size < id_count) {
        resource_types_table = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
        //省略...
        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)].done = 0;
    
    //遍历说有的线程结构体，把当前创建的资源数据赋给storage指向的内存空间
    for (i=0; i<tsrm_tls_table_size; i++) {
        tsrm_tls_entry *p = tsrm_tls_table[i];
        
        //第一种情况
        //p有可能是null，因为还没有调用 TSRMLS_FETCH() 初始化线程结构体指针
        //所以 resource_types_table 就先暂时保存该资源的 size，之后等初始化
        //线程结构体指针的时候，会自动在创建该公共资源的内存空间，并赋值storage
        
        //第二种情况
        //已初始化对应的线程结构体指针，那么就直接根据当前新创建的资源id号对
        //p->storage进行扩容，因为资源id都是递增增加的,并根据当前资源的size
        //malloc创建具体的资源内存空间，创建完成之后回调一下ctor
        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++) {
                    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->storage);
                    }
                }
                
                //id_count每次+1 ， 实际上就是我们公共资源的总数量
                p->count = id_count;
            }
            //指向下一个线程结构体指针
            p = p->next;
        }
    }
    //省略...
    //返回刚才id_count++
    return *rsrc_id;
}

TSRMLS_FETCH() - > Description de la fonction ts_resource_ex

Description de la fonction allocate_new_resource

TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
{
    THREAD_T thread_id;
    int hash_value;
    tsrm_tls_entry *thread_resources;
    //省略...
    
    if(tsrm_tls_table) {
        //获取当前线程ID
        if (!th_id) {
            //省略...
            thread_id = tsrm_thread_id();
        } else {
            thread_id = *th_id;
        }
    TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id));
    tsrm_mutex_lock(tsmm_mutex);
    
    #define THREAD_HASH_OF(thr,ts)  (unsigned long)thr%(unsigned long)ts
    //通过线程id和当前初始化线程数大小进行取模运算，算出当前线程指针位置因为
    //当前线程指针都存在tsrm_tls_table表里，如果当前位置已经存在一个线程指针
    //则 tsrm_tls_table->next 实际上就是一个hash冲突链式解决方法.
    hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
    thread_resources = tsrm_tls_table[hash_value];
    //如果不存在去创建当前线程，并将之前调用ts_allocate_id注册创建的那些公共资源
    //全部copy过来.
    if (!thread_resources) {
        allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
        return ts_resource_ex(id, &thread_id);
    } else {
         do {
            //判断线程id是否相等
            if (thread_resources->thread_id == thread_id) {
                break;
            }
            //如果不等于则next
            if (thread_resources->next) {
                thread_resources = thread_resources->next;
            } else {
               //如果不存在则还是去初始化创建当前线程
                allocate_new_resource(&thread_resources->next, thread_id);
                return ts_resource_ex(id, &thread_id);
            }
         } while (thread_resources);
    }
    //找到或创建完当前线程之后，返回当前线程公共资源区&storage指针 
    //如果指定资源id的话则返回 storage[id] 指针
    TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
}

Utilisation étendue de TSRM

我们在开发扩展的时候也要按照线程安全版本去开发，通过 ZTS 宏判断当前 PHP 是否线程安全版本.

扩展里公共资源定义：

//定义公共资源数据，替换之后就是一个zend_模块名字的结构体
ZEND_BEGIN_MODULE_GLOBALS(module_name)
int id;
char name;
ZEND_END_MODULE_GLOBALS(module_name)
//对应的宏定义
#define ZEND_BEGIN_MODULE_GLOBALS(module_name)
    typedef struct _zend_##module_name##_globals {
#define ZEND_END_MODULE_GLOBALS(module_name)
} zend_##module_name##_globals;
//替换后
typedef struct _zend_module_name_globals {
   int id;
   char name;
} zend_module_name_globals;

扩展里的资源id定义

#ifdef ZTS
  #define ZEND_DECLARE_MODULE_GLOBALS(module_name)              
          ts_rsrc_id module_name##_globals_id;
#else
#define ZEND_DECLARE_MODULE_GLOBALS(module_name)                               
          zend_##module_name##_globals module_name##_globals;
#endif

（1） 线程安全版本：则自动声明全局资源唯一id，因为每个线程都会通过当前的id去storage指向内存区获取资源数据
（2）非线程安全版本：则自动声明当前结构体变量，每次通过变量名获取资源就好了，因为不存在其他线程争抢的情况

扩展里获取公共资源数据

#ifdef ZTS
    #define MODULE_G(v) TSRMG(xx_globals_id, zend_xx_globals *, v)
#else
    #define MODULE_G(v) (xx_globals.v)
#endif

如上每次获取资源全部通过自己定义的MODULE_G()宏获取，如果是线程安全则通过对应的TSRM管理器获取当前线程指定的资源id数据，如果不是则直接通过资源变量名字获取即可

扩展里初始化公共资源

//一般初始化公共资源数据,都会在扩展的MINIT函数执行
//如果是ZTS则ts_allocate_id调用之.
PHP_MINIT_FUNCTION(myextension){
    #ifdef ZTS
       ts_allocate_id(&xx_globals_id，sizeof(zend_module_name_globals),ctor,dtor)
    #endif
}

结束

上面介绍的就是PHP-TSRM线程安全管理器的实现，了解TSRM之后，无论是看内核源码还是开发PHP扩展都有很大的好处，因为内核和扩展里面充斥着大量的TSRM_宏定义.

相关阅读：

PHP中的TSRM及其宏的使用(线程安全管理)

php cgi与fpm关系

PHP CGI FastCGI php-fpm 解惑

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!