Sortie d’Intel Parallel Studio XE 2018

Intel est surtout connu pour ses processeurs, mais aussi pour ses outils de développement, notamment pour le calcul de haute performance avec sa suite Parallel Studio XE, dont la version 2018 vient de sortir. Ces logiciels visent le développement d’applications hautement parallèles, afin d’exploiter tous les cœurs des processeurs modernes à leur plus haut potentiel, mais aussi l’entièreté des nœuds de calcul d’un superordinateur. La suite contient notamment des compilateurs C++ et Fortran, des bibliothèques de haute performance (MKL, IPP, DAAL, etc.), ainsi que des outils d’analyse de performance et de débogage.

Les points principaux de cette nouvelle version concernent l’utilisation des instructions AVX-512, disponibles uniquement sur certaines gammes de processeurs (certains Xeon de dernière génération et les Xeon Phi). Les outils d’analyse sont plus poussés, comme chaque génération. Les compilateurs respectent les normes plus récentes de manière complète : C++14 au complet (C++17 en partie, officiellement finalisée depuis peu), Fortran 2008 au complet (Fortran 2015 en partie, toujours en cours de développement), OpenMP 5.0 en partie.

Langages

Le compilateur C++ se met au goût du jour avec la norme C++14. Parmi les fonctionnalités de C++17 déjà implémentée, on compte l’implémentation parallèle de la STL — ce qui se comprend, vu que l’objectif est d’avoir un code aussi parallèle que possible. L’idée est d’exécuter les différents algorithmes de la STL en parallèle, en changeant un seul paramètre. Bien évidemment, l’implémentation repose sur TBB, la bibliothèque d’Intel pour le calcul multifil. Malgré leur statut d’avant-gardistes en ce qui concerne les évolutions de C++, ni GCC ni Clang ne disposent de cette fonctionnalité. D’autres apports de C++17 sont aussi implémentés. À un niveau proche, la norme C11 est également gérée.

L’optimisation exploitant les profils (PGO) pointe également le bout de son nez. Elle exploite une trace d’exécution récupérée par VTune Amplifier (en utilisant les compteurs matériels des processeurs) pour décider les parties du code qui bénéficieront le plus des efforts d’optimisation, mais aussi pour déterminer certaines statistiques sur l’exécution du code (comme les branchements) pour certaines décisions d’optimisation.

Pour OpenMP, de nouvelles clauses sont implémentées, en suivant les développements de la version 5.0 de la norme, plus spécifiquement pour la gestion des tâches (TASK_REDUCTION, REDUCTION, IN_REDUCTION). Plus de constructions d’OpenMP 4 sont disponibles.

Bibliothèques de calcul

La MKL (math kernel library) s’oriente historiquement vers les opérations souvent requises par le calcul scientifique : algèbre linéaire, notamment creuse, transformée de Fourier, etc. Cette nouvelle version apporte un lot de fonctionnalités pour les réseaux neuronaux profonds (un sujet relativement à la mode), plus spécifiquement les opérations de convolution (pour les réseaux convolutionnels) et de produit scalaire. Les opérations BLAS entre entiers sont aussi développées, notamment de par leur utilité dans l’apprentissage profond (les nombres à virgule flottante sont remplacés par des entiers pour faciliter certains calculs).

Les IPP (integrated performance primitives) sont à l’opposé de la MKL : il s’agit d’algorithmes de bien plus haut niveau (compression, cryptographie, traitement d’images, etc.). Ainsi, la nouvelle version apporte une implémentation de l’algorithme de compression LZ4. L’API de GraphicsMagick a été répliquée pour de nouvelles fonctions pour redimensionner et flouter les images. Côté cryptographique, de nouvelles fonctions sont disponibles pour les courbes elliptiques.

La DAAL (data analytics acceleration library) est la dernière arrivée du lot. Elle est prévue pour l’exploitation des données, notamment l’apprentissage automatique. La version 2018 s’ouvre aux arbres de décision, ainsi qu’aux forêts, tant en classification que régression. Les couches disponibles pour les réseaux neuronaux s’enrichissent d’une addition membre à membre. Une série de nouveaux exemples montre l’intégration avec Spark MLib. La distribution Python d’Intel utilise notamment la DAAL pour accélérer une série d’opérations de scikit-learn.

De manière générale, les instructions AVX-512 sont utilisées très régulièrement. Aussi, les processeurs trop anciens ne sont plus gérés (comme les Pentium III, d’avant l’an 2000) — étonnement, la première génération de Xeon Phi n’est plus au goût du jour, entièrement remplacée par la seconde.

Outils d’analyse et de débogage

