OpenCL dans le Trading - page 9

[MetaQuotes]

EECE.6540 Heterogeneous Computing (Université du Massachusetts Lowell) - 46. Concepts de base du FPGA

46. Concepts de base du FPGA

Cette vidéo couvre les concepts de base des réseaux de portes programmables par l'utilisateur (FPGA). Contrairement aux processeurs, les FPGA peuvent être programmés pour s'adapter à des ressources matérielles spécifiques, ce qui signifie qu'ils sont hautement personnalisables. La vidéo traite de l'importance de la latence dans la conception de circuits et de la façon dont elle peut être équilibrée avec la maximisation de f max. Il introduit le concept de conception de pipeline pour augmenter la fréquence à laquelle un calcul peut être effectué, ainsi que la discussion des chemins de données et des chemins de contrôle dans un circuit. Enfin, la vidéo traite de l'occupation des circuits dans un FPGA et de la façon dont la diminution des bulles et l'augmentation de l'occupation peuvent augmenter f max.

• 00: 00: 00 Dans cette section, nous découvrons les concepts de base des réseaux de portes programmables par l'utilisateur (FPGA) et comment ils diffèrent des autres architectures de processeur. Contrairement aux processeurs, les FPGA n'ont pas de chemin de données fixe et peuvent être programmés pour s'adapter à des ressources matérielles spécifiques afin de prendre en charge différents nombres de registres, de logique de calcul et de leurs connexions, ce qui les rend hautement personnalisables. Les FPGA contiennent divers composants, tels que la logique adaptative, les blocs RAM, les blocs DSP et les commutateurs de routage programmables, qui peuvent être connectés pour mettre en œuvre différentes conceptions. De plus, la fréquence de fonctionnement maximale d'un FPGA est déterminée par le délai de propagation physique de la logique combinatoire, qui affecte la latence et la vitesse de fonctionnement du circuit.
  
  
• 00:05:00 Dans cette section, le concept de latence et son importance dans la conception de circuits sont expliqués. La latence est le temps qu'il faut à un circuit pour effectuer une ou plusieurs opérations, et elle peut être mesurée en temps ou en cycles d'horloge. Réduire la latence est généralement l'objectif, mais il doit être soigneusement équilibré avec la maximisation de f max. Un exemple est donné d'une conception optimisée pour la latence et d'une autre optimisée pour f max grâce à l'utilisation d'un pipeline. L'importance des registres de pipelines pour briser les longs chemins critiques et améliorer la vitesse est soulignée.
  
  
• 00: 10: 00 Dans cette section, la vidéo explique le concept de conception de pipeline et comment il augmente la fréquence à laquelle un calcul peut être effectué. En utilisant un registre pipeline, le retard peut être raccourci, permettant des vitesses d'horloge plus élevées et une augmentation du débit. La vidéo introduit ensuite l'idée de chemin de données et de chemin de contrôle dans un circuit, où le chemin de données est la chaîne de registres et la logique combinatoire qui effectue le calcul, et le chemin de contrôle est tout le reste en dehors du chemin de données qui contrôle le fonctionnement du circuit. . Diverses logiques sont ajoutées au chemin de contrôle pour le contrôle de flux d'établissement de liaison, le contrôle de boucle et le contrôle de branche, entre autres, et l'occupation est utilisée pour définir le taux d'initialisation du chemin de données dans un circuit.
  
  
• 00:15:00 Dans cette section, le conférencier explique le concept d'occupation des circuits dans un FPGA. Le circuit comporte plusieurs registres, l'un étant un registre valide qui détermine si les données d'entrée sont valides ou non. L'objectif est de diminuer les bulles dans le circuit pour augmenter l'occupation en minimisant les bulles dans l'ensemble du circuit. Chaque cycle est compté pour voir comment les ressources sont utilisées, et les parties inoccupées du circuit sont appelées bulles. En diminuant les bulles et en augmentant l'occupation, la f max peut être augmentée.

[MetaQuotes]

47. Analyse de conception (I) : Analyser les premières images FPGA

47. Analyse de conception (I) : Analyser les premières images FPGA

Cette section de la vidéo se concentre sur le processus d'analyse des premières images FPGA pour une conception DPC++. L'orateur explique les étapes impliquées, telles que la compilation du programme, la génération du binaire FPGA et l'exécution du profilage. La vidéo comprend une démonstration sur la façon de générer des rapports et d'interpréter les divers panneaux d'information fournis dans les rapports. Le conférencier analyse également les premières images FPGA d'un module b2 et discute des différents blocs logiques, des boucles, de l'unité de charge et du facteur de déroulement. Ils expliquent également comment la conception d'une fonction du noyau peut avoir un impact significatif sur la conception interne du FPGA et fournissent des exemples de la manière dont les boucles internes et externes peuvent être déroulées pour augmenter le débit. Les exemples illustrent la flexibilité de la programmation en langage de haut niveau pour influencer les ressources matérielles du FPGA.

• 00:00:00 Dans cette section de la vidéo, l'orateur discute du processus d'analyse d'une conception DPC++, en se concentrant spécifiquement sur l'analyse des premières images FPGA. Cela implique plusieurs étapes telles que la compilation du programme sur un émulateur FPGA pour garantir l'exactitude fonctionnelle, la génération du binaire FPGA, son exécution sur une carte de fonctionnalité et l'exécution du profilage pour déterminer les performances d'exécution. La deuxième étape consiste à générer des rapports et à rechercher les goulots d'étranglement avant de revoir la conception si nécessaire. La vidéo comprend une démonstration sur la façon de générer des rapports et de les analyser dans un navigateur, et explique comment interpréter les différents panneaux d'information et résumés fournis dans les rapports.
  
  
• 00:05:00 Dans cette section, l'orateur donne un aperçu de l'outil d'analyse de conception et de ses fonctionnalités. Ils expliquent comment le panneau d'utilisation des ressources affiche des informations sur les ressources qui seront utilisées par la conception et comment le panneau des visualiseurs de système permet aux utilisateurs d'afficher différents composants de la conception, tels que les composants de mémoire et les canaux. La visionneuse de graphiques dans le panneau des visionneuses de système affiche une liste des composants utilisés dans la conception et la façon dont ils sont interconnectés. Le conférencier montre également comment les utilisateurs peuvent zoomer sur des modules individuels pour afficher leurs segments correspondants dans le code source.
  
  
• 00: 10: 00 Dans cette section, l'orateur analyse les premières images FPGA d'un module b2 et discute des différents blocs et boucles logiques qui composent la conception. Ils expliquent également l'utilisation de l'unité de chargement pour charger des données à partir du composant de mémoire et le facteur de déroulement pour augmenter l'efficacité des opérations de boucle. Le conférencier compare également les conceptions à 4 tâches parallèles et à tâche unique et recommande d'utiliser une tâche unique pour les conceptions FPGA afin d'optimiser l'accès à la mémoire.
  
  
• 00: 15: 00 Dans cette section, l'orateur explique comment la conception d'une fonction noyau peut avoir un impact significatif sur la conception interne du FPGA. Le conférencier donne des exemples de la manière dont les boucles internes et externes peuvent être déroulées pour utiliser les ressources matérielles du FPGA, augmentant ainsi le débit. Les exemples illustrent la flexibilité de la programmation en langage de haut niveau pour influencer les ressources matérielles du FPGA.

[MetaQuotes]

48. Analyse de conception FPGA DPC++ (II) : profilage d'exécution

48. Analyse de conception FPGA DPC++ (II) : profilage d'exécution

Dans cette vidéo, le présentateur décrit le processus d'analyse des performances d'exécution d'un programme à l'aide d'outils qui collectent des données de performances en ajoutant des registres d'instruments de profilage aux flux binaires FPGA. Ils montrent comment compiler pour le profilage et interpréter les résultats du profilage collectif à l'aide du profileur dynamique Intel FPGA avec des compteurs de performances ajoutés par l'utilisateur. Ils montrent comment le profileur V2 affiche les fonctions du noyau et les exécutables utilisés pour analyser les résultats du profilage d'exécution, et comment identifier les goulots d'étranglement des partitions et les optimiser. L'exemple utilisé est un noyau de modification de matrice qui avait beaucoup d'accès mémoire à la mémoire globale, qui a été optimisé en utilisant la mémoire locale pour réduire la communication avec la mémoire globale et améliorer l'efficacité de la conception.

