Main Content

Cette page a été traduite par traduction automatique. Cliquez ici pour voir la version originale en anglais.

gpuDevice

Interroger ou sélectionner un dispositif GPU

développer tous les éléments de la page

Description

Un objet GPUDevice représente une unité de traitement graphique (GPU) sur votre ordinateur. Vous pouvez utiliser le GPU pour exécuter du code MATLAB® qui prend en charge les variables gpuArray ou exécuter des noyaux CUDA à l'aide d'objets CUDAKernel.

Vous pouvez utiliser un objet GPUDevice pour inspecter les propriétés de votre dispositif GPU, réinitialiser le dispositif GPU ou attendre que votre GPU termine l'exécution d'un calcul. Pour obtenir un objet GPUDevice, utilisez la fonction gpuDevice. Vous pouvez également sélectionner ou désélectionner votre dispositif GPU à l'aide de la fonction gpuDevice. Si vous avez accès à plusieurs GPU, utilisez la fonction gpuDevice pour choisir un dispositif GPU spécifique sur lequel exécuter votre code.

Vous n'avez pas besoin d'utiliser un objet GPUDevice pour exécuter des fonctions sur un GPU. Pour plus d'informations sur l'utilisation des fonctions compatibles GPU, consultez Exécutez les fonctions MATLAB sur un GPU .

Création

Syntaxe

gpuDevice
D = gpuDevice
D = gpuDevice(indx)
gpuDevice([])

Description

gpuDevice affiche les propriétés du dispositif GPU actuellement sélectionné. S'il n'y a aucun dispositif actuellement sélectionné, gpuDevice sélectionne le dispositif par défaut sans l'effacer. Utilisez cette syntaxe lorsque vous souhaitez inspecter les propriétés de votre dispositif GPU.

exemple

D = gpuDevice renvoie un objet GPUDevice représentant le dispositif actuellement sélectionné. S'il n'y a aucun dispositif actuellement sélectionné, gpuDevice sélectionne le dispositif par défaut et renvoie un objet GPUDevice représentant ce dispositif sans l'effacer.

exemple

D = gpuDevice(indx) sélectionne le dispositif GPU spécifié par l'index indx . Si le dispositif GPU spécifié n'est pas pris en charge, une erreur se produit. Cette syntaxe réinitialise le dispositif spécifié et efface sa mémoire, même si le dispositif est déjà actuellement sélectionné (équivalent à la fonction reset). Toutes les variables de l'espace de travail représentant les variables gpuArray ou CUDAKernel sont désormais invalides et doivent être effacées de l'espace de travail ou redéfinies.

exemple

gpuDevice([]), avec un argument vide (par opposition à aucun argument), désélectionne le dispositif GPU et efface sa mémoire des variables gpuArray et CUDAKernel. Cette syntaxe ne laisse aucun dispositif GPU sélectionné comme dispositif actuel.

Arguments d'entrée

développer tout

Index du dispositif GPU, spécifié sous forme d'entier compris entre 1 et gpuDeviceCount .

Exemple : gpuDevice(1);

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Propriétés

développer tout

Ce propriété est en lecture seule.

Nom du dispositif GPU, spécifié sous forme de tableau de caractères. Le nom attribué à l'appareil est dérivé du modèle de dispositif GPU.

Ce propriété est en lecture seule.

Index du dispositif GPU, spécifié sous forme d'entier compris entre 1 et gpuDeviceCount . Utilisez cet index pour sélectionner un dispositif GPU particulier.

Ce propriété est en lecture seule.

Capacité de calcul du dispositif GPU, spécifiée sous forme de tableau de caractères. Pour utiliser le dispositif GPU sélectionné dans MATLAB, ComputeCapability doit répondre à la spécification requise dans Exigences de calcul GPU .

Ce propriété est en lecture seule.

Indicateur de prise en charge des opérations de double précision, spécifié comme valeurs logiques 0 pour false ou 1 pour true .

Depuis R2023a

Ce propriété est en lecture seule.

Version du pilote graphique actuellement utilisée par le dispositif GPU, spécifiée sous forme de tableau de caractères.

Téléchargez le dernier pilote graphique pour votre GPU sur Téléchargements de pilotes NVIDIA.

Depuis R2023a

Ce propriété est en lecture seule.

