Parlons de l'algorithme de gestion de la mémoire et de garbage collection du V8

Cet article vous fera comprendre l'algorithme de gestion de la mémoire et de garbage collection du moteur V8. J'espère qu'il vous sera utile !

Comme nous le savons tous, JS gère automatiquement le garbage collection et les développeurs n'ont pas besoin de se soucier de l'allocation de mémoire et du recyclage. De plus, le mécanisme de collecte des ordures est également un élément couramment testé lors des entretiens préliminaires. Cet article explique principalement l'algorithme de récupération de place générationnelle de la V8. J'espère qu'après avoir lu cet article, mes amis pourront avoir une compréhension douloureuse du mécanisme de récupération de place V8 (haha, c'est est douloureux). ! ), l'article couvre principalement le contenu suivant : <code>V8垃圾回收机制有个痛彻（哈哈，是痛彻！！！）的了解，文章主要涵盖如下内容：

• V8的内存限制与解决办法
• 新生代内存对象的Scavenge算法
• 基于可达性分析算法标记存活对象的逻辑以及优化手段
• 新生代内存对象的晋升条件、
• Scavenge算法的深度/广度优先区别
• 跨代内存的的写屏障
• 老生代内存对象的标记清除/整理算法
• GC的STW原因及优化策略

V8的内存限制与解决办法

V8最初为浏览器设计，遇到大内存使用的场景较少，在设计上默认对内存使用存在限制，只允许使用部分内存，64位系统可允许使用内存约1.4g，32位系统约0.7g。如下代码所示，在Node中查看所依赖的V8引擎的内存限制方法：

process.memoryUsage();

// 返回内存的使用量，单位字节
{
  rss: 22953984,
  // 申请的总的堆内存
  heapTotal: 9682944,
  // 已使用的堆内存
  heapUsed: 5290344,
  external: 9388
}

V8限制内存使用大小还有另一个重要原因，堆内存过大时V8执行垃圾回收的时间较久（1.5g要50ms），做非增量式的垃圾回收要更久（1.5g要1s）。在后续讲解了V8的垃圾回收机制后相信大家更能感同身受。

虽然V8引擎对内存使用做了限制，但是同样暴露修改内存限制的方法，就是启动V8引擎时添加相关参数，下面代码演示在Node中修改依赖的V8引擎内存限制：

# 更改老生代的内存限制，单位mb
node --max-old-space-size=2048 index.js

# 更改新生代的内存限制，单位mb
node --max-semi-space-size=1024=64 index.js

这里需要注意的是更改的新生代的内存的语法已经更改为上述的写法，且单位也由kb变成了mb，旧的写法是node --max-new-space-size，可以通过下面命令查询当前Node环境修改新生代内存的语法:

node --v8-options | grep max

V8垃圾回收策略

在引擎的垃圾自动回收机制的历史演变中，人们发现是没有一种通用的可以解决任何场景下垃圾回收的算法的。因此现代垃圾回收算法根据对象的存活时间将内存垃圾进行分代，分代垃圾回收算法就是对不同类别的内存垃圾实行不同的回收算法。

V8将内存分为新生代和老生代两种：

• 新生代内存中的对象存活时间较短
• 老生代内存中代对象存活时间较长或是常驻内存

新生代内存存放在新生代内存空间（semispace）中，老生代内存存放在老生代内存空间中（oldspace）,如下图所示：

• 新生代内存采用Scavenge算法
• 老生代内存采用Mark-Sweep和Mark-Compact算法

下面我们看看Scavenge的算法逻辑吧！

Scavenge算法

对于新生代内存的内存回收采用Scavenge算法，Scavenge的具体实现采用的是Cheney算法。Cheney算法是将新生代内存空间一分为二，一个空间处于使用状态（FromSpace），一个空间处于空闲状态（称为ToSpace

