Oct. 2021 - Offre de thèse - Ph.D. Student Position


Offre de thèse au laboratoire TIMA (English below)

Organisation

  • La thèse est financée par le projet ANR Maplurinum pour une durée de trois ans
  • La thèse est encadrée par Frédéric Pétrot (Professeur/Grenoble INP) et Arthur Perais (Chargé de recherche/CNRS), dans l'équipe SLS
  • La thèse débutera au plus tôt en octobre 2021
  • Rémunération : environ 1650 € net/mois
  • Contact : arthur.perais@univ-grenoble-alpes.fr

Contexte

Le projet ANR Maplurinum vise à construire la machine du futur, ce qui passe notamment par l’augmentation de l’espace d’adressage (e.g., 128-bit) afin de permettre à n’importe quel processus d’avoir accès à une quantité de données gigantesque. Cela peut notamment permettre d’unifier mémoire et stockage, et donc d’accéder à une donnée, quelle que soit sa provenance (mémoire centrale, stockage, périphérique, etc.), via une instruction load ou store et une adresse.

Au niveau du processeur central, ce passage à 128-bit a un impact certain. D’une part, les registres “généralistes” doivent doubler en taille afin de permettre d’implanter l’arithmétique sur 128-bit pour manipuler des adresses 128-bit. Cela a un impact sur la taille et la consommation du fichier de registres, des unités fonctionnelles, du réseau de bypass, etc. Ce surcoût matériel se paie même si l’utilisateur a simplement porté (recompilé) un programme écrit pour une machine 64-bit vers cette nouvelle machine 128-bit (et n’utilise donc pas vraiment 128-bit). De plus, il existe un surcoût en performance puisque les pointeurs font maintenant 128-bit, c’est-à-dire qu’ils occupent deux fois plus d’espace en mémoire et donc aussi dans la mémoire cache.

L’objectif de cette thèse est donc de quantifier l’impact du passage de 64-bit à 128-bit sur la performance et la consommation du processeur central (CPU), et de proposer des solutions pour réduire cet impact. On utilisera pour cela le jeu d’instructions open-source RISC-V [1], qui propose déjà une extension pour le 128-bit et permet d’ajouter de nouvelles instructions de manière simple.

Axes de recherche

  1. Quantifier l’impact de l’utilisation de pointeurs sur 128 bits sur la performance des programmes. On s’attend notamment à une perte de performance due à l’augmentation de l’espace mémoire occupé par les pointeurs.
    • Implique le “portage” d’applications standards (ajouter 64b de padding à chaque pointeur) et le benchmarking afin de quantifier la perte de performance.
  2. Quantifier et limiter l’impact de l’utilisation de pointeurs sur 128 bits sur la consommation du processeur.
    • Quantifier : simulation de programmes et projection de la consommation via outils type McPat [2]. Il faudra modifier le modèle de consommation pour tenir compte des chemins de données plus larges.
    • Limiter : On fait l’hypothèse que malgré la possibilité de faire de l’arithmétique 128-bit, la majorité des calculs resteront sur 32/64-bit, et seul le calcul d’addresse se fera sur 128-bit.
      • On vérifiera d’abord cette hypothèse sur les programmes actuels (utilisation d’arithmétique 32-bit malgré une ISA 64-bit) par instrumentation (e.g., Spike [3] ou Qemu [4]).
      • Au niveau matériel, on cherchera ensuite à avoir une majorité du processeur n’utilisant que des chemins de données 64-bit, et un petit sous ensemble qui utilisera des chemins de données 128-bit. Initialement, toutes les instructions seront envoyées vers le “cluster” [7,8] 128-bit, mais la microarchitecture tentera d’apprendre quelles opérations manipulent en fait des entiers 32- et 64-bit et peuvent donc être envoyées sur le “cluster” 64-bit. Il faudra ensuite concevoir des mécanismes pour gérer les cas où la microarchitecture se trompe.
  3. Ajouter deux nouvelles instructions au jeu d’instruction RISC-V, et éventuellement les émettre dans LLVM : load/store pointer
    • Permet notamment de raffiner la classification proposée en 2. : Les instructions sur la chaîne de dépendances d’un load pointer sont envoyées sur le “cluster” 128-bit, les autres sur le “cluster” 64-bit. Il n’y a plus besoin que la microarchitecture “apprenne” dynamiquement.
    • Autres optimisations potentielles

