Boucle d'événements Nodejs

Question

Y a-t-il deux boucles d'événements internes dans l'architecture nodejs ?

• libev/libuv
• v8 javascript boucle d'événement

Lors d'une demande d'E/S, le nœud met-il en file d'attente la demande à la libeio qui, à son tour, notifie la disponibilité des données via des événements utilisant la libev et, finalement, ces événements sont traités par la boucle d'événements de la v8 en utilisant des callbacks ?

Fondamentalement, comment libev et libeio sont-elles intégrées dans l'architecture nodejs ?

Existe-t-il une documentation disponible pour donner une image claire de l'architecture interne de nodejs ?

Answer 1

En tant que débutant en javascript, j'avais également le même doute, est-ce que NodeJS contient 2 boucles d'événements ? Après une longue recherche et une discussion avec l'un des contributeurs de V8, j'ai obtenu les concepts suivants.

• La boucle d'événement est un concept abstrait fondamental du modèle de programmation JavaScript. Le moteur V8 fournit donc une implémentation par défaut pour la boucle d'événement, que les intégrateurs (navigateur, nœud) peuvent remplacer ou étendre . Vous pouvez trouver l'implémentation par défaut de la boucle d'événement dans la V8. aquí
• Dans NodeJS, il n'existe qu'une seule boucle d'événement qui est fourni par le runtime du nœud. L'implémentation de la boucle d'événement par défaut de V8 a été remplacée par l'implémentation de la boucle d'événement de NodeJS

Answer 2

El pbkdf2 a l'implémentation JavaScript mais elle délègue en fait tout le travail à faire du côté C++.

env->SetMethod(target, "pbkdf2", PBKDF2);
  env->SetMethod(target, "generateKeyPairRSA", GenerateKeyPairRSA);
  env->SetMethod(target, "generateKeyPairDSA", GenerateKeyPairDSA);
  env->SetMethod(target, "generateKeyPairEC", GenerateKeyPairEC);
  NODE_DEFINE_CONSTANT(target, OPENSSL_EC_NAMED_CURVE);
  NODE_DEFINE_CONSTANT(target, OPENSSL_EC_EXPLICIT_CURVE);
  NODE_DEFINE_CONSTANT(target, kKeyEncodingPKCS1);
  NODE_DEFINE_CONSTANT(target, kKeyEncodingPKCS8);
  NODE_DEFINE_CONSTANT(target, kKeyEncodingSPKI);
  NODE_DEFINE_CONSTANT(target, kKeyEncodingSEC1);
  NODE_DEFINE_CONSTANT(target, kKeyFormatDER);
  NODE_DEFINE_CONSTANT(target, kKeyFormatPEM);
  NODE_DEFINE_CONSTANT(target, kKeyTypeSecret);
  NODE_DEFINE_CONSTANT(target, kKeyTypePublic);
  NODE_DEFINE_CONSTANT(target, kKeyTypePrivate);
  env->SetMethod(target, "randomBytes", RandomBytes);
  env->SetMethodNoSideEffect(target, "timingSafeEqual", TimingSafeEqual);
  env->SetMethodNoSideEffect(target, "getSSLCiphers", GetSSLCiphers);
  env->SetMethodNoSideEffect(target, "getCiphers", GetCiphers);
  env->SetMethodNoSideEffect(target, "getHashes", GetHashes);
  env->SetMethodNoSideEffect(target, "getCurves", GetCurves);
  env->SetMethod(target, "publicEncrypt",
                 PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
                                         EVP_PKEY_encrypt_init,
                                         EVP_PKEY_encrypt>);
  env->SetMethod(target, "privateDecrypt",
                 PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
                                         EVP_PKEY_decrypt_init,
                                         EVP_PKEY_decrypt>);
  env->SetMethod(target, "privateEncrypt",
                 PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
                                         EVP_PKEY_sign_init,
                                         EVP_PKEY_sign>);
  env->SetMethod(target, "publicDecrypt",
                 PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
                                         EVP_PKEY_verify_recover_init,
                                         EVP_PKEY_verify_recover>);

ressource : https://github.com/nodejs/node/blob/master/src/node_crypto.cc

Le module Libuv a une autre responsabilité qui est pertinente pour certaines fonctions très particulières de la bibliothèque standard.

Pour certains appels de fonctions de la bibliothèque standard, le côté Node C++ et Libuv décident d'effectuer les calculs coûteux en dehors de la boucle d'événement entièrement.

Au lieu de cela, ils font appel à ce que l'on appelle un pool de threads. Le pool de threads est une série de quatre threads qui peuvent être utilisés pour exécuter des tâches coûteuses en termes de calcul, telles que le programme pbkdf2 fonction.

Par défaut, Libuv crée 4 threads dans ce pool de threads.

En plus des threads utilisés dans la boucle d'événements, il existe quatre autres threads qui peuvent être utilisés pour décharger les calculs coûteux qui doivent être effectués dans notre application.

De nombreuses fonctions incluses dans la bibliothèque standard de Node utilisent automatiquement ce pool de threads. Le site pbkdf2 étant l'une d'entre elles.

La présence de ce pool de fils est très significative.

Ainsi, Node n'est pas vraiment monofilaire, car il y a d'autres threads que Node utilise pour effectuer certaines tâches coûteuses en termes de calcul.

Si le pool d'événements était chargé d'effectuer la tâche coûteuse en calcul, notre application Node ne pourrait rien faire d'autre.

Notre CPU exécute toutes les instructions d'un thread une par une.

En utilisant le pool de threads, nous pouvons faire d'autres choses à l'intérieur d'une boucle d'événements pendant que les calculs se produisent.

Answer 3

En termes simples, la boucle d'événement du nœud est un cycle ou une boucle au niveau architectural qui aide le code Javascript à gérer le code asynchrone.

La boucle d'événement contient différentes boucles/cycles, qui sont utilisées pour gérer les tâches appropriées, par exemple setTimeouts, setimmediate, système de fichiers, requêtes réseau, promesses et autres.