• 00:00:00 Dans cette section, le présentateur traite de l'analyse des performances d'exécution d'un programme. Ils expliquent comment utiliser des outils pour collecter des données de performances en ajoutant des registres d'instruments de profilage aux flux binaires FPGA. Le profileur dynamique Intel FPGA est utilisé avec des compteurs de performances ajoutés par l'utilisateur pour collecter les données de performances du noyau. Les données de performances sont stockées dans un fichier appelé profile.mall à la fin de l'exécution, et un fichier json est généré pour permettre au profileur Intel v2 de lire les fichiers. Les deux fichiers sont nécessaires lors du chargement du dossier de résultats dans la boîte à outils Intel Retune. L'importation des données à partir du répertoire est importante lors du chargement des données dans la v2.
  
  
• 00:05:00 Dans cette section, les présentateurs montrent comment compiler pour le profilage et interpréter les résultats du profilage collectif. Ils montrent comment le profileur V2 affiche les fonctions du noyau et les exécutables utilisés pour analyser les résultats du profilage d'exécution. Le panneau affiche les fonctions d'opération de mémoire et les opérations de boucle, leur temps, le pourcentage de blocage, l'occupation, le temps d'inactivité, le pourcentage d'activité, la taille du transfert de données et la bande passante moyenne. La partie inférieure du panneau montre plus en détail l'utilisation du FPGA et d'autres mesures pour l'occupation globale de la bande passante de la mémoire. En affichant les statistiques détaillées, les concepteurs peuvent comprendre les noyaux individuels et leurs fonctions, ce qui les aide à optimiser et à améliorer leurs conceptions.
  
  
• 00:10:00 Dans cette section de la vidéo, l'orateur explique comment identifier les goulots d'étranglement des partitions et les optimiser. L'exemple utilisé est un noyau de modification de matrice qui a beaucoup d'accès mémoire à la mémoire globale, résultant en 15,57 Go de transfert de données. La conception du noyau est liée à la mémoire et la solution consiste à optimiser l'accès à la mémoire en utilisant la mémoire locale pour réduire la communication avec la mémoire globale et améliorer l'efficacité de la conception. Cette optimisation sera discutée dans le cours suivant.

[MetaQuotes]

EECE.6540 Informatique hétérogène (Université du Massachusetts Lowell) - 49. Exemples OpenCL

49. Exemples OpenCL (I)

La vidéo YouTube "Exemples OpenCL (I)" couvre l'implémentation de la multiplication matricielle à l'aide de boucles imbriquées dans la programmation C et son implémentation en tant que noyau OpenCL. Le conférencier explique comment utiliser deux niveaux de boucles imbriquées pour le calcul du produit scalaire de l'élément résultant dans la matrice, et comment chaque élément de sortie de la matrice C est traité comme un élément de travail distinct dans OpenCL. La vidéo couvre également les étapes nécessaires pour préparer l'exécution du noyau OpenCL et récupérer la matrice résultante d'un périphérique à un hôte, ainsi que la définition de la taille des groupes de travail et l'exécution du noyau avec des arguments de noyau modifiés. De plus, un exemple de code pour la multiplication matricielle est fourni, et l'orateur démontre le processus d'obtention des ID de périphérique et de plate-forme sur un Mac OS et de création d'un objet programme sur différentes plates-formes. Enfin, la vidéo explique la gestion des tampons, en traçant les ressources allouées côté hôte et les ressources OpenCL utilisées, et fournit un exemple simple de noyau de multiplication.

Cette vidéo couvre divers exemples d'utilisation d'OpenCL, y compris la multiplication matricielle, la rotation d'image et le filtrage d'image. Pour la rotation d'image, l'orateur explique comment décomposer le problème à l'aide de la décomposition d'entrée et démontre la fonction noyau utilisée pour identifier l'emplacement d'origine et le nouvel emplacement de chaque pixel. Pour le filtrage d'image, l'orateur aborde le concept de création d'objets image côté périphérique et l'utilisation de l'échantillonneur OpenCL pour définir comment accéder à l'image. Ils présentent également un exemple d'implémentation de la fonction de convolution d'image avec deux boucles for imbriquées. La vidéo se termine par une démonstration de l'utilisation d'OpenCL pour effectuer un filtre de convolution sur une image et vérifier les résultats.