Advisor a été le plus retravaillé de tous les outils de la suite Intel. Il montre une série d’optimisations possibles du code, notamment au niveau de la vectorisation. La simulation des caches est arrivée en préversion. En effet, une mauvaise utilisation des caches d’un processeur peut faire s’écrouler la performance d’une application : le processeur doit alors chercher régulièrement des données en mémoire, plutôt que de réutiliser son cache. Quand cette fonction est activée, elle montre, dans les rapports, pour chaque boucle, le nombre d’opérations effectuées en mémoire et celles qui ne peuvent se faire depuis le cache.

Une nouveauté arrivée entre les versions 2017 et 2018 est l’analyse “sous les combles”. Il s’agit d’une visualisation de la performance d’une application selon les limitations matérielles, notamment la bande passante disponible vers la mémoire. Ce graphique présente la performance (en opérations effectuées par seconde) par rapport à l’intensité arithmétique (le nombre d’opérations effectuées par octet de données). Selon le niveau de cache utilisé, on peut déterminer un maximum d’opérations que l’on peut effectuer par seconde, étant donné la bande passante disponible pour se niveau de cache : si l’application est très proche de la limite pour le premier niveau de cache (le plus rapide), c’est qu’elle utilise le processeur au mieux. L’idée est donc de voir facilement où se situent les points faibles.

Sources : notes de version de la suite, du compilateur C++, du compilateur Fortran, de la MKL, des IPP, de la DAAL, de la distribution Python, d’Advisor ; Intel Advisor Roofline.

Advertisements

Sortie du Movidius Myriad X, la nouvelle génération de processeur pour la vision par ordinateur

Movidius est une compagnie spécialisée dans la conception de processeurs de basse consommation prévus pour la vision par ordinateur et l’apprentissage profond. Elle a été rachetée fin 2016 par Intel. Leur nouveau produit, le Myriad X, annonce une performance dix fois supérieure à la génération précédente (Myriad 2) pour les réseaux neuronaux profonds, à consommation électrique égale (1 W).

Ce qui lui permet d’afficher de tels gains en performance, c’est une unité de calcul spécifique aux réseaux neuronaux, le NCE (neural compute engine), qui peut effectuer jusqu’à mille milliards d’opérations par seconde pour de l’inférence (comme Google, contrairement à Microsoft).

Ensuite, le Myriad X reprend des idées du Myriad 2, comme des processeurs vectoriels programmables : comme dans un FPGA, on peut implémenter ses propres instructions ; ici, les seize cœurs SHAVE (quatre de plus que le Myriad 2) sont forcément vectoriels, c’est-à-dire que la même opération est effectuée sur une série de nombres à la fois.

Également, quelques unités de calcul spécifiques à la vision sont disponibles (conversion de couleurs, convolutions, etc.) ; par rapport au Myriad 2, le X ajoute principalement du matériel pour l’encodage de vidéos en 4K (H.264, H.265 et M/JPEG à 60 Hz) et le calcul du flux optique. En plus, deux cœurs de calcul traditionnels (avec une architecture UltraSPARC) sont disponibles.

Au niveau connectique, un seul processeur peut recevoir jusque huit flux d’images en haute définition (700 Mpx/s) par ses seize lignes MIPI. Il peut aussi se connecter à d’autres Myriad X par PCIe 3.0. On compte aussi une interface USB 3.1 et une Ethernet 10 Gbps. Le contrôleur mémoire gère les puces LPDDR4 ; deux cartes SD peuvent être connectées. Au niveau bas niveau, on compte aussi un bus I²S et quatre bus SPI.

Movidius a été rachetée par Intel après le début de la conception du Myriad X, ce qui explique qu’il est fabriqué par TSMC (sur son processus 16 nm FFC). Le Myriad X ne remplacera pas le 2 dans un avenir proche : ce dernier est actuellement disponible pour moins de dix dollars pièce (alors que le modèle X n’est pas encore disponible en grands volumes).

Source et images : Intel Announces Movidius Myriad X VPU, Featuring ‘Neural Compute Engine’.

Voir aussi : Myriad™ X: Evolving low power VPUs for Deep Neural Networks.

Sortie de LLVM et Clang 5.0

Approximativement selon le calendrier prévu, voici donc la version 5.0 de LLVM, y compris le compilateur C et C++ Clang. En peu de mots, cette version apporte la compatibilité avec pas mal de matériel récent ; côté C++, on compte C++17 au complet et les coroutines (qui apparaîtront probablement dans une prochaine version de C++), en utilisant les fonctionnalités arrivées avec LLVM 4.0.

