LabVIEW gère automatiquement l'allocation de mémoire. Comme ce processus est automatique, LabVIEW doit prendre soin de gérer les données d'une manière sûre. Pour cela, LabVIEW copie les données fréquemment. Si le programme doit faire face à de grands ensembles de données, des copies fréquentes d'une grande quantité de données peuvent conduire à l'utilisation de toute la mémoire. Utilisez les conseils suivants pour éviter les problèmes de mémoire et optimiser le programme pour qu'il puisse gérer les grands ensembles de données.

Remarque Vous pouvez aussi utiliser la fenêtre Profil - Performances et mémoire pour acquérir et afficher des données sur l'exécution et l'utilisation de la mémoire des VIs. Utilisez cette fenêtre pour déterminer quels VIs sont à la source de problèmes de mémoire.

Réduction des copies de grands ensembles de données

Comme LabVIEW est un langage de programmation par flux de données, il crée une copie lorsqu'un VI a besoin de plus de données, par exemple lorsqu'un fil de liaison bifurque. Bien que LabVIEW soit généralement en mesure de détecter quand faire une nouvelle copie, il fait une par prudence s'il n'en est pas sûr.

Remarque Lorsque vous utilisez le module LabVIEW Real-Time, les copies de mémoire affectent le déterminisme des applications temps réel.

Utilisez la fenêtre Afficher les allocations de buffer pour déterminer où LabVIEW alloue de la mémoire. Cette fenêtre identifie les buffers de données utilisés par LabVIEW pour stocker les copies des données.

Suivez les conseils suivants pour réduire le nombre de copies que LabVIEW doit faire :

Remarque Certaines des astuces suivantes vont à l'encontre des bonnes pratiques de conception de LabVIEW ; vous ne devriez les utiliser que pour réduire l'utilisation de la mémoire lorsque vous travaillez avec des ensembles de données de taille particulièrement importante.
  • Utilisez le plus petit type de données possible. Par exemple, utilisez un entier 16 bits plutôt qu'un nombre à virgule flottante double précision.
  • Utilisez des tableaux simples. LabVIEW fait une copie supplémentaire des données lorsqu'il extrait un tableau de données de données waveform ou dynamiques pour les traiter.
  • Créez des diagrammes de grande taille ou incorporez le code des sous-VIs pour réduire le temps système. Évitez d'appeler des sous-VIs car LabVIEW crée des copies de données lorsqu'il appelle des sous-VIs.
  • Lorsque vous acheminez des données via des sous-VIs, assurez-vous que tous les terminaux des diagrammes se trouvent en dehors des structures Condition ou des boucles. LabVIEW génère plus de copies de données si les terminaux se trouvent dans des structures Condition ou des boucles.
  • Évitez de faire passer les données par des boucles si ce n'est pas nécessaire. Si vous devez faire passer des données par une boucle, utilisez des registres à décalage au lieu de tunnels. Si vous utilisez des tunnels, LabVIEW fait une copie des données à chaque itération de la boucle.
  • Dans la mesure du possible, utilisez les entrées nécessaires. LabVIEW crée des copies des données lors de la génération d'une valeur par défaut.
  • Utilisez une structure Élément en place au lieu de la structure Séquence déroulée.
Astuce Les versions de LabVIEW les plus récentes font moins de copies automatiques des données que les versions antérieures. Par conséquent, plus la version est récente, mieux LabVIEW gère les grands ensembles de données.

Transfert de grands ensembles de données

Si vous ne pouvez pas éviter de créer des copies des données, la solution suivante consiste à minimiser la taille de chaque copie. Pour cela, divisez les grands quantités de données en blocs plus petits lorsque vous transférez les données d'un emplacement à un autre ; ceci est appelé "chunking", ou découpage en morceaux. Lors du découpage en morceaux, LabVIEW n'a pas d'effet néfaste sur l'utilisation de la mémoire. Les copies affectent le débit ; il reste donc préférable de les minimiser. Les exemples suivants illustrent ce concept.

