paramètres multicœurs Golang

Golang est un langage de programmation moderne et performant qui est largement utilisé dans les services réseau, le cloud computing, l'analyse de données et d'autres domaines. Golang est un langage multiplateforme avec d'excellentes performances de concurrence, et son mécanisme de concurrence par défaut est également très puissant. Par défaut, Golang utilise les coroutines Goroutine pour obtenir la concurrence et peut facilement gérer des milliers de connexions simultanées. Cependant, si vous devez exécuter des programmes Golang sur des processeurs multicœurs, vous devez définir certains paramètres supplémentaires.

Cet article expliquera comment configurer le multicœur dans Golang pour améliorer les performances de concurrence du programme.

1. Qu'est-ce que le réglage multicœur ?

Le paramètre multicœur (ou paramètre multiprocesseur) signifie que lors de l'exécution d'un programme Golang sur un processeur multicœur, en définissant certains paramètres de fonctionnement, le programme peut utiliser pleinement la puissance de traitement du processeur multicœur, améliorant ainsi les performances de concurrence du programme.

Par défaut, le mécanisme de concurrence de Golang n'utilisera qu'un seul cœur. En effet, le planificateur (Scheduler) utilisé par Golang est basé sur une planification coopérative (Cooperative Scheduling), c'est-à-dire que ce n'est que lorsque le Goroutine actuel abandonne activement le processeur qu'il passera à un autre Goroutine, garantissant ainsi qu'il n'y a qu'un seul Goroutine. en même temps. En exécution. Bien que ce mécanisme soit simple et efficace, il ne peut utiliser qu’un seul cœur et ne peut pas exploiter pleinement les avantages en termes de performances des processeurs multicœurs.

Par conséquent, lors d'une configuration multicœur, certains paramètres spéciaux sont nécessaires pour permettre au planificateur de Golang de planifier Goroutine sur plusieurs cœurs et d'équilibrer la charge sur différents cœurs, améliorant ainsi les performances de concurrence du programme.

2. Comment configurer les paramètres multicœurs ?

Les paramètres multicœurs dans Golang nécessitent l'utilisation d'appels système. Il existe principalement trois fonctions :

1. runtime.GOMAXPROCS(n int)

Cette fonction est utilisée pour définir le nombre maximum de cœurs de processeur utilisés lorsque le code. est en marche. Sa valeur par défaut est 1, qui n'utilise qu'un seul cœur. S'il est défini sur une valeur supérieure à 1, Golang exécutera Goroutine sur des processeurs multicœurs. Par exemple :

runtime.GOMAXPROCS(4) //Utilisez 4 cœurs pour exécuter le programme

2. runtime.LockOSThread()

Cette fonction est utilisée pour verrouiller la Goroutine actuelle sur le thread actuel afin d'empêcher le planificateur de changer vers une autre exécution sur le thread, réduisant ainsi la surcharge de changement de thread. Par exemple :

func loop() {

runtime.LockOSThread()  //锁定当前协程到当前线程
//进行一些处理

}

3. runtime.UnlockOSThread()

Cette fonction est utilisée pour déverrouiller la Goroutine actuelle du thread actuel, afin qu'elle puisse être basculée vers d'autres threads par le planificateur. Par exemple :

func loop() {

//进行一些处理
runtime.UnlockOSThread()  //解锁当前协程

}

Si la fonction UnlockOSThread n'est pas appelée, la coroutine actuelle ne pourra jamais quitter le thread actuel.

3. Comment évaluer l'effet des paramètres multicœurs ?

Avant de définir les paramètres multicœurs, vous devez évaluer les performances du programme actuel dans des environnements monocœur et multicœur afin de pouvoir améliorer les performances du programme grâce aux paramètres multicœurs.

Pour évaluer les performances du programme, vous pouvez utiliser le propre outil d'analyse des performances de Go, pprof. pprof peut analyser l'utilisation du processeur et de la mémoire du programme pour découvrir les goulots d'étranglement des performances dans le code.

1. Installez pprof

Vous devez d'abord installer pprof :

allez chercher -u github.com/google/pprof

2 Exécutez pprof

Utilisez pprof pour analyser les performances du programme. Vous devez ajouter. code de profilage au programme, et activez-le :

package main

import (

"math/rand"
"os"
"runtime/pprof"
"time"

)

func main() {

pprofFile, err := os.Create("cpu.prof")
if err != nil {
    panic(err)
}
pprof.StartCPUProfile(pprofFile)
defer pprof.StopCPUProfile()

rand.Seed(time.Now().UnixNano())
for i := 0; i < 10; i++ {
    go func() {
        for {
            num := rand.Intn(1000000000)
            _ = num * num
        }
    }()
}

time.Sleep(10 * time.Second)

}

Une fois le programme exécuté, un fichier cpu.prof sera généré dans le répertoire courant, contenant l'utilisation du processeur du programme. Vous pouvez utiliser la commande suivante pour l'analyse :

pprof -http=:9999 cpu.prof

Cette commande démarrera un serveur Web accessible via http://localhost:9999/ dans le navigateur. Sur la page Web, vous pouvez afficher l'utilisation du processeur du programme, les relations d'appel de fonction et les durées d'appel pour identifier les goulots d'étranglement des performances.

3. Comparez les performances monocœur et multicœur

Avec l'outil pprof, vous pouvez exécuter des programmes dans des environnements monocœur et multicœur et comparer leurs performances.

Pour comparer les performances monocœur et multicœur, vous devez définir le paramètre GOMAXPROCS lors de l'exécution du programme :

go run -race -p=1 main.go //Exécution monocœur
go run -race - p=4 main.go //Quatre noyaux en cours d'exécution

Utilisez pprof pour effectuer une analyse des performances du programme exécuté deux fois et comparer son utilisation du processeur et le nombre d'appels de fonction. En comparant les résultats de l'analyse des performances, les goulots d'étranglement des performances dans le programme peuvent être détectés et optimisés.

4. Résumé

Golang exécute Goroutine sur un seul cœur par défaut, ce qui ne peut pas utiliser pleinement la puissance de traitement des processeurs multicœurs. L'exécution de programmes Golang sur un processeur multicœur nécessite des paramètres multicœurs, notamment la définition des paramètres GOMAXPROCS et l'utilisation des fonctions LockOSThread et UnlockOSThread.

Afin d'évaluer l'effet des paramètres multicœurs, vous pouvez utiliser le propre outil d'analyse des performances de Go, pprof, pour découvrir les goulots d'étranglement des performances du programme et les optimiser.

Grâce aux paramètres multicœurs, vous pouvez utiliser pleinement la puissance de traitement des processeurs multicœurs, améliorant ainsi les performances simultanées du programme.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!