OpenCL dans le Trading - page 5

[MetaQuotes]

6. Superscalaire et VLIW

6. Superscalaire et VLIW

La vidéo explore comment les processeurs utilisent l'exécution superscalaire pour détecter et extraire le parallélisme entre les instructions binaires afin d'améliorer les performances. Il traite de l'importance de la logique de contrôle dans l'identification des instances où les instructions peuvent s'exécuter simultanément, par exemple en l'absence de dépendances entre elles. La vidéo présente également deux exemples de conception de processeur, superscalaire et VLIW, ce dernier transférant la responsabilité de la détection des dépendances aux compilateurs, générant de longs mots d'instruction à exécuter en parallèle. Bien que VLIW réduise la vérification du temps d'exécution, les points inutilisés dans le mot d'instruction long peuvent toujours entraîner un gaspillage dans l'unité d'exécution.

• 00:00:00 Dans cette section, la vidéo explique comment les processeurs utilisent l'exécution superscalaire pour améliorer les performances globales des programmes avec des instructions binaires. Les programmeurs s'appuient sur des processeurs bien conçus pour exécuter correctement leurs programmes, et il incombe donc au processeur d'identifier et d'extraire le parallélisme des instructions pour augmenter les performances. La vidéo fournit un exemple de graphe de dépendance entre les instructions, et bien qu'il existe des dépendances entre certaines instructions, les processeurs peuvent en exécuter d'autres simultanément en raison d'un manque de dépendances entre elles. C'est le travail de la logique de contrôle au sein du processeur d'identifier ces instances et d'exécuter les instructions de la manière la plus efficace possible pour optimiser les performances.
  
  
• 00:05:00 Dans cette section, la vidéo traite de deux exemples de conceptions architecturales dans les processeurs - superscalaire et VLIW. Le premier exemple montre comment le processeur peut détecter les dépendances entre les instructions et les planifier en conséquence pour gagner du temps. La vidéo met également en évidence la possibilité d'exécution spéculative pour les instructions de branche. Le deuxième exemple traite de la conception VLIW, qui transfère la responsabilité de la détection des dépendances aux compilateurs. Le compilateur génère de longs mots d'instructions comprenant plusieurs instructions pouvant être exécutées en parallèle, ce qui simplifie la conception du processeur.
  
  
• 00:10:00 Dans cette section, le concept d'un mot d'instruction très long (VLIW) est expliqué. Cela permet de regrouper plusieurs instructions dans un long mot d'instruction, qui est extrait et décodé ensemble. Le VLIW transfère la responsabilité aux compilateurs de découvrir les opportunités d'exécution d'instructions en même temps avant l'exécution du programme, et réduit le besoin de vérification d'exécution. Cependant, s'il y a des espaces vides dans le long mot d'instruction, l'unité d'exécution peut encore subir un certain gaspillage.

[MetaQuotes]

7. SIMD et multithreading matériel

7. SIMD et multithreading matériel

La vidéo explique deux manières de relever les défis du parallélisme : instruction unique, données multiples (SIMD) et multithreading matériel (SMT). SIMD permet aux instructions matérielles de s'exécuter en parallèle sur plusieurs éléments de données, simplifiant la logique de planification et de décodage. SMT exploite le parallélisme au niveau des threads en exécutant simultanément des flux d'instructions indépendants, exigeant des fichiers de registre supplémentaires et un partage de cache minutieux. La vidéo traite également de la mise en œuvre de la planification des threads par tranches temporelles, où les threads occupent à tour de rôle le chemin de données du processeur de manière circulaire, réduisant la latence et permettant à plusieurs threads d'accéder simultanément aux unités de calcul et aux systèmes de mémoire. En fin de compte, le processeur peut accueillir autant de threads que nécessaire, bien que le gain de performances puisse ne pas être aussi important sur un processeur à un seul thread.