• 00:00:00 Dans cette section, le conférencier présente la multiplication matricielle, un exemple informatique classique, et explique comment elle peut être implémentée par des boucles imbriquées en programmation C. Ils expliquent également le calcul du produit scalaire de l'élément résultant dans la matrice, qui est le produit d'une ligne de la matrice A et d'une colonne de la matrice B. Le cours explique que les deux niveaux de boucles imbriquées peuvent être exécutés indépendamment et peuvent être exécutés de façon aléatoire.
  
  
• 00: 05: 00 Dans cette section, le concept d'élément de travail et comment il peut être appliqué pour implémenter la multiplication matricielle dans le noyau OpenCL est discuté. Chaque élément de sortie de la matrice C est traité comme un élément de travail distinct et, à l'aide d'éléments de traitement FPGA ou GPU, une plage bidimensionnelle d'éléments de travail peut être mappée à d'autres boucles for dans l'implémentation matérielle. Pour implémenter la multiplication matricielle, une fonction noyau nommée "simple multiplier" avec une liste d'arguments est définie, ce qui nécessite toutes les matrices d'entrée nécessaires et leurs dimensions. Le corps de la fonction noyau utilise des ID globaux pour calculer la position bidimensionnelle de l'élément de travail et initialise la somme pour calculer l'élément résultant de la matrice C.
  
  
• 00: 10: 00 Dans cette section, l'orateur explique la fonction du noyau pour la multiplication matricielle à l'aide du cadre de programmation OpenCL. La fonction noyau utilise une opération de produit scalaire et une boucle for pour parcourir les éléments du vecteur ligne à partir de a et du vecteur colonne à partir de B. Les indices de la matrice d'entrée bidimensionnelle sont calculés à l'aide des numéros de ligne et des numéros de colonne pour trouver l'élément droit dans le vecteur ligne et le vecteur colonne. Une fois le produit scalaire calculé, l'élément résultant est affecté à l'élément correspondant en C. L'environnement de calcul est également discuté, qui dépend de la plate-forme et implique la compréhension des ressources disponibles et des paramètres importants de la plate-forme.
  
  
• 00: 15: 00 Dans cette section, l'orateur décrit les étapes nécessaires pour préparer un noyau OpenCL à fonctionner, en commençant par créer un contexte et une file d'attente de commandes pour instancier les noyaux. Ensuite, les données d'entrée sont préparées en allouant des tampons côté hôte, en copiant les données de la mémoire de l'hôte vers la mémoire de l'appareil et en envoyant le noyau. Le programme attend ensuite la fin du noyau pour collecter les résultats en lisant la mémoire de l'appareil. L'application openCL comporte deux couches : la couche de plate-forme et la couche d'exécution, et le programme du noyau doit être compilé dans un binaire pouvant être exécuté sur le périphérique accélérateur, soit un FPGA, soit un GPU. Ces étapes diffèrent selon l'appareil, et la compilation d'un binaire PG peut prendre des heures, tandis que la compilation GPU est souvent rapide.
  
  
• 00:20:00 Dans cette section, la vidéo explique comment configurer l'environnement pour la programmation OpenCL. La première étape consiste à obtenir l'ID de la plate-forme, ce qui est fait avec la fonction CL get platform IDs qui renvoie le nombre de plates-formes disponibles dans le système. Ensuite, la vidéo explique comment obtenir un périphérique spécifique au sein de la plate-forme en fonction des préférences de l'utilisateur et comment créer un contexte OpenCL, qui est l'enceinte de toutes les ressources telles que les files d'attente de commandes et les tampons. Le tutoriel recommande de vérifier la valeur de retour pour garantir le succès de l'opération.
  
  
• 00:25:00 Dans cette section, la vidéo explique comment créer et déplacer des données à partir des matrices d'entrée B et C, et de la matrice de sortie C, en déclarant des tampons et en utilisant les fonctions de l'API OpenCL. Ils supposent que les matrices A, B et C ont déjà été déclarées en tant que tableaux de type flottant et stockent les données dans un espace d'adressage linéaire dans la mémoire physique. La vidéo montre comment utiliser la fonction CL create buffer pour déclarer des tampons pour les matrices A et B, et la fonction CL Inc you write buffer pour copier les données initiales des matrices A et B dans les tampons créés, qui résident sur l'appareil. L'étape suivante consiste à allouer de l'espace pour la matrice C, qui est déclarée comme tampon en écriture seule de la mémoire CL puisque l'appareil y écrit les résultats des calculs.
  
  
• 00:30:00 Dans cette section de la vidéo YouTube "Exemples OpenCL (I)", l'orateur explique le processus de récupération des résultats d'un appareil et de copie de la matrice résultante du tampon C vers un hôte. La définition de l'API C est affichée, avec une explication des cinq arguments pour créer un tampon, y compris le contexte, les indicateurs, la taille, le pointeur d'hôte et la valeur de retour. L'orateur poursuit ensuite en expliquant la troisième étape majeure du programme OpenCL, qui est la compilation du noyau, en utilisant un processus de compilation simple pour les périphériques FPGA. Le processus implique la création et la construction d'un programme et la sélection de la bonne fonction du noyau à partir du code source. Enfin, l'orateur explique comment initialiser les arguments du noyau avant d'exécuter le programme du noyau, à l'aide de l'API OpenCL CL set kernel argument.
  
  
• 00:35:00 Dans cette section, l'intervenant discute du processus d'initialisation des arguments du noyau, de définition de la taille des groupes de travail, d'exécution du noyau et d'obtention de résultats dans un programme OpenCL. L'utilisateur doit utiliser l'API 'CL create kernel' et spécifier la taille et la valeur de l'argument du noyau, en utilisant un pointeur vers la valeur réelle. L'orateur insiste sur l'importance de définir avec précision les indices d'arguments et de les modifier pour chaque ligne lors du copier-coller. Les tailles de groupe de travail local et global doivent être définies pour le nombre d'éléments de travail et de groupes de travail. Enfin, le tampon CL joint est utilisé pour lire le tampon de sortie sur la mémoire de l'hôte, indiquant les exigences de synchronisation pour une exécution correcte.
  
  
• 00:40:00 Dans cette section, l'intervenant présente un exemple de multiplication matricielle à l'aide d'OpenCL. Le code source de l'exemple de multiplication matricielle se compose de plusieurs fichiers, y compris le programme côté hôte, le programme du noyau et un makefile pour aider à compiler le projet. Le programme côté hôte est écrit en C et comprend des bibliothèques standard et des fichiers d'en-tête spécifiques pour le framework OpenCL. L'exemple inclut des matrices d'entrée et des déclarations pour les variables, y compris le nombre de plates-formes et de périphériques, le contexte, le programme OpenCL et le noyau OpenCL. L'orateur explique également comment compiler le code source du noyau et décrit les tailles des matrices d'entrée et la matrice de sortie résultante.
  
  
• 00:45:00 Dans cette section de la vidéo, le présentateur montre comment obtenir les ID de périphérique et de plate-forme pour OpenCL sur un Mac OS. En appelant diverses fonctions OpenCL telles que get platform ID et en créant des files d'attente de commandes, le locuteur crée un contexte OpenCL et compile le programme. Ils expliquent également que le code affiché prend en charge à la fois Mac OS et un SDK OpenCL, et signalera une erreur s'il est exécuté sur une plate-forme différente.
  
  
• 00:50:00 Dans cette section, la vidéo montre comment créer un objet programme à l'aide d'OpenCL sur différentes plates-formes. Sur Mac OS, l'objet programme est créé à partir d'un fichier de code source du noyau, tandis que sur le SDK Altera FPGA OpenCL, il est créé à partir d'un fichier binaire généré par compilation. Une fois l'objet programme créé, le programme noyau peut être construit et la fonction noyau spécifique peut être sélectionnée à partir de cet objet programme. À la fin de cette section, les objets et fonctions nécessaires sont prêts pour la section suivante du programme.
  
  
• 00: 55: 00 Dans cette section, la vidéo traite du processus de gestion des tampons, y compris l'allocation d'un tampon pour stocker les résultats de la matrice et l'utilisation de CL créer un tampon pour créer des tampons côté périphérique. La vidéo souligne également l'importance de vérifier la valeur de retour du CL dans Q et le colonel de gamme pour assurer une exécution réussie, en particulier lors de l'utilisation de FPGA. De plus, la vidéo explique le processus de vérification des résultats en imprimant les ressources allouées côté hôte et les ressources OpenCL utilisées, et fournit un exemple simple de noyau de multiplication où sept arguments sont utilisés pour effectuer une opération de produit scalaire à travers des itérations.
  
  
• 01:00:00 Dans cette section de la vidéo, l'intervenant explique deux exemples d'utilisation d'OpenCL. La première est la multiplication matricielle. Le programme traite deux matrices et multiplie leurs éléments correspondants pour stocker le résultat dans une troisième matrice. Le deuxième exemple est la rotation d'image, où le programme fait pivoter les pixels d'une image en fonction de certaines formules. Ces formules tiennent compte des coordonnées originales et nouvelles de chaque pixel et de l'angle de rotation.
  
  
• 01:05:00 Dans cette section, l'orateur explique comment décomposer un problème de rotation d'image en problèmes plus petits à l'aide de la décomposition des entrées. Ils expliquent que les informations sur les pixels de l'image seront copiées vers un nouvel emplacement grâce à des calculs indépendants des dimensions x et y. Des groupes de travail sont chargés de calculer le nouvel emplacement de chaque pixel à l'aide de son ID global. L'orateur détaille également comment déterminer les groupes et les dimensions des éléments de travail et la fonction noyau nécessaire pour effectuer cette opération. L'objectif est de créer une méthode plus efficace et évolutive pour les calculs de rotation d'image.
  
  
• 01:10:00 Dans cette section, le présentateur vidéo explique comment utiliser OpenCL pour faire pivoter une image. La fonction noyau est utilisée pour identifier l'emplacement d'origine d'un pixel, calculer le nouvel emplacement du pixel à l'aide des paramètres de rotation, vérifier la vérification des limites pour s'assurer que les nouvelles coordonnées correspondent à la taille de l'image d'origine et copier les informations de pixel à partir de l'emplacement d'origine. au nouvel emplacement. Le code inclut également des liaisons C++ pour l'API OpenCL et des étapes pour interroger les plates-formes, acquérir des appareils et déclarer des tampons pour déplacer les données de la mémoire hôte vers le tampon de l'appareil. Le tampon en lecture seule est également créé pour assurer la sécurité des données d'origine.
  
  
• 01:15:00 Dans cette section, l'orateur explique les étapes nécessaires pour effectuer une rotation d'image à l'aide d'OpenCL. Tout d'abord, l'image originale doit être copiée dans un tampon d'image. Ensuite, le noyau est compilé et exécuté en initialisant le tampon de destination et en définissant les bons arguments du noyau, y compris les dimensions de l'image d'origine et les paramètres de rotation. Le noyau est exécuté avec la taille globale du groupe de travail et la taille du groupe de travail local. Enfin, le résultat est relu sur l'hôte à l'aide du tampon de lecture in Q. L'orateur présente également l'exemple de code source pour la rotation d'images, qui comprend des fichiers d'en-tête, des fonctions utilitaires, des ID de plate-forme et de périphérique, des files d'attente de commandes, des objets de programme et de noyau et des tampons d'entrée/sortie pour les images d'origine et pivotées.
  
  
• 01:20:00 Dans cette section, la vidéo couvre le processus de rotation d'une image à l'aide d'OpenCL. L'hôte lit l'image au format BMP et la convertit en un tableau de nombres à virgule flottante stocké dans le tampon d'image d'entrée. Le tampon de sortie sur l'hôte est créé et initialisé avec des nombres aléatoires. La plate-forme est interrogée pour trouver les périphériques sur la plate-forme et créer un contexte et une file d'attente de commandes. Les objets programme et noyau sont créés et des tampons côté périphérique sont créés pour stocker l'image d'origine et la rotation. L'image d'origine est copiée dans la mémoire tampon côté périphérique et les arguments du noyau sont définis. Le noyau est exécuté en l'instanciant avec les tailles de groupe de travail global et local. La valeur de retour est vérifiée pour s'assurer que le noyau s'est exécuté avec succès.
  
  
• 01:25:00 Dans cette section, l'orateur donne un aperçu de la rotation d'image à l'aide d'OpenCL. Une fois le noyau terminé, les données de sortie sont relues vers l'hôte à l'aide du pointeur vers la mémoire globale côté périphérique, et un tampon hôte est fourni pour stocker l'image. Le formatage BMP est impliqué dans le processus, et une fonction utilitaire appelée write BMP float est utilisée pour créer un nouveau fichier BMP qui affiche le résultat. La fonction du noyau est décrite en détail, où les pointeurs de tampon de destination et de source sont transmis avec les dimensions de l'image et les paramètres de rotation. La formule de calcul des nouvelles coordonnées de chaque pixel est utilisée et une vérification des limites est appliquée avant de copier les informations de pixel de l'emplacement d'origine vers le nouvel emplacement. Le processus est démontré avec un exemple de rotation d'une image de chat de 45 degrés.
  
  
• 01:30:00 Dans cette section, le conférencier explique le concept de filtrage d'image à l'aide d'OpenCL. Il décrit le processus d'utilisation d'un filtre 3x3 pour multiplier et additionner les valeurs des pixels voisins pour obtenir la nouvelle valeur de pixel filtrée. Il insiste également sur la nécessité d'être prudent lorsqu'il s'agit de pixels proches de la frontière qui ont moins de pixels voisins pour appliquer le filtre. L'orateur présente ensuite différents types de filtres d'image pouvant être appliqués à une image originale à l'aide d'OpenCL. Ensuite, il présente un exemple d'implémentation de la fonction de convolution d'image avec deux boucles for imbriquées qui traversent chaque pixel de l'image et une troisième boucle qui traverse les éléments du filtre.
  
  
• 01:35:00 Dans cette section, l'orateur parle de la structure de données d'image dans OpenGL, qui est un type opaque qui est maintenu en tant que structure multidimensionnelle et utilisé pour les types de données d'image. Contrairement aux types entiers ou pointeurs, les images ne peuvent pas être visualisées directement à travers des points dans un appareil, et leurs valeurs de pixel peuvent être spécifiées sous forme de valeurs flottantes ou entières. La création d'objets image côté appareil permet aux unités de calcul OpenCL de lire et d'écrire de nouveaux pixels sur les objets image, et cela est bénéfique pour les longues séquences d'instructions optimisées spécifiques au traitement des données d'image ou aux processeurs graphiques. L'orateur explique également comment créer un tampon d'image source, un objet d'image de sortie et un filtre en copiant les données d'image et de filtre sur l'appareil à l'aide d'API telles que CL Write Image et CL Create Buffer.
  
  
• 01:40:00 Dans cette section, le présentateur introduit le concept d'échantillonneur OpenCL, qui est un objet utilisé pour décrire comment accéder à une image. L'échantillonneur est créé à l'aide de la fonction API qui prend le contexte comme argument et définit si les coordonnées seront normalisées ou non. Le mode d'adressage est également défini, qui gère la manière dont les coordonnées de l'image sont gérées lorsqu'elles sont hors plage. Le mode de filtrage spécifie le filtre qui doit être appliqué lorsque les coordonnées tombent entre les pixels. Une fonction de noyau nommée convolution est également introduite, qui prend des objets d'image 2D d'entrée et de sortie, un filtre flottant constant pour stocker les valeurs de filtre et l'objet échantillonneur. La fonction noyau lit les éléments de données de l'objet image et renvoie un vecteur de quatre nombres à virgule flottante pour effectuer une arithmétique sur les données d'image.
  
  
• 01:45:00 Dans cette section, l'orateur explique comment effectuer des opérations sur des vecteurs à virgule flottante à l'aide d'un vecteur à virgule flottante à quatre éléments. Ils passent par le processus d'initialisation de l'index de filtre, de déclaration de variables pour les coordonnées à deux éléments, d'itération dans les lignes de filtre et de calcul des coordonnées en deux dimensions. Le pixel est lu à partir de l'objet image à l'aide de la fonction F de lecture d'image et multiplié par la valeur du pixel du filtre, la valeur mise à jour étant stockée dans l'image de sortie. Enfin, l'image est relue à l'aide d'une fonction CL d'encre que vous lisez.
  
  
• 01:50:00 Dans cette section, le code pour les exemples OpenCL (I) est discuté, qui fournit des filtres à utiliser dans le traitement d'image. Le programme attribue différentes tailles et valeurs à chaque type de filtre et utilise des fonctions d'assistance pour initialiser les valeurs de filtre et lire les données d'image BMP à partir d'un fichier. La découverte de plate-forme et de périphérique est effectuée avant de créer les images d'entrée et de sortie, ainsi que le tampon de filtre. Une fois initialisé, l'échantillonneur configure la façon dont les pixels sortant de la limite seront traités avant d'exécuter le noyau avec les paramètres de filtre appropriés. La taille globale est définie sur le nombre de colonnes et de lignes dans l'image.
  
  
• 01:55:00 Dans cette section, l'orateur montre un exemple d'utilisation d'OpenCL pour effectuer un filtre de convolution sur une image. Le processus implique la configuration d'un noyau qui traite l'intégralité de l'image et utilise une taille locale de 8 par 8 éléments de travail dans un groupe dans une dimension de données. L'image de sortie est stockée côté appareil et peut être relue vers l'hôte à l'aide de l'image de lecture CL. Les résultats sont ensuite comparés à une image de référence filtrée qui a été générée en exécutant le filtre du côté hôte. Les deux images sont visuellement identiques, vérifiant les résultats. Enfin, les ressources côté hôte et côté périphérique sont libérées.