Cette version apporte énormément de nouveautés du côté matériel, pour les architectures ARM, AVR, MIPS, PowerPC 3.0, x86, ainsi que les GPU AMD Radeon Vega. Plus en détail, pour l’architecture ARM, la sélection d’instructions et la fusion d’instructions ont été fortement améliorées, ce qui devrait avoir un impact non négligeable sur la performance. Les instructions ARMv8.1, 8.2 et 8.3 ont été ajoutées au compilateur (comme les Cortex M23 et M33). Les données de l’ordonnanceur Cavium ThunderX2 ont été ajoutées, ce qui devrait améliorer fortement la performance pour ce processeur prévu pour les centres informatiques et superordinateurs.

Bien évidemment, la famille x86 n’est pas oubliée. Dans les processeurs ajoutés, on compte AMD Ryzen (les données pour l’ordonnanceur seront encore améliorées avec LLVM 6.0) et Intel Goldmont (la dernière génération de Pentium, Celeron et Atom). Pas mal de modifications ont eu lieu du côté AVX-512, les instructions vectorielles des Xeon haut de gamme. Les données concernant une série de processeurs plus anciens ont été mises à jour (Intel Silvermont — Atom, Celeron et Pentium de 2013 — et Sandy Bridge — Core 2e génération —, AMD Jaguar — 2013).

Plus spécifiquement, pour Clang, les coroutines sont une des fonctionnalités les plus attendues pour la version 5.0. N’étant pas encore dans la norme C++, il faut les activer séparément (-fcoroutines-ts -stdlib=libc++). Un coroutine est une fonction particulière qui peut suspendre et reprendre son exécution tout en gardant son état. Une utilisation assez simple est d’éviter de générer explicitement une liste d’éléments à travers laquelle le programme itère — notamment dans le cas où cette liste est infinie. Ainsi, on pourrait écrire ceci pour afficher tous les nombres en partant de zéro jusqu’à l’infini par pas de cinq (0, 5, 10, etc.) :

generator generatorForNumbers(int begin, int inc= 1){
  for (int i= begin;; i += inc){
    co_yield i;
  }
}

int main(){
  for (auto n: getForNumbers(0, 5)) 
    std::cout << n << " ";
}

Ces coroutines auront ainsi une certaine utilité notamment dans les applications par événements, comme un serveur Web (en attendant des requêtes) ou une interface graphique (idem pour des interactions avec l’utilisateur). Elles peuvent aussi avoir des applications pour le multitâche coopératif, où chaque tâche à effectuer décide du moment où elle rend l’exécution aux autres tâches (alors qu’un appel de fonction est préemptif : les autres fonctions ne peuvent s’exécuter qu’à la fin de l’actuelle). Ainsi, par exemple, un serveur Web pourrait s’écrire comme ceci :

Acceptor acceptor{80};
while (true){
  Socket socket = co_await acceptor.accept(); // Exécuté dès qu'une nouvelle connexion arrive. 
  auto request = co_await socket.read(); // Dès qu'un paquet est disponible. 
  auto response = handleRequest(request); 
  socket.write(responste); 
}

Voir aussi : les notes de version de LLVM 5.0 et de Clang 5.0.

QupZilla rejoint KDE et devient Falkon

QupZilla est un navigateur Web entièrement libre et basé sur Qt WebEngine. En développement depuis 2010, il se targue de consommer moins de ressources que ses principaux concurrents, à savoir Firefox et Chrome, en plus d’être livré avec AdBlock. L’un de ses éléments distinctifs est qu’il est prévu pour s’intégrer de manière native à tous les environnements de bureau, à l’aide notamment de jeux d’icônes variés. Il fusionne également l’historique et les signets en un même endroit.

Ses débuts étaient assez modestes, le navigateur n’était prévu que comme manière d’apprendre à se servir de PyQt ; avec le temps et les réécritures (d’abord en C++ au lieu de Python pour la version 1.0, en 2011, puis avec Qt WebEngine pour remplacer Qt WebKit lors de la 2.0, en 2016), cependant, il a fini par devenir un navigateur complet. Récemment, le projet a décidé de quitter son statut de projet indépendant et de rejoindre le projet KDE. Il en profite pour changer de nom et devenir Falkon (le K rappelant KDE).

Pour KDE, l’intérêt est relativement clair. Le projet a déjà deux navigateurs, Konqueror et Rekonq, mais aucun des deux n’est réellement au goût du jour : ils sont restés à Qt WebKit (ce dernier ne revivant que depuis peu, mais sans support officiel), Rekonq n’étant toujours pas porté vers les KDE Frameworks 5. De son côté, Falkon s’intègre dans une communauté bien plus vaste et sera probablement installé par défaut sur tous les ordinateurs utilisant KDE.

Voir aussi : le dépôt Git, la page du projet.

Source : QupZilla is moving under KDE and looking for new name.

Sortie de Qbs 1.9