• 00:00:00 Dans cette section, le concept SIMD (Single Instruction Multiple Data) est expliqué, où les instructions matérielles peuvent être utilisées pour l'exécution parallèle d'opérations sur plusieurs éléments de données. SIMD simplifie la logique de planification et de décodage, car une seule instruction doit être planifiée pour appliquer la même opération à chaque élément des données. L'utilisation de SIMD est bénéfique si le problème à résoudre implique un parallélisme important des données, sinon, ce n'est peut-être pas une solution efficace. De plus, la similitude du SIMD et du calcul vectoriel est expliquée, où les instructions vectorielles peuvent être utilisées sur des données dispersées dans différentes parties de la mémoire pour effectuer des opérations virtuelles.
  
  
• 00:05:00 Dans cette section, la vidéo explique comment le multi-threading matériel ou le multi-threading simultané (SMT) peut être utilisé pour exploiter le parallélisme au niveau des threads. En plaçant plusieurs programmes ou threads sur le même processeur, différents flux d'instructions peuvent s'exécuter simultanément s'ils sont indépendants les uns des autres. Le multi-threading matériel peut être utile pour les grandes machines et les processeurs uniques, car il permet d'extraire facilement des instructions à partir de deux threads indépendants. Cependant, cela nécessite des fichiers de registre supplémentaires et une attention particulière à la manière dont les caches sont partagés entre les différents threads.
  
  
• 00: 10: 00 Dans cette section de la vidéo, le présentateur explique comment occuper l'unité arithmétique et logique (ALU) en mettant en œuvre la planification des threads par tranches de temps. Cette méthode permet aux threads d'occuper à tour de rôle le chemin de données du processeur de manière circulaire, ce qui réduit considérablement la latence en planifiant davantage de threads. En exécutant l'instruction suivante en attendant un thread bloqué, cette méthode permet aux unités de calcul et aux systèmes de mémoire d'être utilisés par plusieurs threads simultanément. En fin de compte, le résultat est qu'il n'y a pas de perte de temps et que le processeur peut accueillir autant de threads que nécessaire. Cependant, les performances d'un thread unique sur un processeur monothread peuvent ne pas être améliorées autant que sur un processeur multithread.

[MetaQuotes]

8. Architecture de processeur multicœur

8. Architecture de processeur multicœur

Cette vidéo explique l'architecture des processeurs multicœurs et leurs avantages, tels que plusieurs cœurs fonctionnant indépendamment et partageant certains composants, tandis que chaque cœur possède son propre pipeline et cache de données. L'importance de la hiérarchie des caches pour combler l'écart de vitesse entre le microprocesseur et l'accès à la mémoire est mise en évidence à l'aide de plusieurs niveaux de caches qui exploitent la localité temporelle et spatiale. La vidéo aborde également la conception du système sur puce, qui combine différentes unités de fonction et interfaces en une seule puce pour réduire le coût et le facteur de forme. Dans l'ensemble, la vidéo fournit une introduction utile à la complexité et aux compromis impliqués dans la conception de processeurs multicœurs.

• 00:00:00 Dans cette section, nous découvrons les processeurs multicœurs et leurs avantages par rapport aux processeurs monocœur. Les processeurs multicœurs ont plusieurs cœurs, qui fonctionnent indépendamment et partagent certains composants tels que la récupération d'instructions, le décodage et les ordonnanceurs à virgule flottante. Cependant, chaque cœur possède son propre pipeline et son propre cache de données de niveau 1. Les processeurs multicœurs nécessitent des protocoles de cohérence de cache pour garantir que les données stockées dans chaque cache sont cohérentes avec les données de la mémoire principale. Le système sur puce est une autre option de conception où plusieurs éléments sont combinés en un seul appareil sur la même puce pour réduire le coût et le facteur de forme. Il a beaucoup d'unités de fonction dédiées et d'interfaces différentes connectées au reste de la puce via une interconnexion unship.
  
  
• 00:05:00 Dans cette section, l'orateur explique le concept de hiérarchie de cache dans une architecture de processeur multicœur. La raison principale de l'utilisation du cache est de combler l'écart de vitesse entre le microprocesseur et l'accès à la mémoire, qui fonctionnent à des fréquences différentes et ont des capacités de stockage différentes. Les caches de niveau 1, niveau 2 et niveau 3 sont utilisés pour combler l'écart, et ils exploitent la localité temporelle et spatiale d'accéder à un petit nombre d'instructions ou de données sur une courte période ou d'accéder à des emplacements proches, respectivement. Les caches sont organisés à l'aide de blocs, qui sont déplacés entre les niveaux de mémoire, permettant au processeur de tirer parti de la localité temporelle et spatiale.

[MetaQuotes]

9. Architecture GPU

9. Architecture GPU