Modèle de fonctionnement du pilote graphique, spécifié comme l'une de ces valeurs:

  • 'WDDM' – Utilisez le modèle opérationnel d'affichage.

  • 'TCC' – Utilisez le modèle opérationnel de calcul. 'TCC' désactive les graphiques Windows® et peut améliorer les performances des calculs à grande échelle.

  • 'N/A' – 'WDDM' et 'TCC' ne sont disponibles que sur Windows . Sur d'autres systèmes d'exploitation, le modèle de pilote est 'N/A' .

Pour plus d'informations sur le changement de modèle et sur les dispositifs GPU prenant en charge 'TCC', consultez la documentation NVIDIA®.

Ce propriété est en lecture seule.

Version de la boîte à outils CUDA utilisée par la version actuelle de MATLAB, spécifiée sous forme de valeur scalaire.

Ce propriété est en lecture seule.

Nombre maximum de threads pris en charge par bloc pendant l'exécution de CUDAKernel, spécifié sous forme de valeur scalaire.

Exemple : 1024

Ce propriété est en lecture seule.

Quantité maximale prise en charge de mémoire partagée qu'un bloc de thread peut utiliser pendant l'exécution de CUDAKernel, spécifiée sous forme de valeur scalaire.

Exemple : 49152

Ce propriété est en lecture seule.

Taille maximale dans chaque dimension du bloc de thread, spécifiée sous forme de vecteur. Chaque dimension d'un bloc de filetage ne doit pas dépasser ces dimensions. De plus, le produit de la taille du bloc de thread ne doit pas dépasser MaxThreadsPerBlock .

Ce propriété est en lecture seule.

Taille maximale de la grille de blocs de thread, spécifiée sous forme de vecteur.

Ce propriété est en lecture seule.

Nombre de threads s'exécutant simultanément, spécifié sous forme de valeur scalaire.

Ce propriété est en lecture seule.

Mémoire totale (en octets) sur l'appareil, spécifiée sous forme de valeur scalaire.

Ce propriété est en lecture seule.

Mémoire totale (en octets) disponible pour les données, spécifiée sous forme de valeur scalaire. Cette propriété est disponible uniquement pour le dispositif actuellement sélectionné. Cette valeur peut différer de la valeur signalée par l'interface de gestion système NVIDIA en raison de la mise en cache de la mémoire.

Depuis R2023a

Stratégie de mise en cache du dispositif GPU, spécifiée comme 'balanced', 'minimum' ou 'maximum' . La stratégie de mise en cache détermine la quantité de mémoire GPU qui peut être mise en cache pour accélérer le calcul, spécifiée comme l'une des valeurs suivantes.

  • 'minimum' – La quantité de mémoire pouvant être mise en cache sur le dispositif GPU est minime.

  • 'balanced' – La quantité de mémoire pouvant être mise en cache sur le dispositif GPU est équilibrée. Cette politique fournit un équilibre entre l'utilisation de la mémoire GPU et les performances de calcul.

  • 'maximum' – La quantité de mémoire pouvant être mise en cache sur le dispositif GPU est limitée uniquement par la mémoire totale du dispositif.

La valeur par défaut est 'balanced' pour les appareils en mode de calcul 'Default' ou 'Prohibited' et 'maximum' pour les appareils en mode de calcul 'Exclusive process'. Pour plus d'informations sur la propriété du mode de calcul, consultez ComputeMode .

Remarque

  • La réinitialisation de l'appareil à l'aide de reset, la suppression de l'appareil à l'aide de gpuDevice([]) ou la sélection d'un autre appareil à l'aide de gpuDevice réinitialisent la stratégie de mise en cache à la stratégie par défaut.

  • L'enregistrement et le chargement d'un fichier MAT contenant un objet GPUDevice ne préservent pas la politique de mise en cache.

  • Vous ne pouvez pas définir la stratégie de mise en cache d'un appareil qui n'est pas sélectionné. Par exemple, après avoir stocké un premier objet GPUDevice dans un tableau et sélectionné un autre dispositif, vous ne pouvez pas définir la stratégie de mise en cache du premier objet GPUDevice.

Ce propriété est en lecture seule.

Nombre de multiprocesseurs de streaming présents sur l'appareil, spécifié sous forme de valeur scalaire.