Compétences requises

La majeure partie du travail devrait s’appuyer sur la simulation fonctionnelle (e.g., Spike [3], Qemu [4]) et la simulation microarchitecturale de haut nivau (e.g., gem5 [5], Scarab [6]). Les compétences techniques et savoirs attendus sont donc fortement liéss à ces aspects, mais idéalement, les nouvelles instructions pourraient être intégrées à une infrastructure de compilation (LLVM), et une maîtrise de l’aspect compilation est donc tout à fait bienvenue.

  • Maîtrise des concepts microarchitecturaux (notamment pipelines, exécution dans le désordre et mémoires caches, mémoire virtuelle)
  • Maîtrise du C++
    • Programmation
    • Debug (gdb ou autre)
    • Test
  • La maîtrise d’un langage de scripting (e.g., Python ou autre) est un plus
  • La connaissance des concepts utilisés par l’infrastructure de compilation LLVM est un plus

Il est de plus attendu du candidat/de la candidate les qualités suivantes :

  • Travail en autonomie, ce qui inclut :
    • Pouvoir se former aux technologies non maîtrisées (e.g., simulateurs, modèles de consommation)
    • Dans une certaine mesure, être capable d’analyser les résultats produits et produire des conclusions afin de déterminer les prochaines étapes du travail de recherche
    • Lire des articles de recherche et “suivre” les références pertinentes citées dans les articles : la lecture d’articles représente une partie non négligeable du temps de travail
  • Etre réceptif à la critique constructive
    • Au niveau du développement, expériences et conclusions
    • Au niveau de la rédaction des articles
    • Au niveau des présentations orales

Ph.D. Student Position at TIMA

Organization

  • The Ph.D. is financed by ANR project Maplurinum for three years
  • The Ph.D. supervised by Frédéric Pétrot (Professeur/Grenoble INP) and Arthur Perais (Chargé de recherche/CNRS), in the SLS team
  • The Ph.D. thesis will start october 2021 at the earliest
  • Salary : around 1650 €/month (“net” : after labour taxes but before income taxes)
  • Contact : arthur.perais@univ-grenoble-alpes.fr

Context

The goal of the Maplurinum project is to build the next generation (super)-computer, which notably entails increasing the address space (e.g., to 128-bit) in order to allow any process to access a gigantic amount of data. This can notably allow the unification of storage and memory, allowing data to be accessed with load and store instructions regardless of it actual location (memory, storage, peripheral, etc.).

Within the processor, going to 128-bit has a significant impact. First, general purpose registers must double in size in order to implement 128-bit arithmetic to manipulate 128-bit addresses. This impacts the area and power consumption of the register file, the functional units, the bypass network, etc. This hardware overhead is paid even if a user simply ported (recompiled) a program written for a 64-bit machine to this new 128-bit machine, even if the program does not make use of the larger address space. Moreover, there exists a performance cost since pointers now occupy 128 bits, meaning that the footprint of pointers in memory (and in cache memory) is doubled.

The goal of this Ph.D. thesis is to quantify the impact of the move from 64-bit to 128-bit on central processor (CPU) performance and power consumption, and to propose microarchitectural solutions to significantly reduce this impact. The project will use the open-source RISC-V ISA [1], as it already features a 128-bit extension and will let us add new instructions easily.