L'unité de traitement accéléré (APU) est un processeur hétérogène avec des cœurs à faible consommation d'énergie et des unités GPU, tous sur la même puce. Les GPU ont un grand nombre de cœurs de shader qui peuvent être programmés avec des instructions, et leurs caches sont généralement non cohérents, ce qui simplifie leur conception et permet des performances bien supérieures lorsque de nombreux cœurs fonctionnent en même temps. AMD et Nvidia utilisent de petites unités de calcul pour prendre en charge l'opération sur plusieurs éléments de données en même temps et disposent de fichiers de registre volumineux pour prendre en charge le changement de contexte rapide. L'orateur explique également comment gérer le flux de contrôle dans l'architecture GPU, en particulier pour traiter les instructions de branchement qui peuvent produire des résultats invalides, mais les programmeurs n'ont pas à se soucier de ces problèmes car les fournisseurs de processeurs ont déjà fourni une logique de contrôle dans le matériel. Dans l'ensemble, les GPU sont des processeurs populaires pour les charges de travail complexes sur le marché moderne, en particulier dans le domaine de l'IA et de l'apprentissage automatique.

• 00: 00: 00 Dans cette section, nous en apprenons davantage sur l'unité de traitement accéléré (APU), qui est un processeur hétérogène typique composé de cœurs à faible consommation d'énergie utilisés pour le calcul, la gestion et la configuration à usage général du système, et des unités GPU, le tout sur la même puce. L'APU a un cœur x86 typique avec deux niveaux de cache, alors que les cœurs GPU sont différents et non x86, avec un stockage de données local inférieur considéré comme une mémoire privée. La propriété de la mémoire est visible dans un diagramme, montrant les emplacements, l'accessibilité et la taille de la mémoire, avec une mémoire privée plus petite que la mémoire locale et beaucoup plus petite que la mémoire globale. Les processeurs pour ordinateurs portables actuels d'Intel ou d'AMD ont généralement un petit nombre de cœurs à usage général, une mémoire intégrée et une unité de traitement graphique sur puce.
  
  
• 00:05:00 Dans cette section, nous découvrons l'architecture GPU et son utilisation dans le domaine de l'IA et de l'apprentissage automatique. Les GPU ont un grand nombre de processeurs, appelés cœurs de shader, qui peuvent être programmés avec des instructions. Ils peuvent accéder à une mémoire GPU à grande vitesse qui est différente du sous-système de mémoire d'un processeur à usage général, et leurs caches sont généralement non cohérents. Les GPU n'utilisent pas le protocole de cohérence du cache pour assurer la cohérence, ce qui simplifie la conception et permet des performances bien supérieures lorsque de nombreux cœurs fonctionnent en même temps. Dans l'ensemble, les GPU sont un processeur populaire pour les charges de travail complexes sur le marché moderne.
  
  
• 00: 10: 00 Dans cette section, nous apprenons comment AMD et Nvidia utilisent de petites unités de calcul dotées de matériel cmd pour prendre en charge l'opération sur plusieurs éléments de données en même temps. Les deux fournisseurs ont 16 cmds larges, et ils peuvent regrouper les éléments de travail en groupes plus grands et les mapper sur différents lots en fonction de la puce et des paramètres de configuration. De plus, ils disposent de fichiers de registre volumineux pour prendre en charge le changement de contexte rapide, et les deux fournisseurs ont une combinaison de cache automatique de niveau un et de bloc-notes géré par l'utilisateur, qui est fortement soutenu par une bande passante élevée pour prendre en charge des opérations rapides sur leurs mémoires privées respectives. Enfin, nous abordons brièvement le flux de contrôle et le concept d'exécution de plusieurs données avec une seule instruction, et comment les instructions de branchement provoquent une certaine déviation dans l'exécution des chemins, nécessitant un moyen de minimiser la quantité de calculs effectués sur des données invalides.
  
  
• 00: 15: 00 Dans cette section, l'orateur explique comment gérer le flux de contrôle dans l'architecture GPU, en particulier en traitant les instructions de branche qui peuvent produire des résultats invalides. Pour gérer ce problème, les voies cmd peuvent être masquées pour ignorer certains calculs, bien que cela puisse nuire aux performances. Un autre problème que nous devons résoudre lors de l'utilisation de la technologie SIMT (single instruction multiple threads) est la divergence entre les threads logiciels, qui peut gaspiller des cycles de calcul si elle n'est pas bien gérée. Heureusement, les programmeurs OpenCL n'ont pas à se soucier de ces problèmes car les fournisseurs de processeurs ont déjà fourni une logique de contrôle dans le matériel.

[MetaQuotes]

10. Composants internes du FPGA

10. Composants internes du FPGA