Ce propriété est en lecture seule.

Fréquence d'horloge maximale du GPU en kHz, spécifiée sous forme de valeur scalaire.

Ce propriété est en lecture seule.

Mode de calcul de l'appareil, spécifié comme l'une des valeurs suivantes.

'Default'L'appareil n'est pas restreint et plusieurs applications peuvent l'utiliser simultanément. MATLAB peut partager l'appareil avec d'autres applications, y compris d'autres sessions ou workers MATLAB.
'Exclusive process'Une seule application à la fois peut utiliser l'appareil. Lorsque le dispositif est sélectionné dans MATLAB, d'autres applications ne peuvent pas l'utiliser, y compris d'autres sessions ou workers MATLAB.
'Prohibited'L'appareil ne peut pas être utilisé.

Pour plus d'informations sur la modification du mode de calcul de votre dispositif GPU, consultez la documentation NVIDIA.

Ce propriété est en lecture seule.

Indicateur de prise en charge des transferts superposés, spécifié comme valeurs logiques 0 ou 1 .

Ce propriété est en lecture seule.

Indicateur de délai d'attente pour les noyaux à exécution longue, spécifié sous la forme de valeurs logiques 0 ou 1 . Si 1, le système d'exploitation impose une limite supérieure au temps d'exécution accordé au noyau CUDA. Passé ce délai, le pilote CUDA expire le noyau et renvoie une erreur.

Ce propriété est en lecture seule.

Indicateur de prise en charge du mappage de la mémoire hôte dans l'espace d'adressage CUDA, spécifié sous la forme des valeurs logiques 0 ou 1 .

Ce propriété est en lecture seule.

Indicateur pour le dispositif pris en charge, spécifié par les valeurs logiques 0 ou 1 . Tous les appareils ne sont pas pris en charge; par exemple, les appareils avec un ComputeCapability insuffisant.

Ce propriété est en lecture seule.

Indicateur pour le dispositif disponible, spécifié par les valeurs logiques 0 ou 1 . Cette propriété indique si le dispositif est disponible pour une utilisation dans la session MATLAB en cours. Les appareils non pris en charge avec une propriété DeviceSupported de 0 sont toujours indisponibles. Un appareil peut également être indisponible si sa propriété ComputeMode est définie sur 'Exclusive thread', 'Exclusive process' ou 'Prohibited' .

Ce propriété est en lecture seule.

Indicateur pour le dispositif actuellement sélectionné, spécifié par les valeurs logiques 0 ou 1 .

Depuis R2024a

Ce propriété est en lecture seule.

Identificateur universellement unique, spécifié sous forme de tableau de caractères.

Chaque UUID commence généralement par 'GPU-' suivi d'une séquence hexadécimale de 36 caractères. Vous pouvez utiliser l'UUID pour distinguer des GPU par ailleurs identiques.

Le logiciel n'affiche pas cette propriété lorsque vous appelez gpuDevice . Interrogez cette propriété en utilisant la notation par points ou en utilisant gpuDeviceTable .

Types de données : char

Fonctions d'objet

resetRéinitialiser le dispositif GPU et effacer sa mémoire
wait (GPUDevice)Wait for GPU calculation to complete

Les fonctions suivantes sont également disponibles :

parallel.gpu.GPUDevice.isAvailable(indx)Renvoie 1 ou true logique si le GPU spécifié par l'index indx est pris en charge et peut être sélectionné. indx peut être un entier ou un vecteur d'entiers ; l'index par défaut est le dispositif actuel.
parallel.gpu.GPUDevice.getDevice(indx)Renvoie un objet GPUDevice sans le sélectionner.

Pour une liste complète des fonctions, utilisez la fonction methods sur l'objet GPUDevice:

methods('parallel.gpu.GPUDevice')

Vous pouvez obtenir de l'aide sur n'importe quelle fonction de l'objet avec la commande suivante:

help parallel.gpu.GPUDevice.functionname

où functionname est le nom de la fonction. Par exemple, pour obtenir de l'aide sur isAvailable, tapez:

help parallel.gpu.GPUDevice.isAvailable

Exemples

réduire tout

Ouvrir le live script

Cet exemple montre comment utiliser gpuDevice pour identifier et sélectionner l'appareil que vous souhaitez utiliser.