• Les limitations de mémoire et les solutions de la V8
• Le Algorithme de récupération
• basé sur la logique de l'algorithme d'analyse d'accessibilité et sur les méthodes d'optimisation du marquage des objets survivants
• objets mémoire de nouvelle génération Conditions de promotion, li>
• Différence de priorité profondeur/largeur de l'algorithme de récupération
• Barrière d'écriture de mémoire entre générations
• Objets de mémoire d'ancienne génération Algorithme d'effacement/d'organisation des marques li>
• Raisons <code>STW et stratégies d'optimisation de GC

Limitations et solutions de mémoire du V8

Le V8 a été conçu à l'origine pour les navigateurs. Il existe moins de scénarios dans lesquels une grande mémoire est utilisée. Il existe des restrictions sur l'utilisation de la mémoire par défaut dans la conception. à utiliser. Le système 64 bits autorise environ 1,4 g de mémoire et le système 32 bits autorise environ 0,7 g. Comme indiqué dans le code suivant, vérifiez la méthode de limite de mémoire du moteur V8 dépendant dans Node :

var temp2 = {
  ref: temp1,
}

var temp3 = {
  ref: temp1,
}

var temp1 = {}

🎜V8 Il existe une autre raison importante pour limiter l'utilisation de la mémoire. Lorsque la mémoire du tas est trop grande, V8 Il faut beaucoup de temps pour effectuer le garbage collection (1,5 g prend 50 ms), et il faut encore plus de temps pour effectuer un garbage collection non incrémentiel ( 1,5g Cela prend 1s). Après avoir expliqué plus tard le mécanisme de récupération de place de V8, je pense que tout le monde pourra s'y identifier davantage. 🎜🎜Bien que le moteur V8 ait des limites sur l'utilisation de la mémoire, la méthode de modification de la limite de mémoire est également exposée, qui consiste à ajouter des paramètres pertinents lors du démarrage du moteur V8. le code suivant est démontré dans Modifier la limite de mémoire du moteur <code>V8 dépendant dans Node : 🎜

const temp1 = {}

const temp2 = {
  ref: temp1,
}

🎜 Ce qu'il faut noter ici est que la syntaxe de la mémoire de nouvelle génération modifiée a été a été remplacé par la méthode d'écriture mentionnée ci-dessus, et l'unité a également été modifiée de kb à mb. L'ancienne façon d'écrire est node --max-. new-space-size Vous pouvez interroger le actuel via la commande suivante. L'environnement Node modifie la syntaxe de la mémoire nouvelle génération : 🎜rrreee🎜🎜

Stratégie de collecte des ordures V8

🎜L'évolution historique du mécanisme de collecte automatique des ordures du moteur, les gens ont découvert qu'il n'existe aucun algorithme général capable de résoudre le ramassage des ordures dans n'importe quel scénario. Par conséquent, les algorithmes modernes de collecte des déchets divisent les déchets de mémoire en générations en fonction du temps de survie des objets. L'algorithme de collecte des déchets générationnel consiste à classer différentes catégories de déchets de mémoire. algorithmes. 🎜🎜V8 divise la mémoire en deux types : Nouvelle génération et Ancienne génération : 🎜

• Les objets de la mémoire de nouvelle génération survivent Le temps est plus court
• Les objets de génération dans la mémoire d'ancienne génération ont une durée de survie plus longue ou résident en mémoire

🎜La mémoire de nouvelle génération est stockée dans l'espace mémoire de nouvelle génération (semispace code>), la mémoire d'ancienne génération est stockée dans l'espace mémoire d'ancienne génération (<code>oldspace), comme le montre la figure ci-dessous : 🎜🎜🎜

• La mémoire nouvelle génération utilise l'algorithme Scavenge li>
• La mémoire ancienne génération utilise les algorithmes Mark-Sweep et Mark-Compact

🎜Jetons un coup d'œil à la logique de l'algorithme Scavengecode> ! 🎜

Algorithme de récupération

