V8

Node.js : les importants changements sur V8

Soumis par francoistonic le
Image
Node.js

Node.js annonce de nombreux changements, petits et grands, autour de V8 sur les versions 26 et 27 (alpha). La version Alpha de Node.js 27 met à jour V8 vers la version 15.6, contre 14.6 pour Node.js 26, apportant ainsi plusieurs nouvelles fonctionnalités et améliorations du langage JavaScript. 

L'évolution de V8 apportera de nouvelles fonctionnalités du langage par défaut : 

  • Math.sumPrecise
  • de nouvelles nouvelles méthodes Iterator
  • de nouveaux flags expérimentaux
  • changements sur Math : Math.random() exécute xorshift128+
  • V8 utilise désormais PowerSort au lieu de TimSort dans Array.prototype.sort() pour les tableaux de grande taille. Le tri reste stable et le résultat obtenu avec un comparateur cohérent demeure inchangé, mais les tests enregistrant les appels de comparateur ou les comparateurs ayant des effets de bord peuvent désormais se comporter différemment.
  • Les méthodes `Atomics.notify()`, `Atomics.wait()` et `Atomics.waitAsync()` lisent désormais la longueur du tableau typé avant de convertir l'index, conformément à la spécification. Si cette conversion entraîne une augmentation de la taille du tampon, un index initialement hors limites provoque toujours une exception `RangeError`.
  • Dans Node.js 27, les erreurs V8 fatales sont désormais gérées par le système de gestion des erreurs fatales de Node.js avant l'arrêt du programme. Ainsi, l'option --report-on-fatalerror peut générer un rapport de diagnostic dans des cas où Node.js s'arrêtait auparavant sans rapport.
  • Si la mémoire de la machine où s'exécute Node dispose de 4 à 15 Go, la taille du heap, si non précisée, peut atteindre entre 256 Mo et 4 Go.
  • Chaque objet natif utilise désormais plus de mémoire : chaque objet JavaScript qui encapsule une ressource native, telle qu’un socket, un descripteur de fichier, un flux, un hachage ou un blob, peut utiliser environ 16 octets de plus sur le tas JavaScript et environ 50 octets de plus en dehors du tas.

Exemple Iterator.zipKeyed :

[1, 2, 3]
  .values()
  .map(x => x * 2)
  .join('-'); // '2-4-6'
new Set(['a', 'b']).values().includes('b'); // true
Iterator.zip([
  [1, 2],
  ['a', 'b'],
]).toArray(); // [[1, 'a'], [2, 'b']]
Iterator.zipKeyed({ id: [1, 2], name: ['a', 'b'] }).toArray();
// [{ id: 1, name: 'a' }, { id: 2, name: 'b' }]

Exemple sur les changements dans Data :

// TZ=America/Los_Angeles node
const date = new Date(Date.UTC(1675, 0, 1));
date.getTimezoneOffset();
// v26: 472
// v27: 472.96666666666664
const shifted = new Date(date.valueOf() + date.getTimezoneOffset() * 60000);
shifted.toLocaleString();
// v26: '12/31/1674, 11:59:02 PM'
// v27: '1/1/1675, 12:00:00 AM'

Exemple sur l'accès error.stack :

const err = new Error('boom');
typeof Object.create(err).stack; // No longer looks up the prototype chain
// v26: 'string'
// v27: 'undefined'

Présentation complète : https://nodejs.org/en/blog/announcements/notable-v8-changes-from-node-js-26-to-27-alpha

 

API JSPI dans V8 : faire fonctionner WebAssembly dans un contexte asynchrone

Soumis par fredericmazue le

Les développeurs Google de moteur javaScript v8 travaillent à une API, JSPI, qui est au stade expérimental pour le moment et qui permet aux applications WebAssembly qui ont été écrites en supposant que l'accès aux fonctionnalités externes était synchrone de fonctionner sans problème (selon Google) dans un environnement où la plupart des fonctionnalités souhaitées sont asynchrones.