Research directions

  1. Quantify the impact of using 128-bit pointers on CPU performance. We expect a performance decrease stemming from the bigger memory footprint of pointers.
    • Implies “porting” standard applications (by adding padding to all pointers) and benchmarking in order to quantify the performance loss.
  2. Quantify and limit the impact of using 128-bit pointers on CPU power consumption.
    • Quantify : Simulation and power projection of standard programs via tools such as McPat [2]. The power model will have to be modified to take the wider datapath into account.
    • Limit : Our working hypothesis is that despite the ability to perform 128-bit arithmetic, a majority of computations will actually remain on 64-bit or 32-bit, and only address calculation will actually require 128-bit.
      • This hypothesis will have to be validated on current programs (use of 32-bit arithmetic on a 64-bit ISA) using instrumentation frameworks (e.g., Spike [3] or Qemu [4]).
      • At the hardware level, we will then propose a microarchitecture where most of the datapaths remain 64-bit, with a dedicated and small “cluster” [7,8] for 128-bit execution. Initially, all instructions will be sent to the 128-bit cluster, however, the microarchitecture will attempt to learn dynamically which instructions are actually doing 32-/64-bit computations and send them to the 64-bit “cluster” next time around. Mechanisms to handle misclassifications will be required.
  3. Add two new instructions to the RISC-V ISA, and if time permits add support to the LLVM infrastructure : load/store pointer
    • Allows to refine the classification proposed in 2. : Instructions that depend on a load pointer are automatically sent to the 128-bit cluster, while other instructions are sent to the 64-bit “cluster”. Arguably, there is no need for the microarchitecture to classify instructions dynamically anymore.
    • Other potential optimisations

Required Skills

The bulk of the thesis work will rely on functional simulation (e.g., Spike [3], Qemu [4]) and high-level timing simulation (e.g., gem5 [5], Scarab [6]). Expected technical skills and theoretical knowledge are therefore related to those aspects, although ideally, new RISC-V instructions could be added to a compilation infrastructure (LLVM), and knowledge in compilers is also very welcome.

  • Mastery of architectural and microarchitectural concepts (notably pipelines, out of order execution, cache memory, virtual memory)
  • Reasonable mastery of C++
    • Programming
    • Debugging (gdb or other)
    • Testing
  • Scripting language (e.g., Python) is a plus
  • Knowledge regarding the LLVM compiler infrastructure is a plus

The following traits are also expected from the candidate :

  • Being able to work in autonomy, which includes :
    • Being able to learn new technologies (e.g., simulators, power models)
    • To some extent, being able to analyze experimental results and produce conclusions in order to determine the next steps of the research work
    • Read scientific articles and being able to “follow” the relevant references that are cited in an article : Paper reading represents a non-negligible portion of the time worked
  • Be receptive to constructive criticism
    • Regarding experimental setup and conclusions
    • Regarding scientific article writing
    • Regarding scientific presentations

References

[1] Waterman, Andrew, et al. “The risc-v instruction set manual, volume i: Base user-level isa.” EECS Department, UC Berkeley, Tech. Rep. UCB/EECS-2011-62 116 (2011). Link

[2] Li, Sheng, et al. “McPAT: An integrated power, area, and timing modeling framework for multicore and manycore architectures.” Proceedings of the 42nd Annual IEEE/ACM International Symposium on Microarchitecture. 2009. Link

[3] Spike RISC-V ISA Simulator Link

[4] Bellard, Fabrice. “QEMU, a fast and portable dynamic translator.” USENIX annual technical conference, FREENIX Track. Vol. 41. 2005. Link

[5] Lowe-Power, Jason, et al. “The gem5 simulator: Version 20.0+.” arXiv preprint arXiv:2007.03152 (2020). Link

[6] Scarab Link

[7] Kessler, Richard E. “The alpha 21264 microprocessor.” IEEE micro 19.2 (1999): 24-36. Link

[8] Michaud, Pierre, Andrea Mondelli, and André Seznec. “Revisiting clustered microarchitecture for future superscalar cores: A case for wide issue clusters.” ACM Transactions on Architecture and Code Optimization (TACO) 12.3 (2015): 1-22. Link