Comment mon programme de Go de conserver tous les cœurs de PROCESSEUR occupé?
Goroutines sont légers processus qui sont automatiquement le temps en tranches sur un ou plusieurs threads du système d'exploitation par la Aller de l'exécution. (C'est un vraiment cool fonctionnalité de Go!)
Supposons que j'ai une demande concurrente comme un serveur web. Il y a beaucoup de choses qui se sont produites simultanément dans mon hypothétique programme, sans beaucoup de non-simultanées (la Loi d'Amdahl) ratio.
Il semble que par défaut, le nombre de threads du système d'exploitation en cours d'utilisation est actuellement de 1. Est-ce à dire qu'un seul cœur de PROCESSEUR utilisé?
Si je commence mon programme avec
runtime.GOMAXPROCS(runtime.NumCPU())
fera que donner raisonnablement efficace l'utilisation de tous les cœurs sur mon PC?
Est-il un "parallèle à la paresse" de bénéficier de la encore plus OS threads en cours d'utilisation, par exemple par le biais de certaines heuristiques
runtime.GOMAXPROCS(runtime.NumCPU() * 2)
?
Vous devez vous connecter pour publier un commentaire.
De l'Aller FAQ:
(Mise à JOUR 8/28/2015: Aller de 1,5 à la valeur par défaut de GOMAXPROCS le même que le nombre de Processeurs de votre machine, donc cela ne devrait pas être un problème plus)
Et
En bref: il est très difficile de faire Passer l'utilisation "utilisation efficace de tous vos cœurs". Simplement la ponte d'un milliard de goroutines et l'augmentation de GOMAXPROCS est tout aussi susceptibles de dégrader la performance de l'accélérer, car il sera de commutation de contextes de thread tout le temps. Si vous avez un grand programme qui est parallélisable, l'augmentation de GOMAXPROCS au nombre de parallèles composants fonctionne très bien. Si vous avez un parallèle problème incorporé dans une grande partie de la non-parallèles programme, il peut prendre de la vitesse, ou vous pourriez avoir à faire un usage créatif des fonctions comme l'exécution.LockOSThread() afin d'assurer l'exécution distribue tout correctement (en général Aller juste dumbly se propage actuellement non-blocage des Goroutines au hasard et de manière égale entre tous les threads actifs).
Aussi, GOMAXPROCS est le nombre de cœurs de PROCESSEUR à utiliser, si il est plus grand que NumCPU je suis assez sûr qu'il suffit de pinces à NumCPU. GOMAXPROCS n'est pas strictement égal au nombre de threads. Je ne suis pas sûr à 100% de exactement lorsque le moteur d'exécution décide de frayer de nouveaux threads, mais un exemple est lorsque le nombre de bloquer les goroutines à l'aide d'exécution.LockOSThread() est supérieure ou égale à GOMAXPROCs -- il va engendrer encore plus de threads que de cœurs de sorte qu'il peut garder le reste du programme en cours d'exécution sainement.
Fondamentalement, c'est assez simple pour augmenter GOMAXPROCS et de faire des aller utilisation tous les cœurs de votre PROCESSEUR. Il est tout à fait autre chose à ce moment dans le jeu de Go est le développement de la faire à intelligemment et efficacement l'utilisation tous les cœurs de votre PROCESSEUR, nécessitant beaucoup de la conception du programme et finagling pour obtenir le droit.
Cette question ne peut être répondu, il est beaucoup trop large.
Prendre votre problème, votre algorithme et votre charge de travail et de mesurer ce qui est le mieux pour cette combinaison.
Personne ne peut répondre à une question comme "Est-il heuristique que l'ajout de deux fois la quantité de sel à mon déjeuner le rendre meilleur goût?" car cela dépend du déjeuner (tomates bénéficier beaucoup plus de sel que les fraises) de votre goût et de la quantité de sel qui y est déjà. L'essayer.
Sur plus:
runtime.GOMAXPROCS(runtime.NumCPU())
a atteint le statut de culte, mais de contrôler le nombre de threads par la définition de la GOMAXPROCS variable d'environnement à partir de la à l'extérieur pourrait être la meilleure option.runtime.GOMAXPROCS()
définit le nombre de (virtuelle) de cœurs de PROCESSEUR que votre programme peut utiliser simultanément. Permettant d'accéder à plus de cœurs que vous avez réellement ne vous aidera pas, que votre système ne dispose de beaucoup de cœurs du PROCESSEUR.Pour exécuter la commande dans plus d'un thread, votre programme doit avoir plusieurs goroutines, généralement des appels de fonction avec
go someFunc()
. Si votre programme ne démarre pas tout supplémentaire goroutines il va naturellement s'exécuter dans un thread n'importe comment beaucoup de Processeurs/cœurs de vous autoriser à utiliser.Découvrez cette et les exercices suivants sur la façon de créer des goroutines.
runtime.GOMAXPROCS
ne change pas le nombre de threads que votre programme peut s'exécuter, cependant. Il modifie le nombre de Processeurs sur lesquels ces threads peuvent s'exécuter. Découvrezruntime.NumGoroutine
de voir comment de nombreux threads/goroutines votre programme a donné naissance.