Lua :: Comment écrire le programme simple qui vous permettra de charger plusieurs Processeurs?
Je n'ai pas été capable d'écrire un programme en Lua qui vous permettra de charger plus d'un CPU. Depuis Lua prend en charge le concept via coroutines, je crois que c'est réalisable.
Raison pour moi à défaut peut-être:
- Il n'est pas possible en Lua
- Je ne suis pas capable de l'écrire ☺ (et je espère c'est le cas )
Quelqu'un peut plus expérimentés (j'ai découvert Lua il y a deux semaines) me pointer dans la bonne direction?
The point is to write a number-crunching script that does hi-load on ALL cores...
À des fins de démonstration de la puissance de Lua.
Merci...
Vous devez vous connecter pour publier un commentaire.
Lua coroutines sont pas la même chose que les threads dans le système d'exploitation de sens.
OS threads sont de préemption. Cela signifie qu'ils peuvent exécuter de manière arbitraire, de voler timeslices dictée par l'OS. Ils courent sur des processeurs différents, s'ils sont disponibles. Et ils peuvent s'exécuter en même temps si possible.
Lua coroutines de ne pas faire cela. Coroutines peut avoir le type "fil", mais il ne peut jamais être un seul coroutine active à la fois. Une coroutine jusqu'à la coroutine lui-même décide d'arrêter l'exécution par l'émission d'un
coroutine.yieldde commande. Et une fois qu'il les rendements, il ne sera pas exécuté de nouveau jusqu'à ce qu'une questions de routine d'uncoroutine.resumecommande à la coroutine.Lua coroutines fournir coopérative multithreading, qui est pourquoi ils sont appelés coroutines. Ils coopèrent les uns avec les autres. Une seule chose s'exécute à un moment, et vous n'passer des tâches, lorsque les tâches explicitement dire de le faire.
Vous pourriez penser que vous pouvez simplement créer OS threads, créer des coroutines en Lua, et puis il suffit de reprendre chacun dans un système d'exploitation différent du thread. Ce serait le travail, aussi longtemps que chaque OS thread en cours d'exécution de code dans un autre Lua instance. L'API Lua est réentrant; vous êtes autorisé à appeler à partir de différents OS threads, mais seulement si l'appelant à partir de différents Lua instances. Si vous essayez d'multithread par la même Lua exemple, Lua va probablement faire de mauvaises choses.
Tous les Lua filetage modules qui existent créer d'autres Lua instances pour chaque thread. Lua-lltreads juste fait un tout nouveau Lua instance pour chaque thread; il n'y a pas d'API pour le fil-à-fil de la communication à l'extérieur de la copie de paramètres passés au nouveau thread. LuaLanes fournit une cross-connexion code.
Il n'est pas possible avec le noyau de bibliothèques Lua (si vous ne comptez pas la création de plusieurs processus et de communiquer via l'entrée/sortie), mais je pense qu'il y a Lua liaisons pour les différentes bibliothèques de threading là-bas.
La réponse de jpjacobs à l'une des questions connexes des liens vers LuaLanes, ce qui semble être un multi-threading de la bibliothèque. (Je n'ai aucune expérience, si.)
Si vous incorporez Lua dans une application, vous aurez envie d'avoir le multithreading en quelque sorte lié à vos applications multithread.
En plus de LuaLanes, jetez un oeil à llthreads
En plus de la déjà suggéré LuaLanes, llthreads et d'autres choses mentionnées ici, il y a un moyen plus simple.
Si vous êtes sur un système POSIX, essayez de le faire dans l'ancienne avec de
posix.fork()(à partir de luaposix). Vous savez, diviser la tâche des lots, de la fourche le même nombre de processus que le nombre de cœurs, de calculer les nombres, de collationner les résultats.Aussi, assurez-vous que vous utilisez LuaJIT 2 pour obtenir la vitesse max.
C'est très facile il suffit de créer plusieurs Lua interprètes et d'exécuter des programmes lua à l'intérieur de tous.
Lua le multithreading est partagée rien de modèle. Si vous avez besoin d'échanger des données, vous devez sérialiser les données en chaînes et de les transmettre à partir d'un interprète à l'autre avec un c de l'extension ou de sockets ou n'importe quel type de l'IPC.
La sérialisation de données via IPC-comme des mécanismes de transport n'est pas la seule façon de partager des données entre threads.
Si vous êtes à la programmation dans un langage orienté objet comme le C++ il est tout à fait possible que plusieurs threads d'accéder à des objets partagés dans les threads via des pointeurs d'objet, c'est juste pas de danger à le faire, sauf si vous fournissez une sorte de garantie que deux threads tentent simultanément d'écrire et de lire sur les mêmes données.
Il existe de nombreuses options pour la façon dont vous pourriez le faire, sans verrouillage et d'attendre sans mécanismes sont de plus en plus populaire.