[MetaQuotes]

Une comparaison de SYCL, OpenCL, CUDA et OpenMP pour la classification vectorielle de support massivement parallèle ( WOCL / SYCLcon 2022 )

Une comparaison de SYCL, OpenCL, CUDA et OpenMP pour une classification vectorielle de support massivement parallèle

La vidéo compare les performances de SYCL, OpenCL, CUDA et OpenMP sur différentes plates-formes matérielles pour une classification massivement parallèle des machines à vecteurs de support. L'orateur explique la parallélisation de la multiplication matrice-vecteur avec une implémentation appelée Parallel Fibonacci, qui prend en charge l'exécution multigpu, mais uniquement la classification binaire et les calculs denses. Le matériel utilisé pour les tests comprend les GPU Nvidia A100 et RTX 380, le GPU AMD Radeon Pro 7 et le processeur Intel Core E9-10-09020X. Les résultats montrent que CUDA est le backend le plus rapide pour les GPU Nvidia, tandis qu'OpenCL est le backend le plus rapide pour les CPU. SYCL est convivial, tandis que Hipsicle est plus rapide que DPC++ et OpenCL pour une utilisation bon marché. De plus, l'orateur discute des travaux futurs, tels que l'étude des performances sur les FPGA, l'ajout de la prise en charge des systèmes distribués via les MPI et l'utilisation de calculs de précision mixtes et de matériel spécial d'apprentissage automatique comme les cœurs de tenseur de NVIDIA.