🎜Pour le recyclage de la mémoire de nouvelle génération, l'algorithme Scavenge est utilisé, Scavenge utilise l'algorithme <code>Cheney. L'algorithme Cheney divise l'espace mémoire nouvelle génération en deux, un espace est utilisé (FromSpace) et l'autre est dans un état inactif (appelé ToSpace code>). 🎜🎜🎜🎜<p>在内存开始分配时，首先在<code>FromSpace中进行分配，垃圾回收机制执行时会检查FromSpace中的存活对象，存活对象会被会被复制到ToSpace，非存活对象所占用的空间将被释放，复制完成后FromSpace和ToSpace的角色将翻转。当一个对象多次复制后依然处于存活状态，则认为其是长期存活对象，此时将发生晋升，然后该对象被移动到老生代空间oldSpace中，采用新的算法进行管理。

Scavenge算法其实就是在两个空间内来回复制存活对象，是典型的空间换时间做法，所以非常适合新生代内存，因为仅复制存活的对象且新生代内存中存活对象是占少数的。但是有如下几个重要问题需要考虑：

• 引用避免重复拷贝

假设存在三个对象temp1、temp2、temp3，其中temp2、temp3都引用了temp1，js代码示例如下：

var temp2 = {
  ref: temp1,
}

var temp3 = {
  ref: temp1,
}

var temp1 = {}

从FromSpace中拷贝temp2到ToSpace中时，发现引用了temp1，便把temp1也拷贝到ToSpace，是一个递归的过程。但是在拷贝temp3时发现也引用了temp1，此时再把temp1拷贝过去则重复了。

要避免重复拷贝，做法是拷贝时给对象添加一个标记visited表示该节点已被访问过，后续通过visited属性判断是否拷贝对象。

• 拷贝后保持正确的引用关系

还是上述引用关系，由于temp1不需要重复拷贝，temp3被拷贝到ToSpace之后不知道temp1对象在ToSpace中的内存地址。

做法是temp1被拷贝过去后该对象节点上会生成新的field属性指向新的内存空间地址，同时更新到旧内存对象的forwarding属性上，因此temp3就可以通过旧temp1的forwarding属性找到在ToSpace中的引用地址了。

内存对象同时存在于新生代和老生代之后，也带来了问题：

• 内存对象跨代（跨空间）后如何标记

const temp1 = {}

const temp2 = {
  ref: temp1,
}

比如上述代码中的两个对象temp1和temp2都存在于新生代，其中temp2引用了temp1。假设在经过GC之后temp2晋升到了老生代，那么在下次GC的标记阶段，如何判断temp1是否是存活对象呢？

在基于可达性分析算法中要知道temp1是否存活，就必须要知道是否有根对象引用引用了temp1对象。如此的话，年轻代的GC就要遍历所有的老生代对象判断是否有根引用对象引用了temp1对象，如此的话分代算法就没有意义了。

解决版本就是维护一个记录所有的跨代引用的记录集，它是写缓冲区的一个列表。只要有老生代中的内存对象指向了新生代内存对象时，就将老生代中该对象的内存引用记录到记录集中。由于这种情况一般发生在对象写的操作，顾称此为写屏障，还一种可能的情况就是发生在晋升时。记录集的维护只要关心对象的写操作和晋升操作即可。此是又带来了另一个问题：

• 每次写操作时维护记录集的额外开销

优化的手段是在一些Crankshaft操作中是不需要写屏障的，还有就是栈上内存对象的写操作是不需要写屏障的。还有一些，更多的手段就不在这里过多讨论。

• 缓解Scavenge算法内存利用率不高问题

新生代内存中存活对象占比是相对较小的，因此可以在分配空间时，ToSpace可以分配的小一些。做法是将ToSpace空间分成S0和S1两部分，S0用作于ToSpace，S1与原FromSpace合并当成FromSpace。

Scavenge算法中深度/广度优先的区别

垃圾回收算法中，识别内存对象是否是垃圾的机制一般有两种：引用计数和基于可达性分析。

