performance optimizer Lua optimiser la mémoire



optimisation javascript (3)

Je quoi optimiser mon code. J'ai 3 option ne sais pas ce qui est mieux pour la mémoire dans Lua:

1)

local Test = {}
    Test.var1 = function ()
        -- Code
    end

    Test.var2 = function ()
        -- Code
    end

2) Ou

function var1()
    -- Code
end

function var2()
    -- Code
end

3) Ou peut-être

local var1 = function ()
    -- Code
end

local var2 = function ()
    -- Code
end

Answer #1

Aucun ne va vraiment affecter la mémoire, sauf l'utilisation d'une table en # 1 (donc environ 40 octets + une par entrée).

Si vous voulez les performances, alors l'option # 3 est bien meilleure, en supposant que vous puissiez accéder à ces fonctions à l'échelle locale.


Answer #2

Citant de Gem Programming Lua , les deux maximes de l'optimisation du programme:

  • Règle n ° 1: Ne le faites pas.
  • Règle n ° 2: Ne le faites pas encore. (pour les experts seulement)

Pour revenir à vos exemples, le deuxième morceau de code est un peu plus mauvais car l'accès aux globaux est plus lent. Mais la différence de performance est à peine perceptible.

Cela dépend de vos besoins, le premier utilise une table supplémentaire par rapport au troisième, mais l'espace de noms est plus propre.


Answer #3

Si l'utilisation de la mémoire est plus importante que le traitement et que vous utilisez la programmation orientée objet où vous instanciez plusieurs instances de Test comme indiqué ci-dessus, vous disposez d'une quatrième option avec les métabalises.

TestMt = {}
TestMt.func1 = function(self, ...)
    ...
end
TestMt.func2 = function(self, ...)
    ...
end
TestMt.func3 = function(self, ...)
    ...
end

function new_test()
    local t = {}
    t.data = ...
    setmetatable(t, {__index = TestMt})
    return t
end

foo = new_test()
foo:func1()
foo:func2()
foo:func3()

Si vous effectuez une programmation orientée objet, les métabalises peuvent entraîner des économies massives de mémoire (j'ai accidentellement utilisé plus d'1 gigaoctet une fois pour de nombreux vecteurs mathématiques de cette façon, pour le réduire à 40 mégaoctets en utilisant la métatable).

S'il ne s'agit pas d'objets et de tables instanciés à plusieurs reprises, et d'organiser vos fonctions accessibles au niveau mondial, il est ridicule de s'inquiéter de la mémoire. C'est comme mettre l'intégralité de votre code lua dans un seul fichier afin de réduire les frais généraux du système de fichiers. Vous parlez d'économies si négligeables que vous devriez vraiment avoir besoin d'un cas d'utilisation extraordinaire soutenu par des mesures méticuleuses pour vous soucier de cela.

S'il s'agit de traitement, vous pouvez obtenir de petites améliorations en gardant vos fonctions globales hors des tables imbriquées, et en favorisant les locaux quand cela est possible.





lua