• 00: 00: 00 Dans cette section de la vidéo, l'orateur présente une comparaison de différents langages de programmation parallèles, notamment SYCL, OpenCL, CUDA et OpenMP, en mettant l'accent sur leur utilisation pour la classification massivement parallèle des machines à vecteurs de support (SVM) sur matériel multifournisseur. L'orateur présente la machine à vecteurs de support et décrit son utilisation dans l'apprentissage automatique supervisé pour la classification binaire. Cependant, les machines à vecteurs de support conventionnelles ont un problème en ce qu'elles résolvent un problème de programmation quadratique convexe de manière séquentielle. Pour résoudre ce problème, le locuteur utilise la formulation de la machine à vecteurs de support des moindres carrés, qui réduit le problème à la résolution d'un système d'équations linéaires. L'orateur discute également des détails de mise en œuvre de leur bibliothèque, qui s'appelle Parallel Fibonacci.
  
  
• 00:05:00 Dans cette section, l'orateur explique la machine virtuelle PLSS qui est écrite en C++ moderne. À l'aide d'un seul paramètre de modèle, il est possible de basculer entre les types à virgule flottante simple et double précision. L'orateur parle également de la parallélisation de la multiplication matrice-vecteur dans l'algorithme CG, car il s'agit de la partie la plus importante en termes de calcul de l'algorithme. Ils ont implémenté quatre backends différents (OpenMP, CUDA, OpenCL, Signal) et pris en charge l'exécution multigpu. Cependant, actuellement, seules la classification binaire et les calculs denses sont pris en charge, et ils ne prennent pas en charge la classification multiclasse prête à l'emploi. De plus, le backend OpenMP diverge fortement des autres implémentations, et pour les backends GPU (CUDA, OpenCL et SYCL), ils ont implémenté un CG et l'utilisent pour les trois backends afin de réduire la duplication de code et les bogues potentiels.
  
  
• 00:10:00 Dans cette section de la vidéo, le matériel utilisé et la méthodologie des tests sont expliqués. L'accent est mis sur quatre plates-formes différentes, à savoir les GPU Nvidia A100 et RTX 380, le GPU AMD Radeon Pro 7 et le processeur Intel Core E9-10-09020X, et les résultats de ceux-ci sont discutés. La mise à l'échelle en points N pour les GPU Nvidia A100 et RTX 380 et la mise à l'échelle des points de données et des fonctionnalités pour le GPU AMD Radeon Pro 7 sont examinées, et il a été constaté que les durées d'exécution augmentent de manière similaire avec le nombre de points de données sur les deux NVIDIA GPU. Parmi ceux-ci, Cuda s'avère être le backend le plus rapide suivi par OpenCL, et le modèle de ligne de toit généré avec le calcul N-site a montré que les formulations hiérarchiques du noyau ont tendance à être plus liées à la mémoire que leurs homologues de la gamme ND. Dans l'ensemble, les temps d'exécution d'AMD sont supérieurs à ceux de NVIDIA.
  
  
• 00:15:00 Dans cette section, la vidéo traite de la comparaison des performances de SYCL, OpenCL, CUDA et OpenMP sur différentes plates-formes matérielles. Les GPU Nvidia n'ont montré aucune augmentation du temps d'exécution et le backend le plus rapide était OpenCL. Cependant, le GPU AMD a eu des performances moins bonnes que prévu, peut-être en raison du fait que les tailles de blocage n'ont pas été ajustées avec précision. Le processeur Intel Core E9 avait un comportement similaire aux GPU Nvidia, OpenCL étant le backend le plus rapide. DPC++ était le plus rapide, sauf pour les petits ensembles de données où OpenMP était plus rapide. La formulation du noyau hiérarchique DPC++ était plus lente que son homologue de la gamme indépendante sur toutes les plates-formes matérielles, indiquant un potentiel d'optimisation. Enfin, la surcharge de compilation de triche OpenCL était la plus rapide sur les GPU Nvidia et la plus lente sur le GPU Intel Iris Xe Max, mais avec la mise en cache intégrée, la surcharge peut être réduite lors des exécutions ultérieures.
  
  
• 00: 20: 00 Dans cette section de la transcription, le présentateur discute des résultats de ses tests sur divers langages et cadres de programmation parallèles pour cibler le matériel de différents fournisseurs, tels que NVIDIA, AMD et Intel. Ils notent que si vous n'avez besoin que de cibler les GPU NVIDIA, CUDA reste la meilleure option, car il a obtenu les performances les plus rapides lors de leurs tests. Pour cibler uniquement les CPU, OpenMP est un bon début, même s'il n'a pas eu les meilleures performances lors de leurs tests. Si vous devez cibler du matériel de différents fournisseurs, OpenCL ou SYCL est recommandé, bien que SYCL soit préférable si vous implémentez un nouvel algorithme à partir de zéro, car il est plus convivial. Hipsicle est la meilleure option pour une utilisation bon marché et plus rapide que DPC++ et OpenCL sur les GPU, et ils prévoient d'optimiser leur backend OpenMP et d'étudier d'autres implémentations de signaux comme ComputeCPP à l'avenir.
  
  
• 00: 25: 00 Dans cette section, l'orateur conclut la vidéo en discutant des travaux futurs et des améliorations de leur mise en œuvre de la classification des vecteurs de support à l'aide de divers cadres de calcul parallèle. Ils prévoient d'étudier les performances sur différents matériels tels que les FPGA, d'ajouter la prise en charge des systèmes distribués via les MPI et d'explorer l'impact de l'utilisation de calculs de précision mixtes et de matériel spécial d'apprentissage automatique comme les cœurs de tenseur de NVIDIA. Ils pensent que ces améliorations augmenteront la vitesse et l'efficacité de leur mise en œuvre sur des ensembles de données plus importants.

[MetaQuotes]

Atteindre un C++ encore plus riche dans les noyaux OpenCL avec l'utilisation de libclcxx ( WOCL / SYCLcon 2022 )

Atteindre un C++ encore plus riche dans les noyaux OpenCL avec l'utilisation de libclcxx

La vidéo traite de l'utilisation de libclcxx pour permettre l'intégration des bibliothèques C++ dans le développement du noyau open source. Le projet intègre des traits de type, une bibliothèque essentielle pour la méta programmation en C++, dans le but d'exposer davantage de fonctionnalités C++ aux développeurs. La vidéo montre comment la bibliothèque de traits de type peut optimiser les performances des noyaux OpenCL grâce à sa capacité à manipuler l'espace d'adressage et les types de vecteurs. La vidéo encourage les développeurs à expérimenter avec la bibliothèque et à contribuer à réduire les cycles de développement tout en obtenant une compatibilité maximale avec C++. La bibliothèque fournit une documentation Oxygen dans un style similaire aux pages de référence C++, ce qui permet aux développeurs de naviguer facilement dans les nouvelles fonctionnalités.

• 00:00:00 Dans cette section, Stulova d'Anastasia discute de l'utilisation de lipclcxx pour permettre l'utilisation des bibliothèques C++ dans le développement du noyau open source. Bien que le langage du noyau C++ pour OpenCL ait des capacités C++, il ne prend pas en charge les bibliothèques, ce qui rend important de remédier à la limitation présentée. En conséquence, le projet leap clcxx a été créé, intégrant lipcxcxx, dans le but d'exposer davantage de fonctionnalités C++ aux développeurs de noyau open source. De plus, Tulva soutient que les types de traits sont une bibliothèque essentielle pour faciliter pleinement la méta-programmation en C++, et étend l'espace de noms std pour fournir des spécialisations pour les traits existants tout en ajoutant de nouveaux traits pour le type de vecteur à cellule ouverte, entre autres. La nouvelle bibliothèque fournit une documentation Oxygen dans un style similaire aux pages de référence C++, ce qui permet aux développeurs de naviguer plus facilement dans la nouvelle fonctionnalité.
  
  
• 00:05:00 Dans cette section, la vidéo explique comment l'utilisation de la bibliothèque de traits de type peut améliorer les performances des noyaux OpenCL, en particulier en ce qui concerne l'espace d'adressage et les échanges de vecteurs. La vidéo fournit des exemples montrant comment la bibliothèque peut être utilisée pour créer une fonction de modèle pour différents types de pointeurs, et comment la suppression de l'espace d'adressage du type peut résoudre des problèmes dans l'environnement OpenCL. De plus, la vidéo montre comment l'inclusion d'échanges de taille de vecteur peut rendre les calculs plus efficaces et met en évidence comment la mise en œuvre d'algorithmes de réduction peut être adaptée aux types de vecteurs. Dans l'ensemble, l'utilisation d'échanges de types dans les noyaux OpenCL peut conduire à une programmation C++ encore plus riche.
  
  
• 00:10:00 Dans cette section, l'orateur explique comment définir la fonction d'ajout d'alarmes dans les noyaux OpenCL en utilisant la taille du vecteur comme condition. Ils précisent que pour différentes tailles de vecteurs, une implémentation différente est choisie, et si le type transmis n'est pas un type vectoriel, un élément du tampon sera renvoyé. Le conférencier invite également les développeurs à expérimenter et à contribuer et à obtenir le maximum de compatibilité avec C++ pour réduire les cycles de développement. Ils demandent des commentaires sur les fonctionnalités manquantes ou les bogues et encouragent à rejoindre une discussion sur un problème existant sur la page du projet.

[MetaQuotes]

SYCL au-delà d'OpenCL : l'architecture, l'état actuel et l'orientation future de hipSYCL ( IWOCL / SYCLcon 2020 )

SYCL au-delà d'OpenCL : l'architecture, l'état actuel et l'orientation future de hipSYCL

Le projet hipSYCL est une implémentation open source de SYCL qui cible les GPU via le modèle de programmation HIP au lieu d'OpenCL. Il se compose d'un composant compilateur, d'une interface faucille et d'un environnement d'exécution sécurisé. Le compilateur sécurisé identifie les noyaux, gère l'allocation de mémoire locale et implémente un mécanisme de signalisation. La fonction de répartition crée des éléments spécifiques basés sur des noyaux fournis par l'utilisateur, et des fonctions optimisées peuvent être définies avec rock prim. L'orientation future consiste à autoriser plusieurs back-ends et à supprimer les restrictions sur le modèle de compilation statique. Le modèle de soumission d'opérations est en train de passer à une soumission par lots pour un débit de tâches plus élevé, et hipSYCL est interopérable au niveau du code source, permettant le mélange et la correspondance avec hip et CUDA. En tant que projet open-source, les contributeurs sont les bienvenus.

