Cette page a été traduite par l'API Cloud Translation.

Définir le nombre de threads par cœur

Linux Windows

Le multithreading simultané (SMT), connu sur les processeurs Intel comme la technologie Hyper-Threading (HTT), permet à un cœur de processeur de s'exécuter sous la forme de deux multithreads matériels. Sur Compute Engine, chaque processeur virtuel (vCPU) est implémenté sous la forme d'un multithread matériel unique, et deux processeurs virtuels partagent par défaut chaque cœur de processeur physique.

Compute Engine vous permet de définir manuellement la valeur du nombre de threads par cœur. Par exemple, les charges de travail soumises aux problématiques suivantes peuvent tirer parti de la désactivation du multithreading simultané (c'est-à-dire définir le nombre de threads par cœur sur 1) :

Performance : La réduction du nombre de threads s'exécutant sur chaque cœur de processeur physique peut améliorer les performances des charges de travail qui sont hautement parallèles ou effectuent des calculs à virgule flottante.
Sécurité : Si une VM exécute du code non approuvé, la réduction du nombre de threads par cœur peut atténuer les failles du processeur telles que l'échantillonnage des données microarchitecturales.
Licences : Certains contrats de licence comportent des exigences liées au nombre de processeurs virtuels que vous consommez. Réduire le nombre de threads par cœur de 2 à 1 peut réduire les coûts de licence. Pour plus d'informations, consultez votre contrat de licence.

Pour de nombreuses tâches de calcul générales ou nécessitant de nombreuses E/S, le multithreading simultané peut augmenter considérablement le débit de l'application. Pour les jobs de calcul dans lesquels les deux cœurs virtuels sont liés au calcul, le multithreading simultané (SMT) peut nuire aux performances globales de l'application et ajouter une variance imprévisible aux jobs. Dans ce cas, la désactivation du SMT permet de bénéficier de performances plus prévisibles et peut réduire les durées des jobs.

Limites

Vous ne pouvez pas définir le nombre de threads par cœur sur les VM pour les types de machines suivants:
- Tous les types de machines H3
- Tous les types de machines Tau T2A
- Tous les types de machines Tau T2D
- Types de machines comportant moins de deux processeurs virtuels, par exemple n1-standard-1
- Types de machines à cœur partagé, tels que e2-small.
Pour les instances Bare Metal C3 et X4, le nombre d'hyperthreads auxquels vous avez accès est équivalent au nombre d'hyperthreads de la machine.
Dans la console Google Cloud, lorsque le nombre de threads par cœur est défini sur 1, la métrique d'utilisation du processeur ne peut évoluer que jusqu'à 50 %. Lorsque le nombre de threads par cœur est défini sur 2, la métrique d'utilisation du processeur peut évoluer jusqu'à 100 %.

Tarifs

Le nombre de processeurs virtuels définis par le type de machine d'une VM vous est facturé, et non le nombre de threads qui s'exécutent sur chaque cœur. Par exemple, le type de machine n2-standard-8 peut exécuter jusqu'à huit processeurs virtuels, soit deux processeurs virtuels pour chacun des quatre cœurs du processeur physique. Si vous utilisez le type de machine n2-standard-8 et que vous décidez d'exécuter un seul thread par cœur (soit quatre processeurs virtuels), vous êtes toujours facturé pour huit processeurs virtuels. Pour en savoir plus sur le mode de facturation des VM, consultez la page Tarifs des instances de VM.

Modifier le nombre de threads par cœur lors de la création d'une VM

Pour modifier le nombre de threads par cœur lors de la création de la VM, utilisez la console Google Cloud, gcloud CLI ou l'API Compute Engine.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

Toutes les autorisations requises pour créer une VM

Console

Pour modifier le nombre de threads par cœur lors de la création de la VM, procédez comme suit avec la console Google Cloud :

Accédez à la page Créer une instance dans Google Cloud Console.

Accéder à la page Créer une instance
Dans le champ Nom, saisissez un nom pour la VM.
Choisissez une région et une zone pour la VM.
Choisissez une Famille de machines et un Type de machine compatibles.
Cliquez sur Configurations avancées pour développer la section.
Dans la section Ratio vCPU/cœurs, choisissez le nombre de threads par cœur.
Terminez la configuration des autres paramètres de la VM, puis cliquez sur Créer.

gcloud

Pour modifier le nombre de threads par cœur lors de la création de la VM, utilisez la commande gcloud compute instances create.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

VM_NAME : nom de la nouvelle VM.
ZONE : zone de la nouvelle VM.
MACHINE_TYPE : type de machine pour la nouvelle VM. Doit être un type de machine avec deux processeurs virtuels ou plus.
THREADS_PER_CORE : nombre de threads par cœur physique. Définissez cette valeur sur 2 ou 1.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud compute instances create VM_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --threads-per-core=THREADS_PER_CORE

Windows (PowerShell)

gcloud compute instances create VM_NAME `
    --zone=ZONE `
    --machine-type=MACHINE_TYPE `
    --threads-per-core=THREADS_PER_CORE

Windows (cmd.exe)

gcloud compute instances create VM_NAME ^
    --zone=ZONE ^
    --machine-type=MACHINE_TYPE ^
    --threads-per-core=THREADS_PER_CORE

Vous devriez obtenir un résultat semblable à celui-ci :

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME].
NAME: VM_NAME
ZONE: ZONE
MACHINE_TYPE: MACHINE_TYPE
PREEMPTIBLE:
INTERNAL_IP: EXTERNAL_IP
EXTERNAL_IP: INTERNAL_IP
STATUS: RUNNING

REST

Pour modifier le nombre de threads par cœur lors de la création de la VM, utilisez la méthode instances.insert avec le champ threadsPerCore.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PROJECT_ID : ID du projet.
ZONE : zone de la nouvelle VM.
MACHINE_TYPE : type de machine pour la nouvelle VM. Doit être un type de machine avec deux processeurs virtuels ou plus.
VM_NAME : nom de la nouvelle VM.
THREADS_PER_CORE : nombre de threads par cœur physique. Définissez cette valeur sur 2 ou 1.

Méthode HTTP et URL :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

Corps JSON de la requête :

{
  "machineType": "projects/PROJECT_ID/zones/ZONE/machineTypes/MACHINE_TYPE",
  "name": "VM_NAME",
  "advancedMachineFeatures": {
    "threadsPerCore": THREADS_PER_CORE
  },
  "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/family/debian-11"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ]
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances"

PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances" | Select-Object -Expand Content

APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :

{
  "kind": "compute#operation",
  "id": "7334609091572405391",
  "name": "operation-1663806045894-5e939085735d8-7499db32-c12fcc03",
  "zone": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE",
  "operationType": "insert",
  "targetLink": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME",
  "targetId": "1226375378512516273",
  "status": "RUNNING",
  "user": "EMAIL_ADDRESS",
  "progress": 0,
  "insertTime": "2022-09-21T17:20:48.751-07:00",
  "startTime": "2022-09-21T17:20:48.751-07:00",
  "selfLink": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/operations/operation-1663806045894-5e939085735d8-7499db32-c12fcc03"
}

Modifier le nombre de threads par cœur sur une VM

Pour modifier le nombre de threads par cœur sur une VM, utilisez la console Google Cloud, gcloud CLI ou l'API Compute Engine.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

compute.instances.get sur le projet
compute.instances.update sur le projet

Console

Pour modifier le nombre de threads par cœur sur une VM existante, procédez comme suit dans la console Google Cloud :

Dans Google Cloud Console, accédez à la page Instances de VM.

Accéder à la page Instances de VM
Cliquez sur le Nom de la VM.
Si l'état de la VM est En cours d'exécution, cliquez sur Arrêter.
Cliquez sur Modifier.
Cliquez sur Configurations avancées pour développer la section.
Dans la liste déroulante Ratio vCPU/cœurs, choisissez le nombre de threads par cœur.
Cliquez sur Enregistrer.

gcloud

Pour modifier le nombre de threads par cœur sur une VM existante, procédez comme suit :

Exportez les propriétés de la VM à l'aide de la commande gcloud compute instances export suivante :
```
gcloud compute instances export VM_NAME \
    --destination=YAML_FILE_PATH \
    --zone=ZONE
```
Remplacez l'élément suivant :
- VM_NAME : nom de la VM à partir de laquelle exporter les propriétés
- YAML_FILE_PATH : chemin d'accès et nom du fichier .yaml dans lequel enregistrer les données de configuration exportées
- ZONE : zone contenant la VM
Dans le fichier de configuration de la VM enregistré dans FILE_PATH, mettez à jour la valeur de threadsPerCore. Si la valeur ne figure dans le fichier, ajoutez l'élément suivant :
```
advancedMachineFeatures:
  threadsPerCore: THREADS_PER_CORE
```
Mettez à jour la VM avec le nouveau nombre de threads par cœur à l'aide de la commande gcloud compute instances update-from-file suivante :
```
gcloud compute instances update-from-file VM_NAME \
    --source=FILE_PATH \
    --most-disruptive-allowed-action=RESTART \
    --zone=ZONE
```
Remplacez l'élément suivant :
- VM_NAME : nom de la VM à mettre à jour
- FILE_PATH : chemin d'accès au fichier de configuration de la VM mis à jour
- ZONE : zone contenant la VM à mettre à jour

REST

Pour modifier le nombre de threads par cœur sur une VM existante, utilisez la méthode instances.update suivante :

PUT https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME?most_disruptive_allowed_action=RESTART

{
  ...
  "advanced_machine_features": {
    ...
    "threadsPerCore": "THREADS_PER_CORE"
  },
  ...
}

Remplacez les éléments suivants :

PROJECT_ID : ID du projet
ZONE : zone contenant la VM
VM_NAME : nom de la VM à partir de laquelle exporter les propriétés
THREADS_PER_CORE : nombre de threads par cœur

Afficher le nombre de threads par cœur

Pour afficher le nombre de threads par cœur, suivez la procédure correspondant au système d'exploitation exécuté sur la VM.

Linux

Pour afficher le nombre de threads par cœur sur des VM Linux, procédez comme suit :

Connectez-vous à la VM Linux.
Exécutez la commande lscpu.
```
lscpu
```

Consultez le résultat pour voir le nombre de threads par cœur.

Dans l'exemple de résultat suivant d'une machine n2-standard-16, la valeur du nombre de threads par cœur est 1, comme indiqué dans la ligne Thread(s) per core.

...
CPU(s):                          8
On-line CPU(s) list:             0-7
Thread(s) per core:              1
Core(s) per socket:              8
Socket(s):                       1
NUMA node(s):                    1
Vendor ID:                       GenuineIntel
CPU family:                      6
Model:                           85
Model name:                      Intel(R) Xeon(R) CPU @ 2.80GHz
...

Windows

Pour afficher le nombre de threads par cœur sur des VM Windows, procédez comme suit :

Connectez-vous à la VM Windows.
Lancez PowerShell.

Exécutez la commande suivante :

Get-WmiObject -Class Win32_processor | Select-Object NumberOfCores, @{Name="Thread(s) per core";Expression={$_.NumberOfLogicalProcessors/$_.NumberOfCores}}

Consultez le résultat pour voir le nombre de threads par cœur.

Dans l'exemple de résultat suivant d'une machine n2-standard-16, la valeur du nombre de threads par cœur est 1, comme indiqué dans la colonne Thread(s) per core.
```
NumberOfCores Thread(s) per core
------------- ------------------
            8                  1
```

Étapes suivantes

Découvrez les systèmes d'exploitation que vous pouvez exécuter sur des VM Compute Engine.