Cette vidéo traite de l'architecture et des fonctionnalités des matrices de portes programmables sur le terrain (FPGA). Les FPGA ont une logique programmable, leur permettant d'être reprogrammés pour accueillir de nouvelles fonctionnalités, et ont un accès direct aux données via des quantités massives d'entrées et de sorties (E/S). La structure de la table de consultation dans les FPGA se compose de plusieurs niveaux de multiplexeurs qui peuvent être programmés pour définir des fonctions logiques. Les FPGA utilisent des registres programmables qui peuvent être utilisés pour les compteurs, les registres à décalage, les machines d'état et les fonctions DSP. Chaque bloc rectangulaire sur la puce représente un bloc de réseau logique (LAB), chaque LAB contenant dix modules de logique adaptative (ALM). Les FPGA sont utilisés dans des secteurs tels que les appareils grand public, l'automobile, l'instrumentation médicale, la communication et la diffusion.

• 00:00:00 Dans cette section, les bases des FPGA sont présentées, y compris leur logique programmable qui peut être reprogrammée pour accueillir de nouvelles fonctionnalités, et leur accès direct aux données via des quantités massives d'E/S. Les avantages des FPGA sont leur connexion pratique aux composants de mémoire et aux coprocesseurs, leurs fonctionnalités remplaçables sans qu'il soit nécessaire de remplacer le matériel, et leur omniprésence dans des secteurs tels que les appareils grand public, l'automobile, l'instrumentation médicale, la communication et la diffusion. L'architecture des FPGA comprend la table de consultation, qui peut être programmée pour définir des fonctions logiques, et d'autres parties importantes telles que les registres de report et les modules logiques adaptatifs qui seront abordés dans les sections suivantes.
  
  
• 00:05:00 Dans cette section de la vidéo, le présentateur explique la structure d'une table de recherche dans les FPGA, qui se compose de plusieurs niveaux de multiplexeurs avec des entrées sélectionnables. Les entrées de la table de consultation peuvent être utilisées pour construire une fonction logique combinatoire arbitraire. La vidéo aborde ensuite les registres programmables, qui sont des éléments de stockage dans les FPGA utilisés pour les compteurs, les registres à décalage, les machines d'état et les fonctions DSP. Ces registres ont un signal d'horloge généralement piloté par une horloge globale et peuvent être réinjectés dans la table de consultation. De plus, la vidéo explique comment les éléments logiques et les modules logiques adaptatifs sont connectés via des signaux de chaîne
  et les bits de retenue, et comment l'entrée des registres peut provenir d'éléments logiques précédents.
  
  
• 00:10:00 Dans cette section, nous apprenons à organiser les éléments logiques à l'intérieur d'une puce FPGA. Chaque bloc rectangulaire sur la puce représente un bloc de réseau logique (LAB), chaque LAB contenant dix modules de logique adaptative (ALM). Chaque ALM se compose d'unités arithmétiques, d'interconnexions locales et de connexions d'enregistrement, ainsi que de ressources dédiées et d'une table de recherche adaptative pour une organisation flexible des entrées et une génération de sortie spécifique. De plus, nous avons des interconnexions de lignes et de colonnes qui peuvent connecter des LAB spécifiques, et le routage évolue de manière linéaire en fonction de la densité de l'appareil. Enfin, nous avons des blocs de mémoire intégrés qui prennent en charge différents types de structures de mémoire, telles que la RAM à un ou deux ports, la mémoire en lecture seule ou de petites tranches de structures de mémoire appelées eMLAB.
  
  
• 00:15:00 Dans cette section, nous découvrons les différentes fonctionnalités des FPGA, y compris les blocs de traitement numérique du signal (DSP) et les composants d'entrée/sortie (IO). Les blocs DSP sont utiles pour mettre en œuvre des fonctions de traitement du signal telles que les transformations FFT et les opérations de multiplication et d'accumulation hautes performances. Les FPGA peuvent également communiquer avec divers composants IO, permettant l'activation, le contrôle et la terminaison des sorties. La logique de l'élément IO comprend des broches bidirectionnelles et une commande de signal d'activation de sortie, et le chemin de sortie génère des valeurs A et B via le signal d'horloge. D'autre part, si le contrôle de sortie est désactivé, les signaux d'entrée passent par le registre d'entrée.
  
  
• 00: 20: 00 Dans cette section sur les composants internes du FPGA, l'importance des signaux d'horloge est mise en évidence ainsi que l'utilisation de broches d'horloge d'entrée dédiées pour prendre en charge les opérations FPGA. Les émetteurs-récepteurs à grande vitesse sont également abordés, qui sont utiles pour mettre en œuvre des protocoles de signal plus complexes dans les FPGA, sans avoir besoin d'un conditionnement et d'un traitement complexes du signal. L'utilisation de PLL pour générer différents signaux d'horloge à utiliser dans tout l'appareil avec un décalage minimal est également expliquée, ainsi que l'utilisation de la technologie des cellules SRAM et des tables de consultation pour configurer les bits programmables qui contrôlent la connectivité des signaux d'entrée et de sortie. La vidéo couvre également les méthodes utilisées pour programmer les FPGA à l'aide d'une W prom externe, d'un Cpl D ou d'un processeur pour contrôler les séquences de programmation, et l'utilisation d'une connexion matérielle JTAG spéciale pour un diagnostic et un débogage plus approfondis.
  
  
• 00: 25: 00 Dans cette section, la conception et les fonctionnalités d'un réseau prédiffusé programmable par l'utilisateur (FPGA) sont abordées. La majorité de la zone d'un FPGA est constituée de blocs de réseau logique qui peuvent être connectés via des interconnexions de lignes et de colonnes. D'autres blocs incluent PR, des émetteurs-récepteurs et un contrôleur de mémoire qui peuvent être connectés à différents composants de mémoire. Une zone PJ 10g X FPGA est utilisée comme exemple avec 1 million d'éléments logiques, 1,7 million de registres, 54 000 blocs de mémoire avec 22 bits chacun, 1 518 blocs DSP, 367,4 gigabits par seconde émetteurs-récepteurs, deux blocs PCIe durs, 492 broches IO générales et 12 contrôleurs de mémoire. L'avantage des FPGA est la haute densité pour créer des fonctions complexes, l'intégration de plusieurs fonctions, l'accès à différentes normes et fonctionnalités d'E/S et l'accès direct aux données dans une seule puce.