• 00: 00: 00 Dans cette section, l'orateur discute de la motivation derrière le projet hipSYCL, qui est une implémentation SYCL open source qui cible directement les GPU via le modèle de programmation HIP au lieu d'utiliser OpenCL. L'objectif est d'optimiser le code et de faciliter l'utilisation des profileurs et des débogueurs fournis par les fournisseurs tout en évitant les frictions d'adoption qui peuvent survenir avec d'autres modèles de programmation. L'orateur compare également hipSYCL à d'autres solutions disponibles pour l'interopérabilité SYCL et CUDA, plaçant hipSYCL à l'extrémité de l'échelle d'interopérabilité CUDA en raison de son utilisation du modèle de programmation HIP.
  
  
• 00:05:00 Dans cette section, la vidéo explique le fonctionnement de hipSYCL et ses trois composants principaux : un composant compilateur, une interface faucille et un environnement d'exécution sécurisé. Le composant compilateur permet au compilateur de comprendre à la fois CUDA et faucille, ce qui permet d'avoir une interopérabilité au niveau du code source. Le runtime sécurisé s'occupe de la gestion des données et de la planification des tâches, tandis que l'interface faucille se compose de classes et de fonctions dans l'espace de noms faucille. De plus, la vidéo mentionne que la faucille est une solution flexible qui peut être utilisée pour créer des implémentations qui couvrent tous les cas d'utilisation possibles. Pour cibler les accélérateurs, un composant de compilateur dédié est nécessaire, qui identifie les noyaux et les compile pour l'accélérateur.
  
  
• 00: 10: 00 Dans cette section de la vidéo, l'orateur explique comment fonctionne le compilateur sécurisé dans hipSYCL. Ils expliquent que le compilateur doit identifier les noyaux et déterminer quel code doit être émis vers le périphérique, puis gérer la façon dont les noyaux sont alloués dans la mémoire locale. La fonctionnalité de diagnostic spécifique à la faucille est également mentionnée comme une priorité pour le développement futur. L'orateur explique que l'utilisation du composant de compilateur sécurisé hip est relativement simple avec l'utilisation d'un wrapper de compilateur appelé Cycle CC, qui cache la complexité impliquée, comme l'invocation et la liaison correcte du compilateur, et comment définir les chemins d'inclusion. Ils discutent de la façon dont l'invocation des noyaux nécessite un peu de ruse et expliquent comment cela se fait. De plus, le mécanisme de signalisation utilisant actuellement les événements Coroutines et Hip est utilisé dans hipSYCL pour le traitement dynamique dans le désordre, mais l'inconvénient de cela est discuté.
  
  
• 00: 15: 00 Dans cette section, l'orateur explique comment la fonction de répartition est utilisée pour créer un élément spécifique basé sur le noyau fourni par l'utilisateur et comment le parallèle pour et sécurisé peut être implémenté en instanciant la fonction de répartition avec la fonction fournie par l'utilisateur. noyau. Cependant, initialement, tout le code est transmis en tant que code hôte, où le noyau fourni par l'utilisateur est un lambda hôte et ne peut pas être invoqué directement, ils ajoutent donc un attribut factice appelé noyau HIP, qui ne sera remplacé que par un clic approprié sur l'attribut une fois que l'analyse initiale est terminée et que le plug-in hipSYCL a pris le relais. Ils atteignent de bonnes performances de mémoire pour hipSYCL et CUDA, et en utilisant hipSYCL, ils peuvent atteindre l'interopérabilité hip et CUDA au niveau du code source.
  
  
• 00: 20: 00 Dans cette section, l'orateur explique comment mettre en œuvre une réduction optimisée à l'aide de rock prim avec epsilon. Ils suggèrent de définir une fonction optimisée avec la plate-forme sécurisée macro zip cuda ou hanches une bonne plate-forme rockem, qui est marquée comme hôte et périphérique. En cas de compilation pour la plate-forme cible, la fonction optimisée est appelée, tandis qu'une fonction de secours est appelée dans le cas contraire. L'orateur explique que les bibliothèques optimisées par le fournisseur comme rock prim atteignent des performances plus rapides car elles ont plus de connaissances sur le matériel cible, et bien que hipSYCL soit toujours pré-conforme et manque quelques fonctionnalités comme les images et l'interopérabilité à l'état ouvert, il est toujours utilisable pour de vrai -applications mondiales. Cependant, une chute parallèle organisée sur le pack CPU est lente en raison d'un problème avec les implémentations de cycle de bibliothèque pur.
  
  
• 00: 25: 00 Dans cette section, l'orateur discute des différences de performances en utilisant la forme parallèle de base ou la forme parallèle hiérarchique par rapport à l'utilisation de la forme parallèle nd range avec hipSYCL sur un CPU. Cette dernière entraîne une perte de performance massive car elle nécessite de lancer autant de menaces qu'il y a d'éléments de travail dans chaque groupe de travail. L'orateur parle ensuite de l'orientation future de hipSYCL, qui consiste à créer un nouveau runtime qui permet à des backends arbitraires d'être actifs simultanément et supprime les restrictions concernant le modèle de compilation statique. Ils sont également en train de passer à un mappage de bout en bout où n cyclique utilise le mappage vers M files d'attente principales pour optimiser l'utilisation du matériel. De plus, il y aura une séparation stricte entre le nouveau runtime et l'interface SYCL existante pour faciliter la maintenance et l'expérimentation.
  
  
• 00:30:00 Dans cette section, l'orateur discute des améliorations apportées au modèle de soumission d'opérations dans hipSYCL. Ils passent d'un modèle de soumission basé sur des signaux à un modèle de soumission par lots, où la signalisation au runtime que les choses sont terminées ne se produit qu'une seule fois par lot d'opérations, ce qui permet un débit de tâche plus élevé. L'orateur explique le processus par lequel les opérations sont soumises puis traitées par le constructeur de ponts, qui les collecte et les commande. Le planificateur de pont attribue ensuite des repères d'exécution aux opérations, qui vont ensuite aux exécuteurs principaux pour exécuter le noyau et déterminer quelles opérations de synchronisation sont nécessaires. Le devis de cette configuration remonte ensuite au deck scheduler pour optimiser davantage ou soumettre les opérations telles quelles. L'orateur fournit également des informations sur la façon d'obtenir hipSYCL via leurs référentiels de packages et leurs scripts d'installation.
  
  
• 00:35:00 Dans cette section, il est expliqué que hipSYCL est une implémentation de SICL pour les CPU, les GPU vidéo et les GPU AMD. Il est construit au-dessus des API de fournisseur de bas niveau hip et CUDA, ce qui le rend interopérable au niveau du code source. Cela permet aux développeurs de combiner hip et CUDA, ce qui le rend adapté à une gamme de cas d'utilisation HPC et autres qui nécessitent un accès aux dernières optimisations matérielles de bas niveau ou aux bibliothèques optimisées par les fournisseurs. De plus, il permet la création de chemins de code hautement optimisés pour un matériel spécifique, et les performances du noyau devraient être au même niveau que celles de hip ou CUDA standard. En tant que projet open source, les contributeurs sont toujours les bienvenus et les personnes intéressées peuvent en savoir plus sur la page GitHub.

[MetaQuotes]

SYCL : le futur est ouvert, parallèle et hétérogène (Core C++ 2022 )

SYCL : le futur est ouvert, parallèle et hétérogène

Dans cette vidéo sur la programmation SYCL, l'orateur souligne la nécessité d'augmenter le niveau d'abstraction pour augmenter la productivité et attirer davantage de développeurs, car les modèles complexes nécessitent une puissance de calcul accrue, qui est satisfaite par les systèmes d'accélérateurs. L'importance de la portabilité logicielle et de OneAPI est soulignée, car elle permet aux appareils de fonctionner sur des CPU, des GPU et d'autres appareils. Les avantages de SYCL, un modèle de programmation ouvert, parallèle et hétérogène, sont également abordés, le conférencier soulignant les nombreuses ressources et outils en ligne disponibles pour optimiser le code et améliorer les performances. L'orateur encourage les téléspectateurs à visiter oneapi.io et leur chaîne YouTube pour obtenir des ressources et de l'assistance.