Basé sur l'analyse d'accessibilité, il s'agit de trouver toutes les références racine (telles que les variables globales, etc.), de parcourir toutes les références racine et toutes les références sur la référence racine récursive. Tous les objets traversés sont des objets vivants et marqués, à ce moment, les autres objets mémoire dans l'espace sont des objets morts, construisant ainsi un graphe orienté.

Compte tenu des limites de la récursion, la logique récursive est généralement implémentée à l'aide d'une implémentation non récursive Les algorithmes couramment utilisés incluent des algorithmes de largeur d'abord et de profondeur d'abord. La différence entre les deux est la suivante :

• Lorsque la copie en profondeur d'abord vers ToSpace modifie l'ordre des objets de mémoire, rapprochant ainsi les objets avec des relations de référence. La raison en est qu'après s'être copié, l'objet référencé par lui-même est copié directement, donc les objets associés sont plus proches dans ToSpace
ToSpace时改变了内存对象的排列顺序，使得有引用关系的对象距离较近。原因是拷贝完自己之后直接拷贝自己引用的对象，因此相关的对象便在ToSpace中靠的较近
• 深度优先正好相反

因为CPU的缓存策略，会在读取内存对象时有很大概率把他后面的对象一起读，目的是为了更快的命中缓存。因为在代码开发期间很常见的场景就是obj1.obj2.obj3，此时CPU读取obj1时如果把后面的obj2、obj3一起读的话，则很利于命中缓存。

所以深度优先的算法更利于业务逻辑命中缓存，但是其实现需要依赖额外的栈辅助实现算法，对内存空间有消耗。广度优先则相反，无法提升缓存命中，但是其实现可以利用指针巧妙的避开空间消耗，算法的执行效率高。

新生代内存对象的晋升条件

新生代中的内存对象如果想晋升到老生代需要满足如下几个条件：

• 对象是否经历过Scavenge回收
• ToSpace的内存使用占比不能超过限制

判断是否经历过Scavenge的GC的逻辑是，每次GC时给存活对象的age属性+1，当再次GC的时候判断age属性即可。基本的晋升示意图如下所示：

老生代内存中，长期存活的对象较多，无法采取Scavenge算法回收的原因在于：

• 存活对象较多导致复制效率低下
• 浪费了一半的内存空间

老生代内存对象的回收算法

老生代内存空间的垃圾回收采用的是标记清除（Mark-Sweep）和标记整理（Mark-Compact）结合的方式。标记清除分为两部分：

• 标记阶段
• 清除阶段（如果是标记整理则是整理阶段）

在标记阶段遍历老生代堆内存中的所有内存对象，并对活着的对象做标记，清除阶段只清理未被标记的对象。原因是：老生代内存中非存活对象占少数。

如上图所示，标记清除存在的一个问题是清理之后存在了不连续的空间导致无法继续利用，所以对于老生代内存空间的内存清理需要结合标记整理的方案。该方案是在标记过程中将活着的对象往一侧移动，移动完成后再清理界外的所有非存活对象移除。

垃圾回收的全暂停

垃圾回收时需要暂停应用执行逻辑，待垃圾回收机制结束后再恢复应用执行逻辑，该行为称为“全暂停”，也就是常说的Stop The World，简称STW。对新生代内存的垃圾回收该行为对应用执行影响不大，但是老生代内存由于存活对象较多，所以老生代内存的垃圾回收造成的全停顿影响非常大。

V8为了优化GC的全暂停时间，还引入了增量标记、并发标记、并行标记、增量整理、并行清理、延迟清理等方式。

STW优化

衡量垃圾回收所用时间的一个重要指标是执行 GCLa priorité en profondeur est tout le contraire