Qbs (prononcez “cubes” avec votre plus bel accent anglais) est annoncé comme le prochain outil de compilation par défaut avec Qt, il devrait remplacer QMake à l’horizon de Qt 6. La différence majeure par rapport à QMake est la manière de décrire le projet : Qbs utilise QML, le même langage que Qt Quick. La version 1.9 vient de sortir et, selon ses développeurs, elle pose les bases nécessaires à une utilisation à plus grande échelle.

Une énorme amélioration apportée est la paramétrisation des dépendances, à l’aide des composants Depends et Parameter(s). Depends sert à indiquer les dépendances entre deux produits de compilation : l’un doit être compilé avant l’autre, puisqu’il sert lors de sa compilation. Principalement, un exécutable principal dépend d’une ou plusieurs bibliothèques. Cependant, les dépendances peuvent être nettement plus générales : il faut donc un moyen de les contrôler, mais pas uniquement du côté de la dépendance. Les paramètres servent justement à cela : contrôler la compilation d’un produit depuis le produit qui en a besoin. Par exemple, sous macOS, si le produit A dépend de la bibliothèque partagée C sous la forme d’un paquet (A n’utilise pas directement C) et le produit B dépend également de C, mais en tant que liaison dynamique, A et B doivent pouvoir exprimer leurs besoins différents.

Parmi les grandes nouveautés, le multiplexage des produits est largement généralisé par rapport à l’implémentation précédente. Il était déjà utilisé pour créer des paquets Android pour plusieurs architectures. Cependant, il fallait suivre une architecture du projet assez rigide, ce qui posait notamment problème à Qt Creator. La nouvelle version effectue le multiplexage non sur des profils de compilation, mais bien des propriétés quelconques.

Qbs 1.9 simplifie également le déploiement d’applications pour macOS, avec la possibilité de créer des images disques (fichiers DMG) avec une apparence personnalisée. Les difficultés étaient nombreuses, étant donné que le format DMG n’est que partiellement documenté ; certaines parties datent de Mac OS Classic.

Télécharger Qbs 1.9. Qbs 1.9 est intégré à Qt Creator 4.4.

Plus de détails : Qbs 1.9 released.

Sortie de Qt Visual Studio Tools 2.1.2 Beta

L’intégration de Qt à Visual Studio poursuit son bonhomme de chemin avec la version 2.1.2. Celle-ci est la première à être compatible avec Visual Studio 2017.

Depuis la 2.0, l’extension gère la coloration syntaxique pour QML. L’importation des projets QMake de grande taille est plus rapide. La variable d’environnement $(QTDIR) est mieux gérée, ce qui réduit le risque d’erreur.

Cette version n’a qu’un problème connu : elle force à utiliser le SDK Windows en version 8.1, ce qui cause des problèmes s’il n’est pas installé. Il est cependant possible de contourner ce défaut.

Voir aussi : Qt Visual Studio Tools Version 2.1.2 Beta, la liste des changements.

Télécharger le paquet VSIX directement ou depuis Visual Studio Marketplace (version 2.1.1 pour le moment).

Les nouveautés de Qt Location 5.9

Qt Location est le module de Qt chargé de l’affichage des cartes et de l’interaction avec elles. Il a reçu bon nombre d’améliorations avec Qt 5.9, pour éliminer des limitations anciennes.

Une des nouveautés principales est la possibilité de faire tourner les cartes et de les incliner à volonté, tant pour les cartes que les items ajoutés. Deux nouveaux gestes sont reconnus pour les interfaces tactiles : la rotation avec deux doigts qui tournent et l’inclinaison avec un glissement vertical des deux doigts.

En zoomant un peu trop, Qt Location avait la fâcheuse habitude de remplacer les zones pas encore chargées par la couleur d’arrière plan — contrairement à presque tous les services comparables. Désormais, les parties manquantes seront remplacées par une approximation basée sur les données disponibles en cache, ce qui améliore énormément le rendu.

Avant Qt 5.9, Qt Location ne pouvait afficher des cartes que selon une méthode fixe : découper la cartes en petites zones et les donner au moteur de rendu intégré. Maintenant, le module s’ouvre à des moteurs de rend externes : toute implémentation de QGeoMap peut directement ajouter des nœuds au graphe de scène Qt Quick. Justement, Qt 5.9 est livré avec une extension exploitant cette nouvelle flexibilité, basée sur Mapbox.

Toujours dans le domaine du rendu, toute implémentation de QGeoMap peut désormais indiquer les types d’items qu’elle peut afficher à l’écran. Dans ce cas, Qt Location laisse l’extension se charger du rendu de ces items et de leur apparence — tout ce qui n’est pas géré par l’extension ne sera pas affiché. Mapbox est dans ce cas : il est possible de dessiner des rectangles, des cercles, des polygones, mais pas des bordures.

D’autres fonctionnalités ont été implémentées, elles sont décrites en plus ample détail sur le blog de Qt.