[MetaQuotes]

11. Mémoire OpenCL sur un système GPU

11. Mémoire OpenCL sur un système GPU

L'instructeur explique le mappage de la mémoire OpenCL au GPU AMD et les différents niveaux de mémoire dans un système GPU. Le dispositif de calcul a un processeur de commande qui gère les directives vers les unités de calcul, qui fonctionnent comme des cœurs avec plusieurs voies SIMD, des fichiers de registre privés et une mémoire privée. Le programme du noyau est destiné à fournir des travaux autonomes qui permettent d'utiliser tous les cœurs disponibles et de réduire la latence d'accès à la mémoire. L'orateur mentionne également le concept d'intensité arithmétique, qui fait référence au rapport entre le calcul et le mouvement de l'axe mémoire, et comment il doit être élevé pour éviter que la bande passante mémoire du GPU ne soit le facteur limitant.

• 00:00:00 Dans cette section, l'orateur discute d'OpenCL en relation avec l'architecture matérielle de différents processeurs, en se concentrant spécifiquement sur le GPU AMD. Le diagramme montre la mémoire globale, la mémoire constante et la mémoire locale, le noyau à gauche représentant le noyau OpenCL utilisé lors de la conception d'un programme parallèle de données. Chaque groupe de travail effectue un sous-ensemble du calcul basé sur les données, la mémoire locale étant locale au groupe de travail et partagée avec les unités d'exécution au sein du processeur. Les éléments de travail au sein du groupe de travail sont le calcul réel effectué, chacun ayant son propre ensemble de données.
  
  
• 00:05:00 Dans cette section, l'instructeur explique comment la mémoire OpenCL est mappée sur le GPU AMD et les différents niveaux de mémoire sur un système GPU. Le dispositif de calcul a un processeur de commande qui programme des instructions aux unités de calcul, qui ont un cache de niveau 1 et partagent un cache de niveau 2, et sont connectés à la mémoire globale. L'unité informatique fonctionne comme un noyau, avec plusieurs voies SIMD et des fichiers de registre privés, appelés GPR, qui constituent la mémoire privée. Le programme du noyau est censé fournir des éléments de travail indépendants, qui doivent être aussi nombreux que possible pour occuper tous les cœurs disponibles, et ces éléments doivent permettre le changement de contexte matériel afin de minimiser la latence d'accès à la mémoire. Le noyau doit également avoir une intensité arithmétique élevée pour utiliser efficacement le matériel.
  
  
• 00: 10: 00 Dans cette section, l'orateur discute du concept d'intensité romantique qui est essentiellement le rapport entre le calcul et le mouvement de l'axe de la mémoire. L'objectif est d'avoir des opérations mathématiques sur les accès mémoire aussi élevés que possible pour éviter d'être limités par la bande passante mémoire.

[MetaQuotes]

12. Exemple OpenCL : Multiplication matricielle

12. Exemple OpenCL : Multiplication matricielle