En raison de la stratégie de mise en cache du CPU, lors de la lecture d'un objet mémoire, il y a une forte probabilité que les objets derrière celui-ci soient lus ensemble, afin d'atteindre le cache plus rapidement. Parce qu'un scénario très courant lors du développement de code est obj1.obj2.obj3. À ce moment-là, lorsque le processeur lit obj1, si le obj2 suivant. , Si obj3 est lu ensemble, il sera très utile d'accéder au cache. 🎜🎜Ainsi, l'algorithme axé sur la profondeur est plus propice à l'accès de la logique métier au cache, mais sa mise en œuvre nécessite une implémentation supplémentaire de l'algorithme assistée par la pile, ce qui consomme de l'espace mémoire. Au contraire, la largeur d'abord ne peut pas améliorer les accès au cache, mais sa mise en œuvre peut utiliser des pointeurs pour éviter intelligemment la consommation d'espace, et l'efficacité d'exécution de l'algorithme est élevée. 🎜

🎜Conditions de promotion des objets mémoire de nouvelle génération🎜

🎜Si les objets mémoire de la nouvelle génération souhaitent être promus à l'ancienne génération, ils doivent remplir les conditions suivantes : 🎜🎜🎜Objets S'il a subi un recyclage Scavenge🎜Le taux d'utilisation de la mémoire de ToSpace ne peut pas dépasser la limite🎜Déterminer s'il a expérimenté Scavenge La logique de GC est de donner l'attribut age de l'objet survivant +1 à chaque fois GC code>, et quand <code>GC est refait , jugez simplement l'attribut age. Le schéma de promotion de base est le suivant : 🎜🎜🎜🎜Il existe de nombreux objets survivants à long terme dans la mémoire de l'ancienne génération. La raison pour laquelle l'algorithme Scavenge ne peut pas être recyclé est : 🎜🎜🎜Le grand nombre d'objets survivants conduit à faible efficacité de copie 🎜La moitié de l'espace mémoire a été gaspillée

🎜L'algorithme de recyclage des objets mémoire d'ancienne génération🎜

