J'ai lu hier un chapitre dans le blog de Liao Xuefeng sur : Computing Intensive vs. IO Intensive, l'extrait est le suivant :
Nous pouvons diviser les tâches en à forte intensité de calcul et à forte intensité d'IO.
Les tâches
à forte intensité informatique se caractérisent par la nécessité d'une grande quantité de calculs et la consommation de ressources CPU, telles que le calcul de pi, le décodage haute définition de vidéos, etc., qui reposent toutes sur la puissance de calcul du CPU. Bien que ce type de tâche gourmande en calcul puisse également être réalisé en multitâche, plus il y a de tâches, plus le temps consacré au changement de tâche est long et plus l'efficacité du processeur dans l'exécution des tâches est faible. utilisation du CPU, tâches gourmandes en calcul Le nombre de tâches simultanées doit être égal au nombre de cœurs du CPU.
Les tâches gourmandes en ressources informatiques consomment principalement des ressources CPU, l'efficacité de l'exécution du code est donc cruciale. Les langages de script comme Python fonctionnent de manière très inefficace et sont totalement inadaptés aux tâches gourmandes en calcul. Pour les tâches gourmandes en calcul, il est préférable d’écrire en langage C.
Intensif en IO, les tâches impliquant des E/S réseau et disque sont toutes des tâches gourmandes en E/S. La caractéristique de ce type de tâches est que la consommation du processeur est très faible et la majeure partie de la tâche attend que l'opération d'E/S soit terminée. (car la vitesse des E/S est bien inférieure à la vitesse du CPU et de la mémoire). Pour les tâches gourmandes en E/S, plus il y a de tâches, plus l'efficacité du processeur est élevée, mais il y a une limite. Les tâches les plus courantes sont les tâches gourmandes en E/S, telles que les applications Web.
Lors de l'exécution de tâches gourmandes en E/S, 99 % du temps est consacré aux E/S et très peu de temps est consacré au CPU. Par conséquent, remplacer des langages de script extrêmement lents comme Python par un langage C extrêmement rapide est totalement efficace. ne peut pas être amélioré. Pour les tâches gourmandes en E/S, le langage le plus approprié est celui ayant la plus grande efficacité de développement (le langage de script le moins important est le premier choix, et le langage C est le pire).
Il existe un châtaigne bien utilisé qui explique les concepts non bloquant et événementiel du langage Node.js, qui ressemble à peu près à ceci : 非阻塞，事件驱动 概念，大约是这样的：
Lorsque vous allez manger au restaurant, le serveur du restaurant donnera le menu directement à la cuisine après avoir pris votre commande, puis passera immédiatement au client suivant au lieu d'attendre en cuisine (Blocage ). Jusqu'à ce que la cuisson soit terminée, le chef crie « venez chercher la nourriture » (événement). Le serveur retourne à la cuisine et apporte les plats à votre table (Gestion des événements/Rappel)
Dans ce marron, on peut simplement comprendre que le serveur équivaut à un CPU, et que le travail de la cuisine est un E/S. Évidemment, dans un restaurant, le travail du serveur n'est pas compliqué. La plupart du temps « attendre la nourriture » est consacré à « attendre la cuisine ». Ceci est similaire à la situation de la plupart des sites Web aujourd'hui : les sites Web n'ont généralement pas besoin d'effectuer trop d'opérations complexes, mais ils doivent passer beaucoup de temps à attendre le traitement des E/S, comme les requêtes de base de données, comme la lecture d'images et de vidéos. . 🎜
🎜Node.js a donc abandonné la pratique consistant à « chaque fois qu'une demande arrive, ouvrez un thread pour un traitement séparé » dans les services Web traditionnels et a plutôt adopté un modèle basé sur les événements. Par défaut, un seul thread peut supporter une charge élevée. de concurrence. 🎜
🎜Donc, dans cette situation, nous disons : Node.js est plus adapté au traitement de tâches gourmandes en E/S. 🎜
🎜Mais si on change la châtaigne ci-dessus, par exemple, on n'ouvre pas un restaurant, mais une banque. Chaque fois qu'un client vient demander de retirer une somme d'argent spécifiée, en tant que serveur, vous devez calculer le taux d'intérêt, calculer les intérêts, calculer les dividendes, etc. en fonction du niveau du compte du client... (une métaphore aléatoire peut ne pas être approprié), et "Retirer de l'argent" Et le remettre au client" Cette action en elle-même n'est pas compliquée. 🎜
🎜À l'heure actuelle, nous ne pouvons pas nous attendre à ce qu'un seul serveur puisse gérer un grand nombre de clients comme un restaurant, car chaque demande nécessite une grande partie du temps du serveur (blocage inévitable). À l’heure actuelle, les modèles traditionnels tels que PHP pourraient devenir plus adaptés. 🎜
🎜Ce qui précède, j'espère que cela pourra dissiper votre confusion🎜
IO-intensive : applications avec beaucoup d'IO, telles que la transmission réseau, les appels de base de données, etc. La plupart des applications Web sont comme ça
Intensif en calcul : comme son nom l'indique, c'est le type d'application qui nécessite beaucoup de calculs CPU. Les applications telles que le cloud computing devraient entrer dans cette catégorie.
Qu'est-ce qui nécessite beaucoup de calculs ? Par exemple, placez la base de données SQLite sur le système de fichiers mémoire Linux /dev/shm pour effectuer une requête SELECT sur 1 million de données. Ensuite, cette requête SELECT, lors de l'utilisation de l'index arborescent B+, effectue une requête SELECT sur. l'index de l'arborescence B+. La recherche binaire est un calcul intensif typique. Si aucun index n'est utilisé, la simple analyse de la table entière est également un calcul intensif. Par conséquent, des éléments tels que les bases de données relationnelles sont généralement implémentés en utilisant C/C++ pour garantir les performances et contrôler la mémoire. utilisation.
Qu'est-ce qui est gourmand en IO ? Par exemple, la base de données SQLite n'est pas en mémoire, mais sur un disque mécanique ordinaire, les opérations d'écriture (INSERT/UPDATE/DELETE) sont des opérations typiques gourmandes en IO, car quelle que soit la vitesse du processeur à ce moment-là , le moteur SQLite est plus rapide. , sera également ralenti par l'opération d'écriture du disque mécanique. Par conséquent, par souci de concurrence, SQLite a ensuite introduit le WAL (write-ahead log) write-ahead. prise en charge des logs. La configuration spécifique consiste à exécuter la requête SQLite : WAL(write-ahead log)预写式日志支持,具体配置就是执行一下SQLite查询:
Le principe du mécanisme WAL est le suivant : les modifications ne sont pas écrites directement dans le fichier de base de données, mais dans un autre fichier appelé WAL (data.db3-wal). Si la transaction échoue, les enregistrements dans WAL seront ignorés, annulez la modification. Si la transaction réussit, elle sera réécrite dans le fichier de base de données ultérieurement (PRAGMA synchrone = NORMAL) et validera la modification. Le comportement de synchronisation du fichier WAL et du fichier de base de données est appelé point de contrôle. Il est automatiquement exécuté par. SQLite. La valeur par défaut est lorsque le fichier WAL accumule 1000 pages de modifications (PRAGMA wal_autocheckpoint). Au moment approprié, vous pouvez également exécuter manuellement le point de contrôle. Après avoir exécuté PRAGMA wal_checkpoint, le fichier WAL sera vide. Lors de la lecture, SQLite recherchera dans le fichier WAL le dernier point d'écriture, s'en souviendra et ignorera les points d'écriture suivants (cela garantit que la lecture et l'écriture peuvent être effectuées en parallèle. Par la suite, il détermine si la page des données est sélectionnée). être lu est dans le fichier WAL. Si c'est le cas, lisez les données dans le fichier WAL. Sinon, lisez directement les données dans le fichier de base de données. Lors de l'écriture, SQLite les écrit dans le fichier WAL. doit être garanti, donc l'écriture et l'écriture ne peuvent pas être exécutées en parallèle lors de la mise en œuvre de WAL, la technologie de mémoire partagée (data.db3-shm) est utilisée, donc tous les processus de lecture et d'écriture doivent être sur la même machine, sinon les données. la cohérence ne peut pas être garantie.
Des concepts tels que WAL et checkpoint existent également dans d'autres bases de données telles que MySQL, mais MySQL est plus complexe et peut prendre en charge des opérations d'écriture simultanées à plus grande échelle. Des écritures comme WAL+checkpoint, vous pouvez le considérer comme. une écriture asynchrone.🎜
🎜L'interpréteur JS de Node est basé sur le V8 de Chromium, et le V8 dispose d'un mécanisme de compilation juste à temps JIT, donc les performances de calcul intensives de Node sont pires que celles de PHP. Bien que les responsables de PHP développent actuellement le test JIT de PHP, ses performances ne sont toujours pas aussi bonnes que celles de PHP. Cependant, même si Node a de bonnes performances de calcul, presque personne ne recommanderait d'effectuer des calculs intensifs à grande échelle dans Node, car les calculs intensifs bloqueront inévitablement les services Node, ce qui est contraire au concept de non-blocage prôné par Node.🎜.
Node utilise les caractéristiques événementielles de JS pour obtenir un non-blocage, mais la méthode de programmation d'événements basée sur le rappel n'est pas propice à la maintenance du code. De plus, des services comme Node ne peuvent pas utiliser un processus unique, multithread et multicœur comme Java. des services tels que Tomcat et V8 ne le font pas. Il n'est pas conçu pour le multi-threading, les responsables de Node ne peuvent donc créer qu'un module multi-processus de cluster pour tirer parti du multi-cœur.
PHP est relativement médiocre et sa vitesse de calcul n'est pas aussi rapide que celle des langages JIT. Cependant, parmi les langages de script généraux non JIT, PHP n'est pas lent. Par exemple, PHP5 est déjà plus rapide que Python et PHP7 est beaucoup plus rapide. que Python, comme php-src Dans le test /Zend/bench.php, la consommation de temps de PHP 7.1 n'est que 1/4 de celle de 5.4.
De plus, les méthodes d'exécution FastCGI multi-processus telles que PHP-FPM et Apache MOD_PHP peuvent facilement utiliser plusieurs cœurs. De plus, opcache peut également être activé pour mettre en cache l'opcode des scripts PHP dans la mémoire partagée. De nombreuses fonctions dans Functions.php, une fois qu'opcache a mis en cache le script en mémoire, il n'est pas nécessaire de ré-analyser le script à chaque fois que PHP est demandé, et l'opcode peut être exécuté directement. L'amélioration des performances est très évidente, en particulier pour les complexes. Applications PHP.
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
J'ai lu hier un chapitre dans le blog de Liao Xuefeng sur : Computing Intensive vs. IO Intensive, l'extrait est le suivant :
Il existe un châtaigne bien utilisé qui explique les concepts
non bloquantetévénementieldu langage Node.js, qui ressemble à peu près à ceci :非阻塞，事件驱动概念，大约是这样的：在这个栗子中，我们可以简单的理解为：服务员相当于
CPU，而厨房的工作就是I/O。显然的，在一个饭店里，服务员的工作并不复杂，”等待上菜的时间“多数是花在”等待厨房“上。这与如今大多数网站的情况相似：网站通常不需要做太多复杂的运算，但需要花费大量的时间等待 I/O 处理，比如数据库查询，比如图片、视频的读取。于是 Node.js 舍弃了传统 Web 服务中“每当一次请求来临，都打开一个线程来单独处理”的做法，而是采用事件驱动的模型，默认情况下，仅用单线程就可以负担相当高的并发量。
于是在这种情境下，我们说：
Node.js 更适合 IO密集型的任务处理。但如果我们把上面的栗子更换一下，比如说咱们不开饭馆，开银行。每当客户到来，要求取出指定的款项，作为服务员，你需要根据客户的账户等级计算利率，计算利息，计算分红，等等……（随意想到的比方，可能不太恰当），而“取钱并交给客户”这个动作本身却并不复杂。
这时候，就不能指望像饭店那样，只靠一个服务员就能应付大量的客户，因为每个请求都需要独占服务员大量的时间（不可避免的
Dans ce marron, on peut simplement comprendre que le serveur équivaut à un阻塞CPU, et que le travail de la cuisine est unE/S. Évidemment, dans un restaurant, le travail du serveur n'est pas compliqué. La plupart du temps « attendre la nourriture » est consacré à « attendre la cuisine ». Ceci est similaire à la situation de la plupart des sites Web aujourd'hui : les sites Web n'ont généralement pas besoin d'effectuer trop d'opérations complexes, mais ils doivent passer beaucoup de temps à attendre le traitement des E/S, comme les requêtes de base de données, comme la lecture d'images et de vidéos. . 🎜 🎜Node.js a donc abandonné la pratique consistant à « chaque fois qu'une demande arrive, ouvrez un thread pour un traitement séparé » dans les services Web traditionnels et a plutôt adopté un modèle basé sur les événements. Par défaut, un seul thread peut supporter une charge élevée. de concurrence. 🎜 🎜Donc, dans cette situation, nous disons :Node.js est plus adapté au traitement de tâches gourmandes en E/S. 🎜 🎜Mais si on change la châtaigne ci-dessus, par exemple, on n'ouvre pas un restaurant, mais une banque. Chaque fois qu'un client vient demander de retirer une somme d'argent spécifiée, en tant que serveur, vous devez calculer le taux d'intérêt, calculer les intérêts, calculer les dividendes, etc. en fonction du niveau du compte du client... (une métaphore aléatoire peut ne pas être approprié), et "Retirer de l'argent" Et le remettre au client" Cette action en elle-même n'est pas compliquée. 🎜 🎜À l'heure actuelle, nous ne pouvons pas nous attendre à ce qu'un seul serveur puisse gérer un grand nombre de clients comme un restaurant, car chaque demande nécessite une grande partie du temps du serveur (blocageinévitable). À l’heure actuelle, les modèles traditionnels tels que PHP pourraient devenir plus adaptés. 🎜 🎜Ce qui précède, j'espère que cela pourra dissiper votre confusion🎜IO-intensive : applications avec beaucoup d'IO, telles que la transmission réseau, les appels de base de données, etc. La plupart des applications Web sont comme ça
Intensif en calcul : comme son nom l'indique, c'est le type d'application qui nécessite beaucoup de calculs CPU. Les applications telles que le cloud computing devraient entrer dans cette catégorie.
Qu'est-ce qui nécessite beaucoup de calculs ? Par exemple, placez la base de données SQLite sur le système de fichiers mémoire Linux /dev/shm pour effectuer une requête SELECT sur 1 million de données. Ensuite, cette requête SELECT, lors de l'utilisation de l'index arborescent B+, effectue une requête SELECT sur. l'index de l'arborescence B+. La recherche binaire est un calcul intensif typique. Si aucun index n'est utilisé, la simple analyse de la table entière est également un calcul intensif. Par conséquent, des éléments tels que les bases de données relationnelles sont généralement implémentés en utilisant C/C++ pour garantir les performances et contrôler la mémoire. utilisation.
Qu'est-ce qui est gourmand en IO ? Par exemple, la base de données SQLite n'est pas en mémoire, mais sur un disque mécanique ordinaire, les opérations d'écriture (INSERT/UPDATE/DELETE) sont des opérations typiques gourmandes en IO, car quelle que soit la vitesse du processeur à ce moment-là , le moteur SQLite est plus rapide. , sera également ralenti par l'opération d'écriture du disque mécanique. Par conséquent, par souci de concurrence, SQLite a ensuite introduit le
WAL (write-ahead log)write-ahead. prise en charge des logs. La configuration spécifique consiste à exécuter la requête SQLite :WAL(write-ahead log)预写式日志支持,具体配置就是执行一下SQLite查询:WAL机制的原理是: 修改并不直接写入到数据库文件中,而是写入到另外一个称为WAL的文件中(data.db3-wal). 如果事务失败,WAL中的记录会被忽略,撤销修改. 如果事务成功,它将在随后的某个时间(PRAGMA synchronous = NORMAL)被写回到数据库文件中,提交修改. 同步WAL文件和数据库文件的行为被称为checkpoint(检查点),它由SQLite自动执行, 默认是在WAL文件积累到1000页修改的时候(PRAGMA wal_autocheckpoint). 在适当的时候,也可以手动执行checkpoint,SQLite提供了相关的接口,执行 PRAGMA wal_checkpoint 之后,WAL文件会被清空. 在读的时候,SQLite将在WAL文件中搜索,找到最后一个写入点,记住它,并忽略在此之后的写入点(这保证了读写和读读可以并行执行). 随后,它确定所要读的数据所在页是否在WAL文件中,如果在,则读WAL文件中的数据,如果不在,则直接读数据库文件中的数据. 在写的时候,SQLite将之写入到WAL文件中即可,但是必须保证独占写入,因此写与写之间不能并行执行. WAL在实现的过程中,使用了共享内存技术(data.db3-shm),因此,所有的读写进程必须在同一个机器上,否则,无法保证数据一致性.
像WAL和checkpoint这种概念,在其他数据库比如MySQL中也存在,只不过MySQL会更复杂,能支持更大规模的并发写操作.像
Le principe du mécanisme WAL est le suivant : les modifications ne sont pas écrites directement dans le fichier de base de données, mais dans un autre fichier appelé WAL (data.db3-wal). Si la transaction échoue, les enregistrements dans WAL seront ignorés, annulez la modification. Si la transaction réussit, elle sera réécrite dans le fichier de base de données ultérieurement (PRAGMA synchrone = NORMAL) et validera la modification. Le comportement de synchronisation du fichier WAL et du fichier de base de données est appelé point de contrôle. Il est automatiquement exécuté par. SQLite. La valeur par défaut est lorsque le fichier WAL accumule 1000 pages de modifications (PRAGMA wal_autocheckpoint). Au moment approprié, vous pouvez également exécuter manuellement le point de contrôle. Après avoir exécuté PRAGMA wal_checkpoint, le fichier WAL sera vide. Lors de la lecture, SQLite recherchera dans le fichier WAL le dernier point d'écriture, s'en souviendra et ignorera les points d'écriture suivants (cela garantit que la lecture et l'écriture peuvent être effectuées en parallèle. Par la suite, il détermine si la page des données est sélectionnée). être lu est dans le fichier WAL. Si c'est le cas, lisez les données dans le fichier WAL. Sinon, lisez directement les données dans le fichier de base de données. Lors de l'écriture, SQLite les écrit dans le fichier WAL. doit être garanti, donc l'écriture et l'écriture ne peuvent pas être exécutées en parallèle lors de la mise en œuvre de WAL, la technologie de mémoire partagée (data.db3-shm) est utilisée, donc tous les processus de lecture et d'écriture doivent être sur la même machine, sinon les données. la cohérence ne peut pas être garantie.WAL+checkpointrrreee
Des concepts tels que WAL et checkpoint existent également dans d'autres bases de données telles que MySQL, mais MySQL est plus complexe et peut prendre en charge des opérations d'écriture simultanées à plus grande échelle. Des écritures commeWAL+checkpoint, vous pouvez le considérer comme. une écriture asynchrone.🎜 🎜L'interpréteur JS de Node est basé sur le V8 de Chromium, et le V8 dispose d'un mécanisme de compilation juste à temps JIT, donc les performances de calcul intensives de Node sont pires que celles de PHP. Bien que les responsables de PHP développent actuellement le test JIT de PHP, ses performances ne sont toujours pas aussi bonnes que celles de PHP. Cependant, même si Node a de bonnes performances de calcul, presque personne ne recommanderait d'effectuer des calculs intensifs à grande échelle dans Node, car les calculs intensifs bloqueront inévitablement les services Node, ce qui est contraire au concept de non-blocage prôné par Node.🎜.Node utilise les caractéristiques événementielles de JS pour obtenir un non-blocage, mais la méthode de programmation d'événements basée sur le rappel n'est pas propice à la maintenance du code. De plus, des services comme Node ne peuvent pas utiliser un processus unique, multithread et multicœur comme Java. des services tels que Tomcat et V8 ne le font pas. Il n'est pas conçu pour le multi-threading, les responsables de Node ne peuvent donc créer qu'un module multi-processus de cluster pour tirer parti du multi-cœur.
PHP est relativement médiocre et sa vitesse de calcul n'est pas aussi rapide que celle des langages JIT. Cependant, parmi les langages de script généraux non JIT, PHP n'est pas lent. Par exemple, PHP5 est déjà plus rapide que Python et PHP7 est beaucoup plus rapide. que Python, comme php-src Dans le test /Zend/bench.php, la consommation de temps de PHP 7.1 n'est que 1/4 de celle de 5.4.
De plus, les méthodes d'exécution FastCGI multi-processus telles que PHP-FPM et Apache MOD_PHP peuvent facilement utiliser plusieurs cœurs. De plus, opcache peut également être activé pour mettre en cache l'opcode des scripts PHP dans la mémoire partagée. De nombreuses fonctions dans Functions.php, une fois qu'opcache a mis en cache le script en mémoire, il n'est pas nécessaire de ré-analyser le script à chaque fois que PHP est demandé, et l'opcode peut être exécuté directement. L'amélioration des performances est très évidente, en particulier pour les complexes. Applications PHP.