Vous devez copier 512 Mo de données sur le disque. Vous pourriez prendre toutes les données et les enregistrer sur le disque en une seule fois. Cependant, même si vous minimisez le nombre de copies pour n'en avoir qu'une, vous devez encore transférer les données d'origine et la copie. Vous demandez donc 1 Go de mémoire à LabVIEW. Il est préférable d'utiliser une boucle pour obtenir des blocs de 500 Ko de données à la fois et de les transférer en continu sur le disque. Vous n'utilisez alors qu'1 Mo de mémoire (500 Ko pour les données d'origine et 500 Ko pour la copie), ce qui est tout à fait raisonnable pour la plupart des ordinateurs.

Un autre avantage est que vous économisez le temps considérable qu'il faudrait à LabVIEW pour allouer le grand bloc de mémoire. L'enregistrement de 250 Mo de données sur disque devrait prendre 15 secondes au plus sur la plupart des ordinateurs modernes. Il faudrait au moins autant de temps à LabVIEW pour allouer le Go de RAM nécessaire pour l'autre méthode.

Si vous transférez de grands ensembles de données ou si vous stockez des données dans un RAID (Redundant Array of Independent Disks), vous pouvez aussi transférer ces données sans bufférisation afin de réduire les copies de données et augmenter la vitesse de transfert. Pour désactiver la bufférisation, câblez une valeur VRAI à l'entrée désactiver la bufférisation de la fonction Ouvrir/Créer/Remplacer un fichier.

Affichage de grands ensembles de données

Dans bon nombre d'applications interactives, la seule chose que vous voulez faire avec les données est de les afficher pour que quelqu'un d'autre puisse les voir. Vous avez peut-être une bonne raison pour afficher 5 millions de points, mais une telle quantité de données est bien au-delà de la capacité de la plupart des écrans. Le graphe LabVIEW moyen est de l'ordre de 300 à 1000 pixels de large. Cinq millions de points représente un ordre de magnitude trois fois plus grand que ce que vous pouvez discerner sur un graphe. La décimation des données représente la réponse à ce problème.

Supposons, par exemple, que vous vouliez voir une version précise au pixel près d'une énorme quantité de données sur un graphe. S'il y a une seule variation dans un buffer de 5 millions de points, le tracé sera une ligne horizontale avec un pic large d'un pixel. Si les données représentent une onde sinusoïdale avec plus de cycles que la largeur du pixel de l'écran, le graphe sera une bande solide d'un bord à l'autre de l'écran - pas de repliement. Un algorithme de décimation max-min résout le problème dans ces deux cas.

La décimation max-min est une décimation se fait en utilisant les points maximal et minimal de chaque intervalle de décimation. Une décimation simple utilise le premier point de chaque intervalle de décimation pour le point de données de l'intervalle de décimation. La décimation simple produit des repliements et ne devrait donc pas être utilisée, à moins que le temps ait une importance critique et que la précision ne soit pas importante.

Pour implémenter une décimation max-min, commencez par déterminer la largeur en pixels du graphe. Utilisez la propriété Zone de tracé:Taille:Largeur du graphe pour l'obtenir. Pour diminuer les défauts, il faut au moins deux intervalles de décimation par largeur de pixel ; vous devez donc multiplier la largeur en pixels du graphe par deux pour obtenir le nombre nominal d'intervalles sur lesquels répartir les données. Divisez la longueur des données par ce nombre et arrondissez le résultat à l'entier supérieur le plus proche. Ceci vous donne la taille des morceaux pour la décimation. Pour chaque morceau, trouvez les points maximal et minimal et ordonnez-les dans l'ordre qu'ils avaient dans l'ensemble de données. Ne vous inquiétez pas si le dernier morceau a moins de points que les autres. Le problème a moins d'un pixel de large et n'est pas visible sur l'écran de l'ordinateur. Mettez les données de tous les max et de tous les min en chaîne et tracez-les. Vous aurez quatre points par largeur de pixel sur l'écran. Ceci permet au pic d'un pixel de large de se produire sans affecter les pixels adjacents. Avec la décimation max/min, les pics des données sont toujours visibles, et vous obtenez la bande pleine attendue d'une onde sinusoïdale à haute fréquence. Ceci peut se faire beaucoup plus rapidement car le nombre de données tracées sur le graphe est bien inférieur.

Dans l'illustration suivante, si vous traiter les données de gauche en utilisant une décimation max-min, LabVIEW produit le graphe de droite.

Stockage de grands ensembles de données

Utilisez une file d'attente ou une référence de valeur de données pour stocker de grands ensembles de données en mémoire sans utiliser trop de mémoire. Créez une file d'attente avec un seul élément qui contient les données. À chaque fois que vous voulez accéder aux données, retirez l'élément de la file d'attente. Ceci empêche les autres parties du programme d'y accéder en même temps. Une fois l'opération effectuée sur les données, remettez l'élément dans la file d'attente. Il vous suffit de transférer la référence à la file d'attente. LabVIEW ne crée pas de copie supplémentaire des données lors des transferts de files d'attente. Si vous donnez un nom à la file d'attente, vous pouvez obtenir une référence à cette file d'attente à n'importe quel point en spécifiant le nom dans la fonction Obtenir une file d'attente. Il est aussi facile de créer plusieurs objets de données que plusieurs files d'attente.

Vous pouvez aussi utiliser une référence de valeur de données pour stocker des données sans créer de copie supplémentaire des données. Les références de valeur de données sont légèrement plus efficaces que les files d'attente mais n'ont pas d'option de timeout. Au lieu de transférer les données à une file d'attente, vous pouvez créer une référence aux données et passer la référence. Pour effectuer une opération sur les données, utilisez la structure Élément en place. Le nœud de bordure Lire / Écrire une référence de valeur de données accepte une référence de valeur de données comme entrée, vous permet d'effectuer des opérations sur les données au sein de la structure Élément en place et remplace ces données dans l'espace mémoire d'origine.

Remarque Vous pouvez utiliser la page Héritage de la boîte de dialogue Propriétés de la classe pour n'autoriser que les VIs membres d'une classe LabVIEW à créer des références de valeur de données à la classe.

Vous pouvez aussi utiliser une variable globale fonctionnelle pour stocker de grands ensembles de données en mémoire. Lorsque vous utilisez une variable globale fonctionnelle, LabVIEW enregistre les données et y accède par morceaux, ce qui permet de passer des données sans utiliser une grande quantité de mémoire. Utilisez un registre à décalage non initialisé pour garder les données. Utilisez les fonctions Tableau pour lire, écrire et redimensionner les données. Les fonctions de tableau fonctionnent en place et ne créent pas de copies de données. En général, cette approche est plus lente que l'utilisation d'une file d'attente.