Avantages de la programmation graphique dans le LabVIEW de NI

Pour mieux comprendre les avantages de la programmation graphique LabVIEW, voici un rappel de quelques faits marquants de l’histoire du premier langage de programmation haut niveau. Au début de l’ère de l’ordinateur moderne dans les années 50, une petite équipe d’ingénieurs chez IBM décida de créer un nouveau langage, qui serait plus pratique pour programmer l’énorme ordinateur IBM 704 (le super-ordinateur de l’époque), qui remplacerait l’assembleur de bas niveau et deviendrait le langage le plus moderne de son temps. C’est ainsi que FORTRAN vit le jour. C’était un langage de programmation plus facile à lire dont le but principal était d’accélérer le processus de développement.

Dans les premiers temps, les ingénieurs étaient sceptiques et ne croyaient pas que cette nouvelle méthode pouvait surpasser les programmes en assembleur faits à la main. Toutefois, les programmes créés en FORTRAN ont rapidement prouvé qu’ils s’exécutaient presque aussi efficacement que ceux écrits en assembleur. En même temps, FORTRAN réduisait le nombre d’instructions de programmation nécessaires par un facteur de 20, et c’est une des raisons pour laquelle il est souvent considéré comme le premier langage de programmation de haut niveau. Naturellement, FORTRAN a vite conquis la communauté scientifique et reste influent.

Cinquante ans plus tard, il existe toujours des leçons à tirer de cette anecdote. Tout d’abord, pour plus de 50 ans, les ingénieurs n’ont pas cessé de rechercher des façons plus simples et plus rapides de résoudre leurs problèmes par le biais de la programmation. Ensuite, les langages de programmation choisis par les ingénieurs pour traduire leurs tâches ont eu tendance à évoluer vers des niveaux plus abstraits. Ces leçons expliquent en grande partie la popularité et l’adoption généralisée du G depuis son introduction en 1986. Le G représente un langage de programmation d’extrêmement haut niveau qui a pour objectif d’augmenter la productivité de ses utilisateurs tout en exécutant les programmes à quasiment la même vitesse que les langages de niveaux inférieurs tels que FORTRAN, C et C++.

LabVIEW : Programmation graphique par flux de données

LabVIEW se différencie de la plupart des langages de programmation courants par deux caractéristiques essentielles. Premièrement, la programmation en G s’effectue en câblant des icônes graphiques sur un diagramme, lui-même ensuite compilé directement en code machine pour permettre aux processeurs de l’ordinateur de l’exécuter. Bien qu’il soit représenté graphiquement et non textuellement, le G obéit aux mêmes concepts de programmation que la plupart des langages traditionnels. Par exemple, le G inclut tous les éléments de construction standards, tels que types de données, boucles, gestion d’événements, variables, récursivité et programmation orientée objet.

^{Figure 1: En G, une boucle While est représentée de manière intuitive par une boucle graphique qui s’exécute jusqu’à ce qu’une condition d’arrêt soit remplie.}

La seconde différence réside dans le fait que le code G développé avec LabVIEW s’exécute en fonction des règles de flux de données au lieu d’une approche basée sur des procédures plus classiques (en d’autres termes, une série de commandes séquentielles à exécuter), comme c’est souvent le cas avec la plupart des langages de programmation textuels tels que C et C++. Un langage de programmation par flux de données comme celui du G (ou Agilent VEE, Microsoft Visual et Apple Quartz Composer) met les données en valeur en tant que concept clé derrière chaque programme. Les données déterminent l’ordre d’exécution du flux de données. C’est le flux de données entre les nœuds dans le programme, et non pas les lignes séquentielles de texte, qui détermine l’ordre d’exécution.

