Comment avez-vous pré-de la taille d'un tableau en Lua?

J'ai un programme Lua qui semble être plus lent qu'il devrait être. Je soupçonne que le problème c'est que je suis ajoutant des valeurs à un tableau associatif, un à un, et le tableau a pour allouer de la mémoire à chaque fois.

Il ne semble pas être une table.setn fonction, mais il n'a pas sous Lua 5.1.3:

stdin:1: 'setn' is obsolete
stack traceback:
        [C]: in function 'setn'
        stdin:1: in main chunk
        [C]: ?

Je déduis de la recherche sur Google je n'ai fait que cette fonction a été déprécié en Lua 5.1, mais je ne peux pas trouver ce que (le cas échéant) a remplacé la fonctionnalité.

Savez-vous comment pré de la taille d'un tableau en Lua?

Sinon, est-il un autre moyen d'éviter l'allocation de la mémoire lorsque vous ajoutez un objet à un tableau?

J'ai lu cela pour le plaisir l'autre jour, mais si vous êtes intéressé par lua performance, vous devriez consulter ce document sur la mise en œuvre de la lua, elle va au-dessus de quelques structures de données internes. lua.org/doc/jucs05.pdf

OriginalL'auteur Jon Ericson | 2008-09-23

  1. 9

    Laissez-moi me concentrer plus sur votre question:

    ajoutant les valeurs d'un tableau associatif
    un à un

    Tables en Lua sont associatives, mais de les utiliser dans un tableau (1..N) est optimisée. Ils ont des doubles faces, interne.

    Donc.. Si vous êtes ajoutant des valeurs associative, suivez les règles ci-dessus.

    Si vous êtes en utilisant des indices 1..N, vous pouvez forcer une seule fois la taille de réajuster par la mise en t[100000]= quelque chose. Cela devrait fonctionner jusqu'à ce que la limite d'optimisé la taille du tableau, précisé dans Lua sources (2^26 = 67108864). Après cela, tout est associative.

    p.s. Le vieux "setn la méthode des" traités de la matrice partie seulement, donc ne pas utiliser pour l'associatif l'utilisation (ignorer ces réponses).

    p.p.s. Avez-vous étudié conseils généraux pour garder Lua de haute performance? c'est à dire savoir la création de la table et plutôt de la réutilisation d'un tableau que d'en créer un nouveau, recours à des "locaux print=imprimer" pour éviter d'accès globaux.

    Je n'ai pas regardé dans Lua de la performance en général, mais je suis certainement intéressés. En fait, j'ai juste posé la question: stackoverflow.com/questions/154672/...
    Cette réponse n'est pas vrai (ou plus?), selon "Lua conseils relatifs à la performance" (voir ici lua.org/gems), Lua analyse de la table et place des valeurs dans la table de hachage de la partie si le tableau de la partie a moins de array_N/2, de sorte que la construction de t = {}; t[100000] = true entraînerait un tableau vide, et d'une partie de hachage avec un seul élément.

    OriginalL'auteur akauppi

  2. 7
    static int new_sized_table( lua_State *L )
{
    int asize = lua_tointeger( L, 1 );
    int hsize = lua_tointeger( L, 2 );
    lua_createtable( L, asize, hsize );
    return( 1 );
}

...

lua_pushcfunction( L, new_sized_table );
lua_setglobal( L, "sized_table" );

    Puis, en Lua,

    array = function(size) return sized_table(size,0) end

a = array(10)

    Comme un petit hack pour obtenir cette course, vous pouvez ajouter la C à lua.c.

    Est-il une raison pourquoi ce n'est pas prévu par défaut? Dans, disons, de la table de la bibliothèque.

    OriginalL'auteur

  3. 5

    Je ne pense pas que vous pouvez - c'est pas un tableau, c'est un tableau associatif, comme perl de hachage ou d'un awk tableau.

    http://www.lua.org/manual/5.1/manual.html#2.5.5

    Je ne pense pas que vous pouvez prérégler sa taille de façon significative à partir de la Lua côté.

    Si vous êtes l'allocation de l'ensemble sur le côté C, si, le 

    void lua_createtable (lua_State *L, int narr, int nrec);

    peut-être ce dont vous avez besoin.

    Crée une nouvelle table vide et pousse
    sur la pile. La nouvelle table a
    l'espace pré-alloués pour narr tableau
    les éléments et les nrec non les éléments du tableau.
    Cette pré-allocation est utile lorsque vous
    savoir exactement combien d'éléments de la
    table. Sinon, vous pouvez utiliser
    la fonction lua_newtable.

    D'autre part, .NET du Système.Collection.Table de hachage ne dispose d'un constructeur avec une capacité de paramètre.
    En interne, l'ensemble les touches de numéro de Lua tables sont en fait stockées dans un tableau. Le reste sont stockées dans un tableau associatif comme vous l'avez dit.

    OriginalL'auteur Mike G.

  4. 2

    Si vous déclarez votre table dans le code avec une quantité spécifique d'éléments, comme:

    local tab = { 0, 1, 2, 3, 4, 5, ... , n }

    puis Lua va créer la table avec mémoire déjà allouée pour au moins n éléments.

    Cependant, Lua utilise le 2x différentiels d'allocation de mémoire technique, l'ajout d'un élément à un tableau rarement la force d'une réaffectation.

    OriginalL'auteur GhassanPL

  5. 1

    Il y a encore un interne luaL_setn et vous pouvez compiler Lua, de sorte que
    il est exposé dans le tableau.setn. Mais on dirait qu'il ne va pas aider
    parce que le code ne semble pas faire de pré-extension.

    (Setn comme indiqué au-dessus de la setn est liée à la matrice de la partie
    d'une table Lua, et vous avez dit que vous êtes à l'aide de la table comme un cadre associatif
    array)

    La bonne nouvelle est que même si vous ajoutez les éléments un par un, Lua ne pas
    augmentation de la matrice de cette façon. Au lieu de cela il utilise une stratégie plus raisonnable. Vous avez encore
    obtenir plusieurs allocations pour un ensemble plus grand, mais la performance est meilleure que
    obtenir une nouvelle affectation à chaque fois.

    Pour le générique de situations, c'est une stratégie raisonnable, mais pour ce programme particulier, je sais exactement comment grand la table doit être.

    OriginalL'auteur EPa

  6. 1

    Bien que ce n'est pas la réponse à votre question principale, il répond à ta deuxième question:

    Sinon, est-il un autre moyen d'éviter l'allocation de la mémoire lorsque vous ajoutez un objet à un tableau?

    Si votre exécution de Lua dans une application personnalisée, tant que je peux deviner depuis votre faire C de codage, je vous suggère de remplacer l'allocateur avec Loki petite valeur de l'allocateur, il réduit mes allocations de mémoire+ de 100 fois. Cela améliore les performances en évitant les allers-retours vers le Noyau, et m'a fait un beaucoup plus heureux programmeur 🙂

    De toute façon j'ai essayé d'autres allocateurs, mais ils étaient plus générale, et à fournir une garantie qui ne bénéficient pas de Lua applications (telles que la sécurité des threads, et les grandes allocation des objets, etc...), également à l'écriture de votre propre petit-objet de l'allocateur peut être une bonne semaine de programmation et de débogage pour obtenir juste à droite, et après avoir cherché une solution disponible Loki allocateur était la plus facile et la plus rapide que j'ai trouvé pour ce problème.

    OriginalL'auteur Robert Gould