JSPI fonctionne en interceptant la promesse (promise) renvoyée par un appel d'API asynchrone, en suspendant la logique principale de l'application WebAssembly et en renvoyant une promesse à partir de la fonctione exportée qui a été utilisée pour entrer dans le WebAssembly. Lorsque l'API asynchrone se termine, l'application WebAssembly est reprise afin qu'elle puisse traiter les résultats de l'appel d'API.

JSPI est développé sur les architectures Intel x64 et ARM 64. Il est disponible pour Linux, macOS, Windows et ChromeOS. Pour le tester localement, saisissez chrome://flags dans la barre d'URL de Chrome et recherchez "Experimental WebAssembly JavaScript Promise Integration (JSPI)" et cochez la case. Puis relancez le navigateur.

Vous devez utiliser au moins la version 110.0.5473.0 (macOS) / 110.0.5469.0 (Windows, Android) / 110.0.5478.4 (Linux) de Chrome ou ChromeOS pour obtenir la dernière version de l'API. Google recommande d'utiliser le canal Canary pour vous assurer que toutes les mises à jour de stabilité sont appliquées. 

Le fonctionnement de JSPI et sa mise en oeuvre sont décrits dans cette proposition sur GitHub.

Le moteur JavaScript V8 9.0 améliore les performances d'appel de WebAssembly depuis JavaScript

Soumis par fredericmazue le
Image

V8, le moteur JavaScript de Google est au coeur de nombreux outils majeurs : Chrome, Node.js, Electron, Deno, notamment. V8 est mis à jour toutes les six semaines. Google vient de publier la version 9.0 bêta, qui viendra en version stable lors de la sortie de Chrome 90.

Google y a apporté une amélioration importante en ce qui concerne la performance des appels à WebAssembly depuis JavaScript.

V8 utilise différentes représentations pour les paramètres des fonctions WebAssembly et JavaScript. Pour cette raison, lorsque JavaScript appelle une fonction WebAssembly exportée, l'appel passe par un wrapper JS-to-Wasm, responsable de l'adaptation des paramètres de JavaScript pour WebAssembly ainsi que de l'adaptation des résultats dans la direction opposée.

Malheureusement, cela a un coût en termes de performances, ce qui signifie que les appels de JavaScript à WebAssembly n'étaient pas aussi rapides que les appels de JavaScript à JavaScript avant cette nouvelle version du moteur. Pour minimiser ce surcoût à l'exécution, l'encapsuleur JS-to-Wasm peut désormais être intégré au site d'appel, ce qui simplifie le code et supprime cette trame supplémentaire.

Supposons que nous avons une fonction WebAssembly pour ajouter deux nombres à virgule flottante double, comme ceci:

double addNumbers(double x, double y) {
  return x + y;
}

et supposons que nous appelons cette fonction à partir de JavaScript pour ajouter des vecteurs (représentés sous forme de tableaux typés):

const addNumbers = instance.exports.addNumbers;

function vectorSum(len, v1, v2) {
  const result = new Float64Array(len);
  for (let i = 0; i < len; i++) {
    result[i] = addNumbers(v1[i], v2[i]);
  }
  return result;
}

const N = 100_000_000;
const v1 = new Float64Array(N);
const v2 = new Float64Array(N);
for (let i = 0; i < N; i++) {
  v1[i] = Math.random();
  v2[i] = Math.random();
}

// Warm up
for (let i = 0; i < 5; i++) {
  vectorSum(N, v1, v2);
}

// Measure.
console.time();
const result = vectorSum(N, v1, v2);
console.timeEnd();

Selon Google le temps d'exécution est réduit de plus de la moitié :

Cette fonctionnalité est pour le moment expérimentale. Elle peut être activée via le commutateur --turbo-inline-js-wasm-calls

Google explique en détail cette fonctionnalité dans un document technique très intéressant, accessible ici.

Google réduit l'empreinte mémoire de son moteur JavaScript V8

Soumis par fredericmazue le

En 2018, Google avait lancé le projet V8 Lite. Il était question de réduire considérablement l'empreinte mémoire du moteur JavaScript v8. Le but étant d'aboutir à un moteur JavaScript adapté aux périphérique mobiles disposant de peu de ressources.

