Archived: Relever les défis de la programmation multicœur avec LabVIEW

NI does not actively maintain this document.

This content provides support for older products and technology, so you may notice outdated links or obsolete information about operating systems or other relevant products.

Aperçu

Cet article aborde plusieurs défis auxquels sont confrontés les programmeurs multicœurs et souligne les caractéristiques de l'environnement de programmation graphique LabVIEW 8.5 de National Instruments, conçu pour simplifier la programmation multicœur pour les ingénieurs, les scientifiques et les concepteurs de systèmes graphiques. Plus spécifiquement, cet article traite de la conception des architectures des applications parallèles, de la gestion de la synchronisation des threads et du débogage des programmes multicœurs.

Contenu

 

L’avenir de la technologie multicœur

Des années durant, les fabricants ont amélioré les performances des microprocesseurs en augmentant la vitesse d'horloge. Toutefois, la dernière évolution de la technologie des processeurs est le multicœur. Fondamentalement, cela signifie que les fabricants intègrent plusieurs microprocesseurs sur un seul circuit intégré. Oubliez les ordinateurs double cœur et quadricœurs actuellement disponibles sur le marché : Intel a annoncé un ordinateur doté de 80 cœurs d'ici cinq ans.

Figure n°1 : Le Directeur Général Paul Otellini présente le prototype doté de 80 cœurs d'Intel (Photo de slashgear.com)

Cela semble presque trop beau pour être vrai : une augmentation des performances apparemment sans limite permettant d'exécuter les applications les plus exigeantes. Et avec cette augmentation formidable, imaginez avec quelle rapidité les programmes existants vont s'exécuter. Vous pourriez soupçonner que cela n'est pas aussi simple qu'il y paraît ; et vous auriez raison.

Programmer des applications de façon à ce qu'elles s'exécutent sur des processeurs multicœurs est plus complexe que programmer celles destinées aux processeurs dotés d'un seul cœur. Si plusieurs applications peuvent aisément s'exécuter sur differents cœurs, il est nécessaire de coder méticuleusement les applications pour tirer parti de la technologie multicœur. Ce qui signifie que les performances des applications existantes ne connaissent probablement que peu d'amélioration, voire aucune, avec une exécution sur un ordinateur multicœur moderne.

Concevoir du code parallèle

Le principal défi de la programmation d'une application parallèle consiste à identifier quelles sections d'un programme donné peuvent véritablement s'exécuter en parallèle, et à implémenter ensuite ces sections dans le code. Nous pouvons appeler chaque portion de code capable de s'exécuter en parallèle avec un autre thread ; de ce fait, une application entièrement parallèle peut être qualifiée de multithread.

Par le passé, les programmeurs textuels devaient définir de manière explicite ces threads dans leurs applications en utilisant des API telles que OpenMP ou POSIX. Étant donné que la programmation textuelle est séquentielle par nature, il est difficile de visualiser le parallèlisme dans une portion de code multithread. En revanche, en mettant à profit la nature graphique de NI LabVIEW, les programmeurs peuvent aisément visualiser et programmer des applications parallèles. De plus, LabVIEW génère automatiquement les threads pour les sections de code parallèles, de sorte que les ingénieurs et les scientifiques avec peu de connaissances en programmation, voire aucune, peuvent consacrer davantage de temps à la résolution de problèmes et moins de temps à se soucier de l'implémentation bas niveau de leurs applications.


Figure n°2 : comparaison du multithreading dans LabVIEW et les langages textuels

Synchronisation des threads

Découvrons le deuxième défi de la programmation multicœur : la synchronisation des thread. Avec des dizaines, voire des centaines de threads qui s'exécutent dans une application donnée, il nécessaire de s'assurer que tous fonctionnent correctement ensemble. Par exemple, si deux threads, voire davantage, tentent d'accéder à un emplacement de la mémoire en même temps, cela risque de provoquer une corruption des données. En clair, identifier toutes les portions de code susceptibles de rentrer en conflit dans une application est une tâche impressionnante.

Cependant, en créant graphiquement un diagramme dans LabVIEW, vous pouvez rapidement mettre en œuvre une tâche spécifique sans prendre en compte la synchronisation des threads. La Figure n°2 illustre une application dans laquelle les deux sections parallèles d'un code graphique accèdent à un disque dur lors de l'écriture d'un fichier. LabVIEW traite automatiquement la synchronisation des threads.



Figure n°3 : application simple illustrant la synchronisation automatique des threads dans LabVIEW

Débogage

La plupart des programmes ne fonctionnent pas parfaitement dès leur première exécution. Ceci est vrai aussi bien pour les applications monocœurs que pour les applications multicœurs. Afin de déterminer de manière logique où se produisent d'éventuelles erreurs fonctionnelles dans une portion de code donnéé, l'utilisateur doit compter sur les outils de débogage de l'environnement de développement pour produire le bon comportement.

Le débogage constitue un défi particulier dans les applications multicœurs. Il est non seulement nécessaire de tracer l'exécution de deux portions de code en même temps, mais aussi de déterminer quelle partie du code est en cours d'exécution sur quel processeur. De plus, si l'utilisateur programme fréquemment des applications multithreads, il doit gérer les problèmes d'insuffisance des ressources et de permutation des threads, qui doivent être identifiés durant le processus de débogage.

LabVIEW comporte plusieurs caractéristiques qui simplifient considérablement la mise au point des applications multicœurs. L'utilisateur peut, tout particulièrement, utiliser la fonction Animer l'exécution pour visualiser rapidement et facilement l'exécution parallèle d'un programme (LabVIEW repose par nature sur le flux de données). Par exemple, observons l'application simple de la Figure n°3. Lorsque Animer l'exécution est activé, il est facile de visualiser les sections parallèles de code en train de s'exécuter.

 



Figure n°4 : animation de l'exécution graphique dans l'environnement de développement LabVIEW

En outre, le Module LabVIEW Real-Time offre à la fois une exécution déterministe sur les machines multicœurs et des informations complètes de débogage. Nouveauté de LabVIEW 8.5, Le Toolkit Real-Time Execution Trace permet de visualiser sur quel processeur s'exécute un thread donné et d'identifier rapidement les problèmes tels que les permutations et les manques de ressources des threads.

Figure n°5 : Toolkit LabVIEW 8.5 Execution Trace

Résumé

Pour conclure, les programmeurs experts en multicœur doivent prendre en compte les défis propres au multithreading. Parmi ces défis, citons, de manière non exhaustive, l'architecture des applications parallèles, la synchronisation des threads et le débogage. À l'heure où le nombre de cœurs par processeur augmente, il devient de plus en plus important de recourir à des techniques correctes de programmation parallèle dans les applications multithreads.