Cette vidéo présente la multiplication matricielle comme exemple de programmation OpenCL. L'orateur montre comment le code C est écrit pour créer des boucles indépendantes qui peuvent traverser les lignes et les colonnes de la matrice. Les éléments de travail sont discutés et comment ils peuvent être mappés aux éléments de matrice dans OpenCL. Une implémentation du noyau est expliquée, couvrant les arguments de la fonction du noyau, comment elle est appelée et son corps. L'orateur montre comment la matrice d'entrée est stockée dans un tableau à une dimension en utilisant des numéros de ligne et d'index pour calculer les indices. En fin de compte, la fonction noyau calcule le produit scalaire pour produire l'élément dans la matrice de sortie. L'approche linéaire du stockage des matrices dans la mémoire physique est soulignée.

• 00:00:00 Dans cette section, nous découvrons la multiplication matricielle comme exemple de programmation OpenCL. La multiplication matricielle est un exemple classique de calcul de puissance qui a été utilisé dans de nombreuses applications différentes. L'implémentation nécessite des boucles imbriquées, avec l'exigence que le nombre de colonnes de la matrice A soit égal au nombre de lignes de la matrice B. C'est parce que chaque élément résultant dans la matrice C est le produit scalaire d'un vecteur ligne de A avec un vecteur colonne de B. Nous voyons comment le code C est écrit pour implémenter l'opération et comment les boucles fonctionnent indépendamment, nous permettant de parcourir chaque ligne ou colonne de la matrice résultante C de manière aléatoire.
  
  
• 00: 05: 00 Dans cette section, le concept d'éléments de travail est présenté et il est expliqué comment les éléments de travail peuvent être mappés sur des éléments de matrice dans OpenCL. Des éléments de travail peuvent être créés pour chaque élément de sortie d'une matrice à calculer indépendamment et, par conséquent, ils peuvent être mappés à des éléments de travail de plage bidimensionnelle. L'implémentation du noyau pour la multiplication matricielle dans OpenCL est également abordée, où les arguments de la fonction noyau et comment l'appeler à partir de la fonction principale sont expliqués, et le corps de la fonction noyau est présenté. La fonction noyau calcule le produit scalaire d'un vecteur ligne et d'un vecteur colonne pour calculer chaque élément de la matrice de sortie.
  
  
• 00:10:00 Dans cette section, l'intervenant explique le processus de multiplication de matrices à l'aide du langage de programmation OpenCL. L'idée principale est de stocker la matrice d'entrée bidimensionnelle dans un tableau à une seule dimension en utilisant le numéro de ligne et le numéro d'index pour calculer le bon index afin de trouver le bon élément pour effectuer l'opération de produit scalaire. La fonction noyau initialise la variable somme avec 0 et parcourt le vecteur ligne de A et le vecteur colonne de B pour calculer le produit scalaire, affectant finalement le résultat dans l'élément correspondant en C. Ces étapes illustrent comment utiliser les numéros de ligne et de colonne pour calculer les indices de manière linéaire, ce qui est essentiel pour stocker la matrice en mémoire physique.

[MetaQuotes]

13. Structure d'un programme OpenCL (partie 1)

13. Structure d'un programme OpenCL (partie 1)

Dans la vidéo "Structure d'un programme OpenCL (part1)", le processus de construction d'une application OpenCL est expliqué. Le programme doit d'abord interroger la plate-forme OpenCL pour comprendre ses ressources et créer un contexte OpenCL et une file d'attente de commandes. Des tampons sont ensuite créés pour l'échange de données entre l'hôte et la mémoire de l'appareil, et le programme du noyau est compilé dans un binaire pour exécution sur l'appareil. La vidéo explique ensuite comment créer des tampons en lecture seule et en écriture seule, allouer de l'espace pour les matrices de sortie et copier les résultats sur l'hôte. L'importance de vérifier les appels d'API pour une exécution réussie est soulignée.

