Création d'un environnement d'exécution

Bonjour, je m'appelle Lucas Wasilewski et tout comme j'ai mis la description du projet sur mon github depuis que j'ai commencé à programmer avec NodeJS (début 2021) j'ai toujours voulu écrire quelque chose qui ressemblait à l'outil, cela n'a fait qu'augmenter après avoir regardé le documentaire sur le projet et j'ai été étonné de voir à quel point le monde open source peut avoir plusieurs rebondissements et être très accueillant quand il le souhaite. Et après une semaine de prise de tête, j'ai décidé d'écrire cet article pour que les futurs programmeurs fous qui veulent relever ce défi ne commettent pas les mêmes erreurs que moi.

Exécutions Javascript

Ce terme peut facilement induire en erreur quiconque ne comprend pas grand-chose au sujet et une bonne définition est donc nécessaire :

Un runtime Javascript est un outil qui permet d'exécuter le langage en dehors du navigateur

Il existe aujourd'hui 3 runtimes populaires : NodeJS, Deno (Node Killer) et Bun (Deno Killer), mais ils font fondamentalement la même chose : ils vous permettent d'utiliser javascript en dehors du navigateur et d'utiliser d'autres bibliothèques pour créer de nouvelles fonctionnalités. ceux-ci, et c'est très bien, puisque vous pouvez utiliser n'importe lequel d'entre eux pour construire un serveur, créer des bibliothèques et même des applications mobiles ou terminaux.

Node et Deno ont été créés par la même personne : Ryan Dahl, et en 2009, il a créé l'outil pour permettre aux développeurs de créer des applications "async IO", c'est-à-dire qui ne bloquaient pas le thread principal mais continuaient à le faire. répondre aux demandes, c'est dans cette optique qu'il a créé Libuv, une bibliothèque qui fait exactement cela. Jusque-là, le projet n'était qu'un gros tas de C et s'il voulait que plus de gens utilisent l'outil, il avait besoin d'un langage plus facile à comprendre et à utiliser. Par coïncidence, au même moment, Google lançait le V8, qui en général est un ultra- compilateur javascript rapide, cela lui a fait combiner les deux et ainsi créer Node.

Quelque temps plus tard (9 ans plus précisément), Ryan a quitté le projet et est allé travailler sur d'autres choses qu'il considérait plus intéressantes, cela lui a fait réaliser plusieurs erreurs qui pouvaient être corrigées dans Node, mais la communauté était déjà très grande et devoir prendre du recul était impossible, alors, déterminé à faire un meilleur travail, il crée Deno, un autre runtime IO qui promet d'être bien supérieur à Node, à ce jour (2024) Deno est en version 2.0 et est très stable pour les projets et la communauté.

Toute cette histoire a incité davantage de personnes à rejoindre la communauté du runtime et cela nous a également conduit à la création de Bun, et bien mieux, du mien et du vôtre ! Passons maintenant aux choses sérieuses.

Compilation de la V8

Comme indiqué précédemment, V8 est le moteur de Node, nous devrons donc le télécharger et le compiler manuellement pour avoir accès à ses bibliothèques et en-têtes. Comme il s'agit d'un projet Google, ils ont leurs propres méthodes de téléchargement et de compilation, nous devrons donc pour cela suivre leur manuel : lien, un simple copier-coller vous amènera aux commandes finales.

Cependant, ici, j'ai fait une erreur qui m'a pris 3 jours pour réaliser que je faisais tout de travers. Après avoir généré les fichiers de configuration du build avec :

tools/dev/v8gen.py x64.release

Vous devez être très prudent avec le fichier args.gn dans le dossier out.gn/x64.release/ car il contient la configuration de build que le ninja (outil de compilation) utilisera pour générer les fichiers de bibliothèque, certains anciens tutoriels utilisez le paramètre v8_monolithic = true, mais dans les versions récentes, il n'est plus utilisé. D'après ce commentaire de StackOverflow, nous devons maintenant utiliser le paramètre is_component_build = true pour générer les bons fichiers et modifier les indicateurs lors de la compilation du fichier, quelque chose de très idiot qui, si vous n'y prêtez pas attention, peut vous faire perdre un temps précieux.

Après avoir placé correctement le reste des drapeaux, il suffit d'exécuter la commande pour compiler le projet

ninja -C out.gn/x64.release

En attendant, allez manger quelque chose, car V8 est un projet très vaste avec d'innombrables tests, selon votre machine, ce processus peut facilement prendre 1 heure ou plus, alors laissez-le fonctionner et continuez à lire.

Où est console.log ?