Cette distinction peut paraître insignifiante au premier abord, mais son impact est décisif car elle attire l’attention du développeur sur les chemins de données entre les différentes parties du programme. Dans un programme LabVIEW, les nœuds (c’est-à-dire les fonctions, structures comme les boucles, sous-programmes, etc.) possèdent des entrées, traitent des données et produisent des signaux en sortie. Dès que les entrées d’un certain nœud reçoivent des données valides, ce nœud s’exécute selon sa logique, produit des données en sortie et transfère les données au nœud suivant dans le chemin du flux de données. Un nœud qui reçoit des données d’un autre nœud ne s’exécute que lorsque le premier nœud a terminé son exécution.

Programmation graphique intuitive

Comme la plupart des gens, les ingénieurs et les scientifiques assimilent les informations en voyant et en traitant des images de manière subconsciente. De nombreux ingénieurs et scientifiques se distinguent également comme étant des « penseurs visuels », de sorte qu’ils sont particulièrement compétents pour organiser les informations par traitement des informations visuelles. En bref, ils pensent mieux à l’aide d’images. Cette capacité est souvent encouragée dans les universités, où les étudiants sont invités à modéliser les solutions aux problèmes sous forme de diagrammes des procédures. De nombreux langages de programmation courants exigent de passer beaucoup de temps à apprendre la syntaxe associée à chaque langage et ensuite à faire correspondre la structure du langage utilisé au problème à résoudre. La programmation graphique en G propose une expérience plus intuitive.

Le code en G permet souvent aux ingénieurs et scientifiques de comprendre aisément et rapidement car ils ont souvent l’habitude de visualiser, et même de produire, des modèles de procédures et de tâches sous forme de diagrammes et d’organigrammes (qui obéissent aux règles des flux de données). De plus, comme les langages de programmation par flux de données exigent de baser la structure de votre programme sur le flux de données, cela vous amène à penser en fonction du problème à résoudre. Par exemple, un programme typique en G est susceptible d’acquérir plusieurs voies contenant des données de température, puis de transférer ces données vers une fonction d’analyse et enfin, d’écrire les données analysées sur disque. Dans l’ensemble, les flux de données et les étapes de ce programme sont faciles à comprendre à l’aide d’un diagramme LabVIEW.

^{Figure 2: Les données proviennent de la fonction d’acquisition et sont ensuite transférées de manière intuitive via les fils de liaison aux fonctions d’analyse et de stockage.}

Outils interactifs de mise au point

Du fait de la simplicité du code G graphique de LabVIEW, les tâches courantes de programmation, telles que la mise au point, deviennent également plus intuitives. Par exemple, LabVIEW fournit des outils uniques de mise au point que vous pouvez utiliser pour vérifier le déplacement interactif des données dans les fils de liaison dans un programme. Ils permettent aussi de voir les valeurs des données au fur et à mesure qu’elles passent d’une fonction à l’autre à travers les fils. (Ce processus au sein de LabVIEW est appelé Animation de l’exécution.)

^{Figure 3: Le bouton Animer l’exécution fournit un moyen intuitif pour comprendre l’ordre d’exécution du code G.}

LabVIEW offre des fonctionnalités de mise au point pour le code G, comparables à celles que l’on trouve dans les outils classiques de mise au point. Ces fonctionnalités, accessibles dans le cadre de la barre d’outils d’un diagramme, incluent des sondes, des points d’arrêt et des boutons Exécuter sans détailler/Exécuter de façon détaillée/Terminer l’exécution.

^{Figure 4: La barre d’outils du diagramme donne accès aux outils standards de mise au point comme le pas-à-pas.}

Grâce aux outils de mise au point en G, vous avez la possibilité de sonder simultanément les données à plusieurs endroits du programme, interrompre l’exécution et exécuter un sous-programme sans programmation complexe. Bien que ce soit également faisable avec d’autres langages de programmation, la visualisation de l’état du programme et des relations entre des sections parallèles du code est plus simple (ce qui est très courant en G en raison de son caractère graphique).

^{Figure 5: Dans LabVIEW, les sondes constituent un moyen efficace pour lire les valeurs qui circulent dans les câbles de l’application, y compris pour des sections parallèles de code.}