• 00:00:00 Dans cette section, l'orateur explique les étapes pour construire une application OpenCL. Tout d'abord, le programme doit interroger la plate-forme OpenCL pour comprendre les ressources disponibles sur la plate-forme, puis créer un contexte OpenCL et une file d'attente de commandes, ce qui est essentiel pour les opérations de tampon et les lancements de noyau. Des tampons sont ensuite créés pour échanger des données entre l'hôte et la mémoire de l'appareil. Ensuite, le programme du noyau doit être compilé dans un binaire qui peut être exécuté sur le périphérique accélérateur soit sur un FPGA, soit sur un GPU. Le processus de compilation diffère selon l'appareil.
  
  
• 00:05:00 Dans cette section, la vidéo explique comment configurer l'environnement pour créer la plate-forme et l'appareil, créer un contexte et créer des files d'attente de commandes pour la programmation OpenCL. Cela implique d'obtenir l'ID de plate-forme, ce qui permet au programmeur de déterminer le nombre de plates-formes disponibles et d'allouer de l'espace pour le stockage. La vidéo explique ensuite comment choisir les périphériques au sein de la plate-forme, obtenir des informations sur le périphérique choisi, définir les arguments appropriés et transmettre les valeurs de ces arguments à la fonction noyau pour instancier le noyau. Enfin, ils montrent comment copier les résultats de l'appareil vers la mémoire de l'hôte une fois le noyau terminé.
  
  
• 00: 10: 00 Dans cette section, la vidéo explique comment créer un contexte OpenCL et l'importance de l'objet de contexte pour lier toutes les ressources nécessaires aux opérations OpenCL, telles que les files d'attente de commandes et les tampons. La transcription explique comment créer des tampons en lecture seule et en écriture seule, et comment copier des données entre l'hôte et le périphérique à l'aide des commandes CL ink et CL in Q write buffer. L'exemple utilisé est la multiplication matricielle, où les matrices A et B sont des entrées et la matrice C est une sortie. La vidéo souligne l'importance de vérifier les appels d'API réussis.
  
  
• 00:15:00 Dans cette section, l'orateur explique comment allouer de l'espace pour la matrice C, qui est la matrice de sortie. Ils disent que le tampon C est déclaré comme mémoire CL, ce qui permet à l'appareil d'y écrire les résultats. Cependant, cela n'interdit pas la lecture de ce tampon depuis le côté hôte, ce qui est nécessaire pour récupérer les résultats de l'appareil et copier la matrice résultante quelque part dans l'hôte. L'orateur montre la définition complète de l'API de tampon, qui prend cinq arguments : contexte, drapeaux, taille, pointeur d'hôte et valeur de retour.

[MetaQuotes]

14. Structure d'un programme OpenCL (partie 2)

14. Structure d'un programme OpenCL (partie 2)

La troisième étape de la programmation OpenCL implique la compilation du noyau, qui est différente pour les périphériques FPGA puisqu'elle est effectuée hors ligne. Le programme CL create avec source et C TX est utilisé pour créer un programme, suivi du programme CL build pour construire le programme en binaire. La fonction correcte du noyau est sélectionnée à l'aide du point d'entrée approprié, et les arguments du noyau doivent être initialisés à l'aide de l'argument CL set kernel avec le pointeur correct. L'orateur détaille la configuration correcte des arguments dans la multiplication matricielle. Ils discutent ensuite de la configuration des tailles de groupe de travail locales et globales, de l'exécution du noyau et de l'obtention des résultats à l'aide de l'API CL in queue buffer. Enfin, l'orateur mentionne brièvement les événements de la programmation OpenCL.

• 00:00:00 Dans cette section, la troisième étape d'un programme OpenCL est abordée, qui implique la compilation du noyau. Ce processus est un peu différent pour les appareils FPGA, car la compilation est effectuée hors ligne. En supposant que le code source du programme est stocké dans un tampon de caractères, le programme de création CL avec source et C TX est utilisé pour créer un programme, et le programme de construction CL est utilisé pour construire le programme en binaire. Ensuite, la fonction de noyau correcte est sélectionnée à partir du code source en créant un noyau à l'aide du point d'entrée approprié pour la fonction de noyau spécifique choisie. Une fois le noyau créé, les arguments du noyau doivent être correctement initialisés à l'aide de l'argument du noyau défini CL, avec un pointeur pointant vers la valeur réelle. Par exemple, dans la multiplication matricielle, sept arguments doivent être configurés correctement, y compris le tampon de destination, la taille des matrices et les deux matrices d'entrée.
  
  
• 00:05:00 Dans cette section, l'orateur parle de l'initialisation de plusieurs arguments du noyau et souligne l'importance de configurer correctement les indices de ces arguments pour éviter les erreurs. Ils expliquent ensuite comment définir la taille des groupes de travail locaux et globaux, en spécifiant le nombre d'éléments de travail dans un groupe et le nombre de groupes de travail. Enfin, ils décrivent les étapes d'exécution du noyau, notamment l'appel de l'API OpenCL et l'obtention des résultats du périphérique vers la mémoire hôte à l'aide de l'API CL in queue buffer. L'orateur mentionne également brièvement les événements et comment ils peuvent être utilisés dans la programmation OpenCL, mais cela sera discuté plus en détail dans des conférences ultérieures.