• 00:00:00 Dans cette section, l'orateur discute de la nécessité de monter le niveau d'abstraction pour augmenter la productivité et attirer plus de développeurs. À mesure que les modèles deviennent plus complexes, la demande de puissance de calcul augmente rapidement. L'orateur évoque le ninja gap, qui fait référence à la difficulté de trouver et d'embaucher des experts de niveau inférieur tels que des développeurs d'assemblage ou de Cuda. Monter le niveau d'abstraction entraîne une perte de performances, c'est pourquoi les accélérateurs d'IA tels que les GPU et GAUDI sont nécessaires pour répondre à la demande croissante de puissance de calcul.
  
  
• 00: 05: 00 Dans cette section, l'orateur discute de la nécessité d'avoir des accélérateurs pour atteindre les performances les plus rapides, mais note qu'un accélérateur n'est pas suffisant pour couvrir toute la gamme des applications. Des systèmes hétérogènes sont nécessaires, combinant des processeurs et des accélérateurs tels que des accélérateurs et des processeurs de type ASIC. Le conférencier souligne l'importance de la portabilité des logiciels et la capacité du code à s'exécuter sur n'importe quelle machine ou appareil, quel que soit le matériel utilisé, sans avoir besoin de recoder, recompiler ou reconstruire pour chaque plate-forme ou système d'exploitation. OneAPI est un effort de l'industrie pour rationaliser les piles logicielles, en unifiant les bibliothèques et les outils pour assurer une portabilité logicielle ouverte, gratuite et multi-appareils, ce qui signifie que les piles logicielles peuvent fonctionner sur les CPU, les GPU et d'autres appareils. OneAPI propose une boîte à outils de base qui contient tout le nécessaire pour démarrer.
  
  
• 00: 10: 00 Dans cette section, l'orateur discute de la puissance de l'utilisation de la boîte à outils basée sur OneAPI et du concept du compilateur Data Policy ++, conçu pour ajouter de l'hétérogénéité aux bibliothèques C ++. En utilisant des politiques prédéfinies, vous pouvez facilement accéder au CPU ou au GPU sans avoir besoin d'en savoir trop sur les détails de niveau inférieur concernant OpenCL ou CUDA. Le compilateur offre la possibilité de contrôler et de séparer les mémoires omniprésentes, de gérer les codes d'exception et de créer un calcul parallèle.
  
  
• 00:15:00 Dans cette section de la vidéo, l'orateur explique que pour avoir de bonnes capacités de calcul hétérogène, trois choses sont nécessaires. Le premier est la possibilité de découvrir l'appareil et d'obtenir des informations à son sujet. C'est là que le haut-parleur affiche un simple morceau de code qui détecte et répertorie tous les appareils connectés au système. La deuxième exigence concerne les informations sur l'état des appareils en temps réel, ce qui permet de surveiller l'utilisation et la température, et permet également aux utilisateurs de basculer entre le CPU et le GPU. La troisième exigence est la capacité d'échanger de la mémoire de manière efficace et transparente entre l'appareil et l'hôte, ce qui est réalisé de deux manières principales dans SYCL : les tampons et la mémoire graphique unifiée.
  
  
• 00:20:00 Dans cette section, l'orateur explique les avantages de l'utilisation de SYCL, un modèle de programmation ouvert, parallèle et hétérogène. En ajoutant SYCL à C++, on peut écrire du code qui peut s'exécuter sur plusieurs appareils, y compris les GPU, les CPU, les ARM et les FPGA. L'orateur mentionne qu'il existe de nombreuses ressources en ligne et des exemples sur la façon de faire fonctionner SYCL avec plusieurs appareils. Intel Advisor est un outil recommandé par le conférencier, qui peut aider à optimiser le code et offre la possibilité de décharger des fonctions spécifiques sur un GPU. L'orateur souligne l'importance d'utiliser cet outil, qui peut rendre le code beaucoup plus rapide et améliorer les performances globales du programme.
  
  
• 00: 25: 00 Dans cette section, l'orateur promeut l'utilisation de SYCL comme le moyen le plus rapide de rendre le code disponible sur plusieurs appareils par plusieurs fournisseurs, et encourage les téléspectateurs à visiter le site Web oneapi.io et sa chaîne YouTube pour obtenir des ressources et une assistance. Il mentionne également la possibilité que SYCL soit plus rapide que CUDA dans certains exemples, mais souligne que le principal avantage de SYCL est sa portabilité, car il permet de coder sur une seule plate-forme qui peut ensuite fonctionner sur divers appareils, libérant ainsi le besoin de créer plusieurs décisions de codage pour différents appareils. De plus, le conférencier propose de répondre à toutes les questions et de fournir des ressources, telles que des ordinateurs portables Jupyter et l'accès à Intel Devcloud, pour aider les utilisateurs à démarrer avec SYCL.

[MetaQuotes]

Accélération GPU en Python

Accélération GPU en Python

La vidéo explique comment obtenir une accélération GPU dans la programmation Python en tirant parti de la puissance des unités de traitement graphique, qui peuvent fournir une accélération jusqu'à 10x avec le parallélisme des données. Les deux normes de calcul GPU, OpenCL et CUDA, sont brièvement présentées, et la vidéo montre l'utilisation de Pi OpenCL et CUDA pour la multiplication matricielle en Python. L'orateur explique l'utilisation de la mémoire globale et du noyau pour la multiplication matricielle, et discute également de l'algorithme utilisé pour calculer un élément dans le produit matrice-matrice. Le code pour l'accélération GPU en C et Python est discuté, en mettant l'accent sur la compréhension des représentations internes des matrices et de l'allocation de mémoire. Les exercices de la conférence fournissent une base pour une exploration plus approfondie de l'informatique GPU.