^{Figure 6: La fenêtre d’observation des sondes permet de visualiser les valeurs émises par toutes les sondes de l’application (y compris par les sous-programmes).}

Le compilateur toujours actif (always-on) est l’une des fonctionnalités de mise au point les plus utilisées de LabVIEW. Lorsque vous développez un programme, le compilateur vérifie constamment s’il comporte des erreurs et renvoie des commentaires sur la sémantique et la syntaxe de l’application. En cas d’erreur, il est impossible d’exécuter le programme et le bouton Exécuter sur la barre d’outils présente une flèche brisée.

^{Figure 7: La flèche d’exécution brisée vous alerte immédiatement des erreurs de syntaxe dans le code G.}

Cliquer sur la flèche brisée ouvre une fenêtre contenant la liste des problèmes à résoudre. Dès que vous avez traité ces questions, le compilateur LabVIEW compile votre programme en code machine. Lorsque la compilation est terminée, les performances des programmes en G sont comparables à celles des langages textuels traditionnels tels que le C.

^{Figure 8: La liste des erreurs affiche le détail de chaque erreur de syntaxe dans toute la hiérarchie du code.}

Performance et parallélisme automatique

Des langages de programmation par flux de données similaires à LabVIEW permettent la parallélisation automatique. Contrairement aux langages séquentiels comme le C et le C++, les langages de programmation graphique contiennent des informations inhérentes sur les sections de code à exécuter en parallèle. Par exemple, le modèle de conception Producteur/Consommateur est courant en G. Il permet d’exécuter séparément deux boucles While différentes : la première boucle est responsable de la production des données et la seconde les traite. Malgré l’exécution en parallèle (peut-être à des fréquences différentes), les données sont transférées entre les deux boucles à l’aide de files d’attente, qui sont des structures standards dans les langages de programmation classiques.

^{Figure 9: Le modèle de conception Producteur/Consommateur LabVIEW est souvent utilisé pour augmenter les performances des applications qui requièrent l’exécution de tâches parallèles.}

En programmation, le parallélisme est un facteur important car il peut déverrouiller les gains de performance par rapport aux programmes purement séquentiels, en raison de modifications récentes dans la conception des processeurs des ordinateurs. En l’espace de 40 ans, les fabricants de circuits intégrés ont accéléré la vitesse d’horloge des processeurs afin d’augmenter leurs performances. Cependant, l’augmentation des vitesses d’horloge dans le but d’optimiser leurs performances n’est plus viable aujourd’hui à cause des contraintes liées à la consommation électrique et à la dissipation thermique. De ce fait, les fabricants de puce se sont tournés vers de nouvelles architectures comportant plusieurs processeurs par circuit intégré.

Pour tirer parti des performances disponibles grâce aux processeurs multicœurs, vous devez être capable d’utiliser le multithreading dans vos applications. En d’autres termes, il est conseillé de fractionner vos applications en sections discrètes facilement exécutables séparément. Au cas où vous utiliseriez des langages textuels classiques, vous devrez explicitement créer et gérer les threads pour implémenter le parallélisme, ce qui peut représenter un sérieux problème pour les programmeurs moins expérimentés.

Par contre, la nature parallèle du code G facilite l’implémentation d’un mode multitâche et du multithreading. Le compilateur intégré travaille constamment en arrière-plan à l’identification des sections parallèles de code. Dès que le code G indique une bifurcation dans un fil de liaison, ou une séquence parallèle de nœuds sur le diagramme, le compilateur tente d’exécuter le code en parallèle au sein d’un ensemble de threads que LabVIEW gère automatiquement. En informatique, cette caractéristique est appelée « parallélisme implicite » car vous n’avez pas besoin d’écrire de code particulier pour l’activer ; le langage G s’occupe automatiquement du parallélisme.