Toutefois, au cours de ce travail, Google s'est rendue compte que bon nombre des optimisations de mémoire réalisée pour ce mode Lite pourraient être intégrées à la version V8 standard, ce qui serait avantageux pour tous les utilisateurs.

Google a présenté le résultat de ses travaux à la conférence BlinkOn 10. (Video ci-dessous). Google a également publié un interessant billet technique donnant le détail des travaux réalisés.

Notamment, Google s'est rendue compte qu'une partie importante du segment de mémoire de V8 était dédiée à des objets qui ne sont pas essentiels à l'exécution de JavaScript, mais qui sont utilisés pour optimiser l'exécution de JavaScript et gérer des situations exceptionnelles. Parmi lesquels : code optimisé, type de retour utilisé pour déterminer comment optimiser le code, métadonnées redondantes pour les liaisons entre les objets C ++ et JavaScript. Google s'est encore aperçue que quand le moteur n'optimise pas le code (mode Lite), il est possible d'éviter la collecte des commentaires de type requis par le compilateur d'optimisation.

Google est ainsi parvenue à réduire de 22% l'empreinte mémoire de son moteur amélioré par rapport à la version V8 v7.1, ceci quand l'optimisation est désactivée.

Google est ensuite allée plus loin, après s'être aperçue qu'il était possible de réaliser la plupart des économies de mémoire du mode Lite sans aucun impact sur les performances en rendant V8 plus paresseux.

Au final, Google déclare avoir réduit de 18% en moyenne la taille du segment mémoire de V8 pour 'une gamme de sites Web classiques'.

[video:https://www.youtube.com/watch?v=56ogP8-eRqA autoplay:0]

Google améliore son moteur Javascript

Soumis par fredericmazue le
Web

Alors que Microsoft vient de publier un billet proposant d'étendre Javascript, Google publie un billet sur le blog de Chromium, annonçant une amélioration spectaculaire de Javascript tel qu'il est.

Il s'agit d'une amélioration du ramasse-miettes dans le moteur Javascript V8 de Google. Une amélioration qui doit avoir une énorme répercussion sur les performances des application Web et des jeux en HTML5, dixit Google.

Cette amélioration consiste en un ramasse-miettes qui devient incrémental, ce qui signifie qu'il libère des zones de mémoires progressivement, plutôt que de mettre en pause une applicationpériodiquement, le temps de faire une libération massive, comme le font généralement les ramasse-miettes.

Mountain View déclare avoir passé son nouveau bébé à des tests de performances sévères, qui ont vu le temps de rendu d'une page tomber de 272ms à 50ms.

Memsoft lance sa suite logicielle de gestion Oxygène en version 8

Soumis par fredericmazue le

Memsoft, éditeur de progiciels de gestion pour les entreprises, de la TPE à la GME, lance Oxygène V8, la nouvelle version de sa suite logicielle.

Oxygène V8 voit ses fonctionnalités enrichies pour ses 5 modules :

• Oxygène Gestion Commerciale intègre l’application de la loi LME. Elle permet l’édition de lettres de relance aux clients indiquant les intérêts de retard en cours ainsi que le calcul et l’édition des montants des intérêts de retard dus aux fournisseurs.

• Oxygène Comptabilité s’enrichit d’une gestion analytique supplémentaire, indépendante ou non de la première.

• Oxygène Gestion d’Affaires se voit doté du pilotage graphique par tableaux de bord sur les ressources et les affaires.

• Oxygène CRM s’enrichit d’une fonction permettant le suivi temps réel des actions commerciales. Une nouvelle fonctionnalité de géo-localisation des prospects et clients, basée sur Google Maps, permet de calculer une feuille de route optimisée pour les "tournées" des commerciaux.

• Oxygène Paie intègre dorénavant la gestion du DIF (droit individuel à la formation).

Héritant des fonctionnalités de la précédente version, l’interface graphique d’Oxygène V8, basée sur un environnement de bureau virtuel en 3D, permet de naviguer intuitivement d’une fonction à l’autre.

Le chef d’entreprise a ainsi accès à une vue dynamique de son activité, relayée par un envoi de mail automatique quotidien.