[MetaQuotes]

15. Démo de multiplication de matrice OpenCL

15. Démo de multiplication de matrice OpenCL

La vidéo "OpenCL Matrix Multiplication Demo" explique le processus d'exécution d'un exemple de multiplication matricielle à l'aide du framework OpenCL. Il comprend plusieurs fichiers de code source tels qu'un programme C principal pour le côté hôte, un programme noyau et un makefile. La vidéo couvre différents aspects du framework OpenCL, l'obtention des ID de plate-forme et de périphérique, la création d'un contexte OpenCL, des objets de programme et de noyau, la gestion des tampons pour l'hôte et la création et l'initialisation des tampons sur le périphérique. Le présentateur montre également un exemple de noyau qui effectue des opérations de produit scalaire et une démonstration du résultat final sur un moteur de calcul AMD Radeon pro 575.

• 00:00:00 Dans cette section, l'orateur explique comment exécuter un exemple de multiplication matricielle via OpenCL. L'exemple se compose de plusieurs fichiers de code source, y compris un programme C principal en tant que programme côté hôte, un programme noyau nommé my kernel CL et un makefile pour aider à compiler le projet. Le programme principal comprend des bibliothèques standard, des définitions de macros pour le framework OpenCL et des déclarations pour les matrices d'entrée (matrice A et matrice B) ainsi que le nom de l'appareil, les identifiants de plate-forme et le nombre d'appareils. L'orateur décrit également divers aspects du framework OpenCL, tels que le contexte, le programme, le noyau et la lecture et la compilation du code source. En outre, l'orateur explique l'importance des identifiants de plate-forme et d'appareil ainsi que des dimensions de la matrice dans le code.
  
  
• 00: 05: 00 Dans cette section, l'orateur discute du processus d'obtention des identifiants de plate-forme et de périphérique et de création du contexte OpenCL pour la démonstration de multiplication matricielle. Ils expliquent comment le nombre de plates-formes est renvoyé et le tableau est alloué pour stocker les ID de plate-forme. Ils montrent également comment obtenir les ID de périphérique pour un type spécifique choisi et interroger son nom. La vidéo montre comment créer une file d'attente de commandes pour chaque périphérique et comment compiler le programme OpenCL. Ils expliquent en outre comment utiliser l'application ouverte pour ouvrir le fichier de code source du noyau et compiler le programme.
  
  
• 00:10:00 Dans cette section, la vidéo explique comment créer un objet programme à partir du code source du noyau OpenCL. Ce processus est différent sur différentes plates-formes. Sur Mac OS avec prise en charge native d'OpenCL, on peut créer un objet programme à l'aide du code source. Sur le SDK Altera FPGA OpenCL, cependant, la création d'un objet programme implique la compilation du noyau et sa création à partir du résultat binaire de cette compilation à l'aide de l'API spécifique d'Altera. Une fois l'objet programme créé, la vidéo montre comment construire le programme noyau et créer l'objet noyau. Enfin, la vidéo passe en gestion de tampon côté hôte, où un tampon est alloué pour stocker la matrice résultante C.
  
  
• 00: 15: 00 Dans cette section, le présentateur explique comment créer et initialiser des tampons côté périphérique pour la multiplication matricielle à l'aide d'OpenCL. Ils montrent ensuite comment définir correctement les arguments du noyau, y compris la définition des tailles de groupe de travail globales et locales. L'importance de vérifier la valeur de retour du CL est également soulignée. Le présentateur montre ensuite comment lire les résultats dans la mémoire de l'hôte, puis libère les ressources allouées sur l'hôte et OpenCL. Enfin, ils montrent un exemple de noyau, qui utilise get global ID pour parcourir la largeur d'une matrice, effectuer des opérations de produit scalaire et stocker les résultats dans l'élément correspondant de la matrice C.
  
  
• 00: 20: 00 Dans cette section, l'orateur discute de la construction du programme principal C et du programme Mike Rinder CL. Pour construire le programme côté hôte, les utilisateurs doivent compiler un seul fichier de programme C, et pour le noyau, on peut utiliser le compilateur GPU pour compiler la Micra connaître le CL en un binaire GPU. Après avoir construit le programme côté hôte et côté périphérique, les utilisateurs disposent d'un exécutable nommé "main", ainsi que de différents fichiers binaires disponibles pour différentes versions de GPU. Lors de l'exécution de ce fichier, l'orateur montre une plate-forme OpenCL avec un moteur de calcul AMD Radeon pro 575 qui a une valeur initiale de la matrice C avec tous les éléments contenant huit points.