Pour déterminer combien de dispositifs GPU sont disponibles sur votre ordinateur, utilisez la fonction gpuDeviceCount.

gpuDeviceCount("available")
ans = 2

Lorsqu'il y a plusieurs appareils, le premier est celui par défaut. Vous pouvez examiner ses propriétés avec la fonction gpuDeviceTable pour déterminer si c'est celle que vous souhaitez utiliser.

gpuDeviceTable
ans=2×5 table
    Index           Name           ComputeCapability    DeviceAvailable    DeviceSelected
    _____    __________________    _________________    _______________    ______________

      1      "NVIDIA RTX A5000"          "8.6"               true              false     
      2      "Quadro P620"               "6.1"               true              true

Si le premier appareil est celui que vous souhaitez utiliser, vous pouvez continuer. Pour exécuter des calculs sur le GPU, utilisez les fonctions activées gpuArray. Pour plus d’informations, consultez Exécutez les fonctions MATLAB sur un GPU.

Pour utiliser un autre appareil, appelez gpuDevice avec l'index de l'autre appareil.

gpuDevice(2)
ans = 
  CUDADevice with properties:

                      Name: 'Quadro P620'
                     Index: 2
         ComputeCapability: '6.1'
            SupportsDouble: 1
     GraphicsDriverVersion: '511.79'
               DriverModel: 'WDDM'
            ToolkitVersion: 11.2000
        MaxThreadsPerBlock: 1024
          MaxShmemPerBlock: 49152 (49.15 KB)
        MaxThreadBlockSize: [1024 1024 64]
               MaxGridSize: [2.1475e+09 65535 65535]
                 SIMDWidth: 32
               TotalMemory: 2147287040 (2.15 GB)
           AvailableMemory: 1615209678 (1.62 GB)
               CachePolicy: 'balanced'
       MultiprocessorCount: 4
              ClockRateKHz: 0
               ComputeMode: 'Default'
      GPUOverlapsTransfers: 1
    KernelExecutionTimeout: 1
          CanMapHostMemory: 1
           DeviceSupported: 1
           DeviceAvailable: 1
            DeviceSelected: 1

Vous pouvez également déterminer le nombre de dispositifs GPU disponibles, inspecter certaines de leurs propriétés et sélectionner un dispositif à utiliser à partir du bureau MATLAB ®. Dans l'onglet Accueil, dans la zone Environnement, sélectionnez Parallèle > Sélectionnez l'environnement GPU.

gpuDevice2.png

Ouvrir le live script

Créez un objet représentant le dispositif GPU par défaut et interrogez sa capacité de calcul.

D = gpuDevice;
D.ComputeCapability
ans = 
'8.6'

Interrogez les capacités de calcul de tous les dispositifs GPU disponibles.

for idx = 1:gpuDeviceCount
    D = gpuDevice(idx);
    fprintf(1,"Device %i has ComputeCapability %s \n", ...
        D.Index,D.ComputeCapability)
end
Device 1 has ComputeCapability 8.6 
Device 2 has ComputeCapability 6.1

Comparez les capacités de calcul et la disponibilité des dispositifs GPU de votre système à l'aide de gpuDeviceTable.

gpuDeviceTable
ans=2×5 table
    Index           Name           ComputeCapability    DeviceAvailable    DeviceSelected
    _____    __________________    _________________    _______________    ______________

      1      "NVIDIA RTX A5000"          "8.6"               true              false     
      2      "Quadro P620"               "6.1"               true              true
Ouvrir le live script

Modifiez la politique de mise en cache de votre GPU.

Créez un objet représentant le dispositif GPU par défaut.

D = gpuDevice
D = 
  CUDADevice with properties:

                      Name: 'NVIDIA RTX A5000'
                     Index: 1
         ComputeCapability: '8.6'
            SupportsDouble: 1
     GraphicsDriverVersion: '511.79'
               DriverModel: 'TCC'
            ToolkitVersion: 11.2000
        MaxThreadsPerBlock: 1024
          MaxShmemPerBlock: 49152 (49.15 KB)
        MaxThreadBlockSize: [1024 1024 64]
               MaxGridSize: [2.1475e+09 65535 65535]
                 SIMDWidth: 32
               TotalMemory: 25553076224 (25.55 GB)
           AvailableMemory: 25145376768 (25.15 GB)
               CachePolicy: 'balanced'
       MultiprocessorCount: 64
              ClockRateKHz: 0
               ComputeMode: 'Default'
      GPUOverlapsTransfers: 1
    KernelExecutionTimeout: 0
          CanMapHostMemory: 1
           DeviceSupported: 1
           DeviceAvailable: 1
            DeviceSelected: 1