• 00: 00: 00 Dans cette section, la vidéo présente l'informatique GPU comme moyen d'atteindre le parallélisme des données et d'accélérer les programmes en tirant parti de la puissance des unités de traitement graphique, qui peuvent traiter des milliards d'opérations en virgule flottante par seconde et fournir une accélération d'un facteur de 10. Les deux normes de calcul GPU, OpenCL et CUDA, sont brièvement présentées, avec des exemples de GPU haut de gamme tels que Kepler, Pascal et Volta de Nvidia. L'aspect massivement parallèle de l'informatique GPU est souligné comme un moyen de garder le GPU occupé, avec la planification d'un nombre suffisant de threads souvent requis. La vidéo mentionne également les applications potentielles des accélérateurs matériels dans les domaines scientifiques et techniques.
  
  
• 00:05:00 Dans cette section de la vidéo, l'orateur évoque l'évolution de l'accélération GPU, de Kepler qui avait une performance de pointe d'un téraflop à la génération actuelle qui dépasse 7,9 téraflops. Le modèle de programmation du calcul massivement parallèle suit une approche de données multiples à instruction unique et les données sont divisées en blocs de threads et chaque bloc exécute au moins un thread. L'orateur aborde le langage informatique ouvert qui est une norme ouverte pour la programmation parallèle et couvre l'informatique multicœur et multithread en plus de l'informatique GPU.
  
  
• 00: 10: 00 Dans cette section, l'orateur discute de l'utilisation d'OpenCL et de Pi OpenCL pour l'accélération GPU en Python. OpenCL est une norme générale qui était à l'origine prise en charge sur les cartes graphiques NVIDIA mais qui a été abandonnée. Cependant, cela fonctionne bien sur les MacBook car il a été initié par Apple. Pi OpenCL simplifie la programmation OpenCL en réduisant le code passe-partout et en permettant de se concentrer plus facilement sur le noyau. Il prend également en charge les tableaux NumPy, mais les structures de données sont plus limitées en raison du parallélisme des données. L'orateur démontre l'utilisation de Pi OpenCL pour la multiplication matricielle sur deux matrices entières à des fins de test.
  
  
• 00: 15: 00 Dans cette section, l'orateur explique comment les GPU peuvent être utilisés pour la multiplication matricielle en Python à l'aide d'OpenCL. Ils commencent par importer les bibliothèques nécessaires, y compris OpenCL et NumPy. L'orateur note également que la carte graphique utilisée ne supportait pas l'arithmétique 64 bits, ils ont donc opté pour l'arithmétique 32 bits à virgule flottante. Ils définissent ensuite les matrices, génèrent des entiers aléatoires et changent leur type en une matrice de flux 32 bits. L'orateur explique ensuite le code passe-partout requis pour définir les contreparties des matrices sur l'appareil et créer des files d'attente. Enfin, l'orateur définit le noyau pour la multiplication matricielle, qui est compilé lors de l'exécution du programme, et montre comment multiplier des matrices sur le GPU.
  
  
• 00:20:00 Dans cette section, l'orateur explique le concept de "global" dans le contexte de l'accélération GPU en programmation Python. Global indique que les matrices résident dans la mémoire globale de la carte graphique, permettant à chaque thread d'accéder aux données. Les dimensions sont transmises sous forme d'entiers courts, chaque thread ayant un numéro d'identification unique. Le processus de multiplication matricielle bénéficie de l'accélération GPU car presque chaque partie peut être effectuée indépendamment grâce à l'indexation des lignes et des colonnes de la matrice. Les matrices sont stockées dans C-wise, sous la forme d'un long tableau, et les pointeurs déterminent leurs emplacements en mémoire.
  
  
• 00: 25: 00 Dans cette section, l'orateur explique l'algorithme en C pour calculer un élément dans le produit matrice-matrice et l'accélération potentielle de la multiplication matrice-matrice, qui est généralement une opération cubique dans les dimensions des matrices. Cependant, avec l'utilisation de GPU et de lancements de noyaux, l'opération peut être simplifiée en une opération linéaire, entraînant une réduction massive des coûts et des accélérations significatives. L'orateur mentionne également que si la manière la plus simple d'effectuer l'opération est via Python et sans avoir besoin de compiler explicitement, les algorithmes réels utilisés dans les supercalculateurs utilisent des mémoires partagées sur les GPU et un processus de compilation qui va au-delà de ce qui est discuté dans le vidéo. L'orateur insiste sur l'idée que PiCUDA et PiOpenCL permettent aux programmeurs de développer du code à un niveau supérieur, sans avoir à se soucier des processus de compilation et de liaison de niveau inférieur.
  
  
• 00:30:00 Dans cette section, la vidéo parle de l'installation de CUDA pour l'accélération GPU en Python. Pour utiliser CUDA, un utilisateur doit avoir installé un GPU NVIDIA et des pilotes. La conférence passe en revue les instructions pour vérifier si le système est correctement configuré, et le présentateur note que la technique est un calcul parallèle hautement interactif. Le conférencier explique que l'on peut obtenir de bonnes performances avec un ordinateur portable haut de gamme avec une bonne carte graphique. Le cours présente ensuite la multiplication matricielle à titre d'exemple. Le présentateur note qu'il faut généralement avoir un programme en cours d'exécution sur le CPU, et le GPU n'accélère que les parties qui nécessitent beaucoup de calculs. Enfin, la conférence traite de l'allocation de mémoire pour les matrices correspondantes sur le GPU et de l'initialisation des matrices résultantes, indiquant que les allocations avec NumPy sont meilleures qu'elles ne le seraient avec C. De plus, aucune compilation n'est nécessaire à ce stade.
  
  
• 00:35:00 Dans cette section, le code pour l'accélération GPU en C est discuté. Les matrices en C sont stockées ligne par ligne, et le code exploite ce fait. La syntaxe de lancement de blocs de threads dans une structure à deux dimensions est utilisée pour calculer explicitement les threads. Une boucle avec des crochets explicites est utilisée pour éviter l'arithmétique des pointeurs. La fonction prend les dimensions et les pointeurs vers les données, qui incluent les matrices A et B pour l'entrée et la matrice de résultat C_gpu. La copie de la mémoire vers l'appareil doit se terminer avant l'impression, et la copie de la mémoire vers l'hôte doit être effectuée avant l'impression des données, car l'impression dans les fonctions des fonctions du noyau exécutées par le GPU peut ne pas être possible. Enfin, la discussion se termine en indiquant que pyCUDA est plus récent que piOpenCL et PyCUDA.
  
  
• 00: 40: 00 Dans cette section, l'orateur discute de l'accélération GPU en Python, qui est orientée vers CUDA mais a également des efforts en cours pour fonctionner sur d'autres GPU. Il prend en charge à la fois la compilation et l'exécution, ce qui rend les exécutions ultérieures beaucoup plus rapides. Il est possible de développer des noyaux GPU en Python tout en restant dans l'environnement de script ; cependant, il faut comprendre comment fonctionnent les GPU et comment les matrices sont représentées en interne à l'aide de la syntaxe C. Les exercices du cours magistral sont ouverts et peuvent servir de base à un deuxième projet explorant le calcul GPU. Dans l'ensemble, il s'agissait d'une section d'introduction qui visait à donner une idée de la façon dont les programmeurs et les développeurs de logiciels peuvent développer des fonctions qui s'exécutent sur le GPU.

[MetaQuotes]

Présentation de lancement OpenCL 3.0 (IWOCL / SYCLcon 2020)

Présentation du lancement d'OpenCL 3.0

Le lancement d'OpenCL 3.0 est discuté dans cette vidéo, en mettant l'accent sur son importance pour la programmation parallèle de bas niveau dans l'industrie. OpenCL 3.0 n'ajoute pas de nouvelles fonctionnalités à l'API, mais fournit un réalignement de l'écosystème pour permettre à OpenCL d'atteindre plus de développeurs et d'appareils. Le présentateur discute également de l'ajout d'extensions pour les processeurs légers DSP, de la feuille de route pour les fonctionnalités futures et de l'écosystème croissant de compilateurs de langage de noyau open source qui peuvent générer des noyaux spirituels pour OpenCL Vulcan. Les commentaires des utilisateurs sont encouragés pour aider à finaliser la spécification alors que le groupe de travail se prépare pour la première vague d'implémentations au cours des prochains mois.

• 00:00:00 Dans cette section, Neil Travis de NVIDIA et du groupe Khronos discute du lancement d'OpenCL 3.0 et de l'importance de la norme pour la programmation parallèle de bas niveau dans l'industrie. OpenCL est largement utilisé par les fournisseurs de GPU et de plus en plus utilisé par les applications, les moteurs et les bibliothèques. Le lancement d'OpenCL 3.0 fournit un réalignement de l'écosystème plutôt que d'ajouter de nouvelles fonctionnalités à l'API dans le but de permettre à OpenCL d'atteindre encore plus de développeurs et d'appareils. OpenCL 3.0 rend toutes les fonctionnalités 2x plus qu'optionnelles, permettant aux fournisseurs de se concentrer sur la livraison des fonctionnalités dont ils ont besoin pour leurs clients, et réinitialise la possibilité de relever la barre des fonctionnalités de base.
  
  
• 00: 05: 00 Dans cette section, il est expliqué qu'OpenCL 3.0 est une nouvelle spécification livrée avec une API unifiée conçue pour interroger toutes les fonctionnalités d'OpenCL 2.x avec des extensions supplémentaires pour les processeurs légers DSP afin de transférer des données 2D et 3D entre global et mémoires locales de manière flexible et asynchrone via des transactions d'accès direct à la mémoire (DMA). Bien qu'OpenCL 3.0 n'inclue pas la spécification OpenCL C++, d'autres implémentations sont encouragées à utiliser le compilateur frontal open source C++ pour OpenCL pour générer des noyaux Spir-V en mélangeant OpenCL C avec une grande partie de C++17. La feuille de route pour OpenCL comprend la livraison de nouvelles fonctionnalités en tant qu'extensions en premier lieu pour l'adoption par l'industrie, leur permettant de mûrir et d'être éprouvées avant de les intégrer dans les futures spécifications de base. Le groupe de travail OpenCL considère également les profils comme un outil essentiel pour équilibrer la flexibilité de mise en œuvre avec la portabilité des applications et éviter la fragmentation pour les marchés cibles.
  
  
• 00: 10: 00 Dans cette section, le présentateur discute de l'écosystème croissant de compilateurs de langage de noyau open source, qui comprend clang et lvm, qui peuvent générer des noyaux spirituels pour OpenCL Vulcan, ou pour une traduction supplémentaire en shaders à exécuter sur d'autres API telles que comme métal. Cela permettrait aux applications OpenCL sur les plates-formes Apple sans avoir besoin d'utiliser les pilotes OpenCL. Le présentateur mentionne également le projet OpenCL 12, qui traduit les spirit kernels générés par LLVM à l'aide d'un pipeline de conversion open source vers DXi L, permettant aux compilateurs de langage d'innover indépendamment des runtimes. La spécification d'OpenCL 3 est provisoire et les commentaires des utilisateurs sont encouragés pour aider à finaliser la spécification alors que le groupe de travail se prépare pour la première vague d'implémentations au cours des prochains mois.