Au-delà du multithreading dans un système multicœur, le G peut même améliorer l’exécution parallèle en étendant les avantages de la programmation graphique aux circuits FPGA (field-programmable gate arrays). Les FPGA sont des circuits de silicium reprogrammables massivement parallèles (chaque tâche de traitement indépendante étant assignée à une section spécifique du circuit) mais ils ne sont pas limités par le nombre de cœurs disponibles. En conséquence, les performances d’une partie de l’application ne sont pas affectées pour autant lorsque le volume à traiter augmente.

Par le passé, la programmation des FPGA relevait du domaine exclusif des ingénieurs experts ayant une grande expérience des langages de conception de matériel numérique. Désormais, les ingénieurs qui n’ont aucune expertise avec les FPGA veulent de plus en plus utiliser ce matériel pour des routines de cadencement et de déclenchement personnalisées, des boucles de contrôle ultrarapides, l’interfaçage avec les protocoles numériques, le traitement de signaux numériques (DSP), les applications RF et communications, ainsi que de nombreuses autres applications qui exigent vitesse, fiabilité, personnalisation et déterminisme. Le G convient tout particulièrement à la programmation sur FPGA étant donné qu’il représente la parallélisation et les flux de données. Sa popularité augmente rapidement et devient l’outil de prédilection des développeurs pour le traitement en parallèle et l’exécution déterministe.

^{Figure 10: La gestion de mémoire dans LabVIEW est optionnelle, mais les utilisateurs expérimentés ont la possibilité de paramétrer l’utilisation de la mémoire pour déterminer les portions de l’application qui doivent être optimisées.}

Lorsque le code en G fait preuve d’un comportement inhabituel ou inattendu, difficile à gérer avec les outils de mise au point cités précédemment, vous pouvez utiliser des fonctionnalités de mise au point plus avancées grâce au Toolkit LabVIEW Desktop Execution Trace. Ce toolkit est conçu pour les utilisateurs plus expérimentés qui veulent effectuer des analyses dynamiques de code pour les démarches suivantes :

détecter les fuites de référence et de mémoire
isoler la source d’un événement particulier ou d’un comportement indésirable
passer les applications au crible à la recherche des sections où les performances peuvent être améliorées
identifier le dernier appel avant une erreur
garantir l’exécution identique d’une application sur différentes cibles

Associer le G à d’autres langages

Le code G fournit une excellente représentation du parallélisme et dispense les développeurs d’avoir à comprendre et gérer la mémoire de l’ordinateur. Cependant il n’est pas le meilleur outil pour toutes les tâches, en particulier pour les formules et équations mathématiques qui sont souvent mieux représentées en format textuel. Pour cette raison, nous conseillons d’associer la programmation graphique LabVIEW à d’autres types de programmation textuelle. En travaillant avec LabVIEW, vous avez la possibilité de choisir entre une approche textuelle ou graphique, ou les deux.

Par exemple, LabVIEW intègre le concept de boîte de calcul qui évalue les formules mathématiques et les expressions similaires à celles en C sur le diagramme. Ces formules mathématiques peuvent s’exécuter en parallèle et s’intégrer aisément au code graphique LabVIEW.

^{Figure 11: La boîte de calcul utilise une syntaxe similaire à celle en C pour représenter des expressions mathématiques en format textuel succinct.}

Une meilleure solution pour résoudre vos problèmes

LabVIEW et son langage de programmation graphique par flux de données vous aident à résoudre vos problèmes plus facilement que d’autres langages de bas niveau, d’où sa longévité. Les éléments essentiels de la programmation en G associent la création d’un code graphique intuitif d’une part, et des règles déterminées par les données en charge de l’exécution d’autre part, afin d’offrir une expérience de la programmation qui reflète davantage la démarche intellectuelle de ses utilisateurs que les autres langages. Bien que le G soit un langage de haut niveau, il peut toujours atteindre un niveau de performances comparable à celui des langages comme le C, grâce au compilateur intégré dans LabVIEW.