Accédez à la propriété CachePolicy du dispositif GPU.

D.CachePolicy
ans = 
'balanced'

Modifiez la stratégie de mise en cache pour permettre au GPU de mettre en cache la quantité maximale de mémoire pour accélérer le calcul.

D.CachePolicy = "maximum";
D.CachePolicy
ans = 
'maximum'

Réinitialisez la stratégie de mise en cache sur la stratégie par défaut en définissant la propriété sur [].

D.CachePolicy = [];

L'appel de reset(D) ou la sélection d'un autre appareil avec gpuDevice réinitialise également la stratégie de mise en cache à sa valeur par défaut.

Ouvrir le live script

Si vous avez accès à plusieurs GPU, vous pouvez effectuer vos calculs sur plusieurs GPU en parallèle à l'aide d'un pool parallèle.

Pour déterminer le nombre de GPU disponibles pour une utilisation dans MATLAB, utilisez la fonction gpuDeviceCount. 

availableGPUs = gpuDeviceCount("available")
availableGPUs = 3

Démarrez un pool parallèle avec autant de nœuds de calcul que de GPU disponibles. Pour de meilleures performances, MATLAB attribue par défaut un GPU différent à chaque worker.

parpool("Processes",availableGPUs);
Starting parallel pool (parpool) using the 'Processes' profile ...
Connected to the parallel pool (number of workers: 3).

Pour identifier le GPU utilisé par chaque worker, appelez gpuDevice dans un bloc spmd. Le bloc spmd exécute gpuDevice sur chaque worker.

spmd
    gpuDevice
end

Utilisez des fonctionnalités de langage parallèle, telles que parfor ou parfeval, pour distribuer vos calculs aux nœuds de calcul du pool parallèle. Si vous utilisez des fonctions activées gpuArray dans vos calculs, ces fonctions s'exécutent sur le GPU du worker. Pour plus d’informations, consultez Exécutez les fonctions MATLAB sur un GPU. Pour un exemple, voir Run MATLAB Functions on Multiple GPUs.

Lorsque vous avez terminé vos calculs, arrêtez le pool parallèle. Vous pouvez utiliser la fonction gcp pour obtenir le pool parallèle actuel.

delete(gcp("nocreate"));

Si vous souhaitez utiliser un choix différent de GPU, vous pouvez utiliser gpuDevice pour sélectionner un GPU particulier sur chaque worker, à l'aide de l'index de dispositif GPU. Vous pouvez obtenir l'index de chaque dispositif GPU de votre système à l'aide de la fonction gpuDeviceCount.

Supposons que vous disposiez de trois GPU disponibles sur votre système, mais que vous souhaitiez n’en utiliser que deux pour un calcul. Obtenez les indices des appareils.

[availableGPUs,gpuIndx] = gpuDeviceCount("available")
availableGPUs = 3

gpuIndx = 1×3

     1     2     3

Définissez les indices des appareils que vous souhaitez utiliser.

useGPUs = [1 3];

Démarrez votre pool parallèle. Utilisez un bloc spmd et gpuDevice pour associer chaque worker à l'un des GPU que vous souhaitez utiliser, à l'aide de l'index de dispositif. La fonction spmdIndex identifie l'index de chaque worker. 

parpool("Processes",numel(useGPUs));
Starting parallel pool (parpool) using the 'Processes' profile ...
Connected to the parallel pool (number of workers: 2).

spmd
    gpuDevice(useGPUs(spmdIndex));
end

À titre de bonne pratique et pour de meilleures performances, attribuez un GPU différent à chaque worker.

Lorsque vous avez terminé vos calculs, arrêtez le pool parallèle.

delete(gcp("nocreate"));

Capacités étendues

Historique des versions

Introduit dans R2010b

développer tout

Voir aussi

| | | | | |

Rubriques

Sites web externes