🎜 Le garbage collection de l'espace mémoire d'ancienne génération est adopté. Il s'agit d'une combinaison de Mark Sweep (Mark-Sweep) et de Mark Compact ( Mark-Compact). Le marquage et le dédouanement se divise en deux parties : 🎜🎜🎜Phase de marquage🎜Phase de dédouanement (s'il s'agit de marquage et de tri, c'est la phase de tri)🎜Dans la phase de marquage, tous la mémoire dans la mémoire tas d'ancienne génération est parcourue par les objets et marquée par les objets actifs. La phase de nettoyage nettoie uniquement les objets non marqués. La raison en est que les objets non survivants représentent une minorité dans la mémoire des anciennes générations. 🎜🎜🎜🎜Comme ci-dessus Comme le montre la figure, un problème avec l'effacement des marques est qu'après l'effacement, il reste des espaces discontinus qui ne peuvent plus être utilisés. Par conséquent, le nettoyage de la mémoire de l'espace mémoire de l'ancienne génération doit être combiné avec une solution de tri des marques. Cette solution consiste à déplacer les objets vivants d'un côté pendant le processus de marquage, puis à nettoyer et à retirer tous les objets non vivants en dehors de la limite une fois le mouvement terminé. 🎜🎜🎜

🎜Pause complète pour le garbage collection🎜

🎜La logique d'exécution de l'application doit être suspendue pendant le garbage collection, et la logique d'exécution de l'application peut être reprise une fois le mécanisme de garbage collection terminé. Ce comportement est appelé « 🎜Pause complète🎜 », également connu sous le nom de Stop The World, ou STW en abrégé. Le garbage collection de mémoire de jeune génération a peu d'impact sur l'exécution des applications, mais comme il existe de nombreux objets survivants dans la mémoire d'ancienne génération, l'impact des pauses complètes provoquées par le garbage collection de mémoire d'ancienne génération est très important. 🎜🎜🎜🎜V8 Afin d'optimiser le temps de pause complet du GC, marque incrémentale, marque de concurrence, marque parallèle, finition incrémentale sont également présentés. code>, Nettoyage parallèle, Nettoyage différé et d'autres méthodes. 🎜

🎜Optimisation STW🎜

🎜Une mesure importante pour mesurer le temps passé dans le garbage collection est la durée pendant laquelle le thread principal est en pause lors de l'exécution de GC. L'impact de STW est inacceptable, c'est pourquoi V8 a également adopté de nombreuses méthodes d'optimisation. 🎜<ul><li>GC parallèle</li></ul> <p>Le processus de GC doit faire beaucoup de choses, ce qui conduit au phénomène STW sur le thread principal. La méthode du GC parallèle consiste à ouvrir plusieurs threads auxiliaires pour partager le travail du GC. Cette approche ne peut toujours pas éviter le phénomène STW, mais elle peut réduire la durée totale de STW, en fonction du nombre de threads auxiliaires activés. </p> <p><img src="https://img.php.cn/upload/image/795/713/176/165106317370481Parlons%20de%20lalgorithme%20de%20gestion%20de%20la%20m%C3%A9moire%20et%20de%20garbage%20collection%20du%20V8" title="165106317370481Parlons de lalgorithme de gestion de la mémoire et de garbage collection du V8" alt="1Parlons de lalgorithme de gestion de la mémoire et de garbage collection du V8"></p> <ul><li>Incremental<code>GCGC

增量GC将GC工作进行拆分，并在主线程中间歇的分步执行。该做法并不会减少GC的时间，相反会稍微花销，但是它同样会减少GC的STW的总时间。

• 并发GC

并发GC是指GC在后台运行，不再在主线程运行。该做法会避免STW现象。

• 空闲时间GC

Chrome中动画的渲染大约是60帧（每帧约16ms），如果当前渲染所花费时间每达到16.6ms，此时则有空闲时间做其他事情，比如部分GC任务。

减少垃圾回收的影响

想要提高执行效率要尽量减少垃圾回收的执行和消耗：

• 慎把内存当作缓存，小心把对象当作缓存，要合理限制过期时间和无限增长的问题，可以采用lru策略

• Node

  Incremental GC divise le travail GC et l'exécute par intermittence dans le thread principal. Cette approche ne réduira pas le temps GC, au contraire, elle coûtera un peu, mais elle réduira également le temps total STW du GC.
  • 
  Concurrent GC

Concurrent GC signifie que GC s'exécute en arrière-plan et ne s'exécute plus sur le thread principal. Cette approche évitera le phénomène STW.

🎜🎜 Le temps d'inactivité GC🎜🎜🎜Le rendu de l'animation dans Chrome est d'environ 60 images (chaque image dure environ 16 ms) >), Si le temps de rendu actuel atteint 16,6 ms, vous aurez du temps libre pour faire d'autres choses, comme certaines tâches GC. 🎜🎜🎜

Réduire l'impact du garbage collection

🎜Si vous souhaitez améliorer l'efficacité de l'exécution, vous devez minimiser l'exécution et la consommation du garbage collection : 🎜🎜🎜 🎜Soyez prudent lors de l'utilisation de la mémoire Pour la mise en cache, veillez à traiter les objets comme du cache Pour limiter raisonnablement le temps d'expiration et les problèmes de croissance infinie, vous pouvez utiliser la stratégie lru🎜🎜🎜🎜Node pour éviter d'utiliser la mémoire. pour stocker les sessions utilisateur, sinon ils seront stockés en mémoire. Un grand nombre d'objets de session utilisateur entraîne une augmentation de la mémoire d'ancienne génération, ce qui affecte les performances de nettoyage, puis affecte les performances d'exécution des applications et le débordement de mémoire. Façons améliorées d’utiliser Redis, etc. Avantages du déplacement du cache vers l'extérieur : 🎜🎜🎜 Réduisez le nombre d'objets de mémoire résidents et rendez le garbage collection plus efficace 🎜🎜 Le cache peut être partagé entre les processus 🎜🎜🎜🎜🎜 Pour plus de connaissances sur les nœuds, veuillez visiter : 🎜 Tutoriel nodejs🎜 ! 🎜

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!