Après la compilation, vous pouvez jeter un œil à v8/samples/hello-world.cc et commencer à avoir une idée de la façon de compiler javascript, mais plus précisément ces lignes :

v8::Local<v8::String> source =
          v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");

// Compile the source code.
v8::Local<v8::Script> script =
          v8::Script::Compile(context, source).ToLocalChecked();

Allez-y et jouez avec la chaîne qui contient "Hello World", créez des fonctions, des boucles, des conditions et devenez fou lorsque vous réalisez que si vous incluez le classique console.log() vous recevrez un indéfini, qui d'abord vous laisse perplexe moi, j'ai toujours pensé que l'objet console faisait partie de la V8 elle-même, mais en fait Node lui-même l'inclut et les navigateurs l'incluent dans le DOM (post de 2012 disant que console.log n'est probablement pas pris en charge par les navigateurs), ce qui signifie que nous nous devrons le créer nous-mêmes.

Bonjour le monde!

Pour pouvoir créer nos propres fonctions, nous devons d'abord comprendre que la V8 fonctionne avec plusieurs portées, l'une d'elles est le contexte, où c'est grâce à cela que le runtime sait où et comment exécuter le script individuellement, à l'intérieur de celui-ci. il peut y avoir un objet global qui est partagé entre tous les autres, et c'est à l'intérieur de celui-ci que nous insérerons nos fonctions personnalisées.

tools/dev/v8gen.py x64.release

Avec ces lignes, nous avons pu créer un objet appelé global, nous avons inséré un modèle de fonction "print" qui, une fois exécuté, appelle la fonction Print.

v8::Local<v8::String> source =
          v8::String::NewFromUtf8Literal(isolate, "'Hello' + ', World!'");

// Compile the source code.
v8::Local<v8::Script> script =
          v8::Script::Compile(context, source).ToLocalChecked();

La fonction Print reçoit ce paramètre fou qui contient des informations sur l'appel de fonction dans javascript et c'est à travers lui que nous parcourons tous les éléments qu'il contient, les transformons en chaîne C et les imprimons à l'écran, très direct, très simple et il remplit son rôle, il suffit de le mettre dans un fichier, de le lire et de le jouer sur le V8 (je laisse celui-là entre vos mains).

v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(GetIsolate());
global->Set(GetIsolate(), "print", v8::FunctionTemplate::New(GetIsolate(), this->Print));
v8::Local<v8::Context> context = v8::Context::New(GetIsolate(), nullptr, global);

Libuv

Eh bien, j'espère qu'à présent vous avez pu suivre et avez même arrêté de lire pour créer des implémentations uniques pour votre Node maison, mais la V8 ne nous mènera pas plus loin, afin que nous puissions nous rapprocher d'un runtime professionnel, nous devons rendre javascript capable d'effectuer plus d'opérations, pour ce faire, nous utiliserons Libuv, qui a été créé précisément pour cela.

Vous pouvez trouver le tutoriel pour installer et compiler ici. La chose importante à noter ici est que cela nous donne la liberté d'effectuer des opérations asynchrones, c'est-à-dire sans bloquer le thread principal, permettant ainsi au programme de continuer à s'exécuter tout en effectuant un travail plus lourd (comme ouvrir un fichier ou attendre des requêtes sur un serveur). prise).

Il est lui-même déjà intégré avec la fonctionnalité permettant de créer un serveur http, il nous suffit donc de le synchroniser avec les appels V8. Ne vous y trompez pas, ce n'est pas une tâche facile, car l'interface des deux bibliothèques diffère beaucoup donc il est difficile de connecter les deux, mais il y a toujours un moyen et le code source du nœud est ouvert alors assurez-vous de voler quelques idées là

Conclusions

Nous sommes arrivés à la fin d'un autre article et avec lui nous examinons certains détails que j'ai remarqués lors de la mise en œuvre. Le premier est certainement la complexité, bien sûr, ce n'est pas un projet simple, mais une fois qu'on a compris comment interagir avec l'interface V8 les choses vont très vite.

Ce projet m'a aussi fait beaucoup mieux comprendre Node. Le fait que le runtime ne soit qu'un conglomérat de bibliothèques communiquant permet de comprendre très facilement comment fonctionnent des choses plus complexes (comme la "boucle d'événement").

Si vous voulez voir ce que j'ai fait de bien, ou probablement de très mal, jetez un œil au projet sur github : done

Parler ne coûte pas cher, montre-moi le code - Linus Torvalds

## Références

https://github.com/libuv/libuv
https://v8.dev/docs
https://stackoverflow.com/questions/71213580/cant-get-v8-monolith-to-genorate
https://github.com/ErickWendel/myownnode
https://github.com/WasixXD/done

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!