LoriotPro Extended Edition Programmation en language LUA

Table des matières

HelpLUA

Récupération de la mémoire utilisée


Objets inaccessibles

Dans les langues telles que C et C++, des objets que nous créons au temps d'exécution (par exemple employer malloc() ou new) doivent être explicitement supprimés. Les fuites de mémoire sont le résultat des objets étant assignés, obtenant perdues et non jamais libérées. Il est possible d'écrire les systèmes de piste de mémoire qui assignent la mémoire pour nous et savent quand nous n'avons besoin plus d'elle. Quelques langues ont ce dispositif incorporé, y compris Lua.

Il y a de diverses manières dont du cheminement des objets de mémoire ne sont plus eu besoin. Une fois aucun d'des variables d'applications ne met en référence un objet qu'elle serait inaccessible. Objets qui ne sont plus accessibles devenus deleteable et sont des candidats pour la disposition automatique, ou collection d'ordures.

Dans les exemples suivants nous créons quelques objets de Lua et leur assignons à l'des variables. Si nous assignons d'autres valeurs aux variables, et aucune autre variable ne met en référence les objets précédents, ils deviennent inaccessibles. Si elle n'étaient pas pour la collection d'ordures ceci causerait une fuite de mémoire. Par exemple,

> t = {this="table" ; 1.2.3} -- construisez 
une table et assignez-l'à "t" > t = zéro -- placent "t" à zéro et 
à la table devient inaccessible > > s = "une corde" -- créez la 
variable de corde > le s = une "autre corde" -- quand l'ensemble à 
l'autre valeur la vieille valeur devient inaccessible

Algorithmes simples de collection

Il y a de divers types de collecteurs et beaucoup de terminologie lié à la collection d'ordures [ 1 ]. Un des algorithmes de collection les plus simples est compte de référence. Ici nous maintenons juste un compte dans chaque objet assigné, du nombre d'objets le mettant en référence (ou l'employant). Si le nombre d'objets mettant en référence un autre objet tombe à zéro il devient inaccessible (et inutilisé) et peut être libéré. Une légère complication avec ceci est mise en référence cyclique, où l'objet A met en référence l'objet B, et B met en référence A. C'est très bien aussi longtemps que d'autres objets mettent en référence A et/ou B, mais quand ils pas plus, A et B formeront une île. Ils sont maintenant un groupe d'objets qui sont inaccessibles et mutuellement permanents en raison de la mise en référence cyclique. L'île ne sera jamais libérée à moins que la référence comptant l'algorithme de collection soit augmentée. Par exemple,

> a = {} > b = {} > a['other '] = b > b['other '] = a -- maintenant nous avons une référence
> un a,b = un zéro cycliques, zéro -- l'OH cher, nous n'avons pas une référence aux 2 tables maintenant
> -- il y a deux tables qui sont inaccessibles

Marque et champ

Se débarasser des îles de l'algorithme décrit ci-dessus que nous pourrions voyager par toutes les variables dans notre système et voir quels objets ils mettent en référence. Si objets de trouvaille de variables les certains inaccessibles nous des ordures de bidon les rassemblent. Cet algorithme s'appelle la marque et champ, c.-à-d., nous marquons tous les objets accessibles et balayons loin ceux restants. Lua emploie l'algorithme de marque et de collection d'ordures de champ exclusivement. Ceci a l'avantage que nous ne devons pas mettre en référence des objets de compte et ainsi n'obtient pas la répétition mettant en référence des problèmes. Un inconvénient est que l'algorithme prend du temps de traiter et peut être une issue dans des applications en temps réel.

Note: Si nous devions distribuer le traitement de la marque et balayer l'algorithme de collection, de sorte qu'il n'ait pas été tout fait immédiatement, il serait plus transparent au système hôte. Ceci s'appelle collection par accroissement d'ordures. Ce changement est projeté pour la version 5.1 de Lua.

Commande et statut

Lua fournit quelques fonctions pour commander et questionner le statut de collection d'ordures. Il y a plus de détails dans le CoreFunctionsTutorial.

collectgarbage([limit]) place le seuil auquel la collection d'ordures est lancée. Elle peut s'appeler sans arguments pour forcer une collection immédiate.

gcinfo() retours deux nombres : la quantité de mémoire que Lua a assignée et du seuil courant de collecteur d'ordures. Tous les deux sont en K bytes.

Plus de lecture

D'autres pages sur le wiki couvrent la collection d'ordures dans Lua en plus détail. Ce qui suit est lecture suggérée :



LUTEUS www.loriotpro.com