Utilisation de la mémoire partagée dans le contexte de processeurs embarqués multi-cœurs : exploration de la technologie et de ses limites

Use of shared memory in the context of embedded multi-core processor : exploration of the technology and its limits

• Auteur / Autrice : Paolo Burgio
• Direction : Philippe Coussy, Luca Benini
• Type : Thèse de doctorat
• Discipline(s) : STIC
• Date : Soutenance en 2013
• Etablissement(s) : Lorient
• Ecole(s) doctorale(s) : École doctorale Santé, information-communication et mathématiques, matière (Brest, Finistère)
• Partenaire(s) de recherche : Laboratoire : Laboratoire en sciences et techniques de l'information, de la communication et de la connaissance
• Partenaire(s) de recherche : Autre partenaire : Université européenne de Bretagne (2007-2016)

Mots clés

Mots clés contrôlés

OpenMP (informatique)

Mémoire partagée répartie

Conception et construction

Microprocesseurs multi-coeurs

Systèmes embarqués (informatique)

Résumé

Dans la dernière décennie, en particuliers depuis l’avènement des Smartphones et des tablettes numériques, les systèmes embarqués ont adoptés des architectures « many-cores » pour répondre à la demande en hautes performances à faible cout énergétique. Le paradigme de la communication par mémoire partagée est une solution prometteuse pour faciliter la programmation de ces plateformes. Toutefois, ce modèle vient des architectures mutli-cœurs et son adoption dans les architectures « many-cores » a certains inconvénients. Le principal problème vient du fait que, eu égard aux contraintes d’énergie et de surface, la plupart des systèmes embarqués modernes intègrent, afin d’améliorer la localité des données et ainsi se battre contre le mur de mémoire (memory wall), des mémoires de type « scratchpad » gérée par le logiciel plutôt que des mémoires caches. Cette solution complique la vie des programmeurs puisqu’il leur est maintenant demandé de gérer explicitement la mémoire et d’orchestrer les mouvements de données. De plus, les applications modernes sont de plus en plus complexes et doivent être manuellement parallélisées afin de pouvoir exploiter au mieux les centaines voire les milliers d’unités de traitement accessibles et rendre ainsi leurs performances potentielles bien réelles. Pour cela, plusieurs langages ou extensions de haut niveau ont été proposés chacun ciblant un modèle de programmation ou un type d’architecture particulier. Typiquement les services de base associés tels que la gestion de la mémoire ou des tâches sont fournis par une bibliothèque d’exécution qui interagit directement avec le matériel mais dont la latence peut limiter la performance. La minimisation de ce surcout est particulièrement cruciale dans le domaine des systèmes embarqués pour lesquels le nombre de ressources (telle que la mémoire) et le budget énergétique sont limités. Dans ce document, l’applicabilité du paradigme de programmation par mémoire partagée dans le contexte des systèmes « many-cores » et en particulier sa facilité de mise en œuvre sont explorés. Les travaux ciblent principalement OpenMP qui est un standard de facto pour la programmation par mémoire partagée. Dans une première partie, les coûts des services de bas niveau tels que la synchronisation ou le partitionnement des données sont analysés et de nouveaux mécanismes et algorithmes pour les mettre en œuvre sont proposés. Ensuite, une bibliothèque d’exécution OpenMP qui a été conçue pour supporter des formes complexes de parallélisme telles que le multi-niveau (ou imbriqué) ou le parallélisme de niveau tâche est présentée. Dans une deuxième partie, les systèmes hétérogènes sont particulièrement ciblés. Ceci est une tendance de conception récente qui considère des plates-formes dans lesquelles les accélérateurs matériels non programmables sont couplés aux processeurs pour mettre en œuvre des noyaux fonctionnels et ainsi obtenir des performances temporelles supérieures de plusieurs ordre de magnitude comparées à des solutions purement logicielles. La communication entre les processeurs et les accélérateurs, qui est un élément cruciale pour atteindre de hautes performances, est ici encore mise en œuvre au travers d’un système de mémoire partagée. Dans ce contexte un modèle d’architecture incluant une interface de communication est défini pour les accélérateurs matériels et un modèle de plateforme permettant d’intégrer ces accélérateurs est proposé. De plus, un outil de CAO ainsi qu’une pile logicielle complète ont été développés pour supporter le processus de conception et permettre au concepteur d’exploiter aisément les accélérateurs au sein de la plateforme. Les détails de bas niveau tels que les mouvements de données ou la synchronisation sont masqués au programmeur et réalisés de façon transparente par la bibliothèque d’exécution que nous proposons. Une interface de programmation basée sur OpenMP permettant d’interagir avec le moteur d’exécution ainsi qu’une version modifiée du compilateur GCC sont fournis. Deux approches de conception sont proposées dans le cadre de ces travaux : (1) une approche descendante, facilitant la conception de plates-formes via un ensemble d’outils logiciels ; (2) une approche montante, pour laquelle nous proposons d’étendre le formalisme OpenMP afin de masquer à l’utilisateur la mécanique de gestion de la mémoire lorsqu’il utilise des accélérateurs matériels et pour avoir recours à une exécution purement logicielle lorsque les accélérateurs ne sont pas disponibles

In the last decade, embedded systems embraced many-core designs, to meet the demand for performance at low power budgets by the market, especially since smartphone and tablets went mainstream. The shared-memory communication paradigm is a promising solution to ease programmability on these platforms. However, it is born for programming symmetric multi-processor sytems, and adopting it on modern many-cores has some drawbacks. The main issue stems from the fact that, due to constrained power and area budgets, most of modern embedded systems feature software-managed scratchpad memories instead of data caches, to increase data locality and fight the memory wall. This complicates programmers’ life, because now it’s their duty to explicitly manage the memory and orchestrate the data movements. Moreover, modern applications are increasing in complexity and must be manually parallelized before they can exploit the hundreds/thousands available processing units, translating their potential into actual performance. To this aim, several languages/extensions have been proposed, targeting different programming paradigms and architectures. They work at a high level of abstraction and, typically, basis services such as memory and thread management are provided by a runtime runtime library, which direcly interacts with the hardware/BSP, and whose cost potentially hinders performance. Minimizing this overhead is crucial, especially in the domain of embedded systems, where resources (such as the memory) and power budget are constrained. In this dissertation, I explore the applicability of the shared-memory paradigm on modern many-core systems, especially focusing on the ease-of-programming. I will mainly focus on OpenMP, which is the de-facto standard for shared memory programming. In a first part, the cost of low level services such as synchronization and data partitioning are analyzed, and new mechanism and algorithm are proposed for implementing them on embedded many-cores. Then, I introduce the original design of an OpenMP runtime library, which supports complex forms of parallelism such as multilevel (or nested) and task-based parallelism. In the second part of the thesis, the focus is on heterogeneous systems. This is a quite recent design trend, which considers platforms where hardware accelerators are coupled to (many-)cores to implement key functional kernels with orders-of-magnitude of speedup and energy efficientcy compared to the “pure software” version. Communication beween cores and accelerators is crucial to achieving performance, and again it is implemented through the shared memory system. Starting from this, a template for a generic hardware processing unit (HWPU) is proposed, which can be specified for a given application or kernel, and an heterogeneous architecture which integrates HWPUs and many-cores is shown. Once the generic platform template and communication “contract” were fixed, a full software stack and toolchain have been developed to support the design process and to let programmers exploiting the accelerators of the platform. Low-level details such as data movements and synchronization are hidden to programmer, and silently performed by a lightweight runtime library. A simple OpenMP-based API is provided to interact with the runtime, with a modified GCC compiler to support it: this greatly simplifies programmer’s life. Two orthogonal approaches are presented: from one side (top-down) we aim at supporting the design of the platform with a set of tools that automate it as much as possible; from the other perspective (bottom-up), programmer is provided with lightweight language extensions to develop code that transparently inspect the platform and exploits the – possibly existing – accelerators, or resorts to the software version of the kernels if they are not available.