Parallel Standard-Compliant SystemC Simulation of Loosely-Timed Transaction Level Models
Simulation SystemC parallèle et conforme au standard de modèles transactionnels à temps relâché
Résumé
A System-on-Chip (SoC) is a complete digital electronic system integrated on a single silicon chip called the hardware. This hardware is usually accompanied by dedicated software, the complexity and development time of which increases year by year. However, the highly competitive environment of SoC design imposes limited time-to-market. It is therefore necessary to develop hardware and software simultaneously in a process called "hardware-software codesign". Since hardware prototypes are initially unavailable, software developers rely on virtual prototypes of the targeted SoC. A virtual prototype is a simulator capable of running the software for the SoC being designed and executable on a conventional computer called the host. The SystemC/TLM-2.0 library is one of the most popular libraries for virtual prototyping of SoC. It allows hardware modeling and simulation using the principle of discrete event simulation (DES). This simulation technique sequentially executes the various processes representing the behavior of the modeled hardware according to the so-called coroutine semantics. This guarantees the reproducibility of the simulations while simplifying the writing of the models. However, DES also constrains the use of a single host core, greatly limiting simulation speed. This thesis proposes a parallelization technique for SystemC loosely timed TLM simulation that preserves coroutine semantics. SCale 2.0, the proposed parallel SystemC kernel, is based on the parallel evaluation of the processes of each evaluation phase as well as on the observation of their interactions, mainly via shared memory. Each shared resource is thus associated with a state machine designed to classify these resources and to define the access policy to them. Thus, each process can possibly be sequentialized before accessing a certain shared resource to prevent any interaction with other processes, which could violate the semantics of coroutines. In spite of this, dependencies can form between processes, for example when accessing the same memory address. In particular, in case of circular dependency between processes called conflict, the coroutine semantics is no longer respected and the simulation becomes invalid. All interactions are therefore controlled at the end of each evaluation phase to validate its evaluation. The storage of these dependencies also allows to replay a simulation identically. In the event of an error, a backtracking is performed using a CRIU-based Linux process backup and restore system to re-execute the simulation and avoid the error. However, the simulation of a complete operating system such as Linux generates a very high number of conflicts in this configuration, the cost of which cancels the benefits obtained by parallelization. As the conflicts are mostly caused by the operating system code itself, it was decided to detect the latter via the privilege level of the simulated processors and to force the sequential simulation of the operating system code. This method was evaluated on a variety of models composed of 1 to 32 simulated RISC-V cores, running benchmarks with and without Linux and simulated on a dual-processor machine with 36 cores. In the parallel simulation of 32 cores, the speedup against the reference SystemC Accellera kernel was up to x15 on the benchmarks without Linux with speeds between 800 and 2000 million simulated instructions per second. The speedup varies between x9 and x13 for Linux-based benchmarks and between x12 and x24 when replaying these simulations
Un système sur puce (SoC) est un système électronique numérique complet intégré sur une unique puce de silicium appelée le matériel. Ce matériel est généralement assorti d'un logiciel dédié dont la complexité et le temps de développement augmentent d'année en année. Le contexte hautement concurrentiel de la conception de systèmes sur puce impose cependant des temps de mise sur le marché restreints. Il est de ce fait nécessaire de recourir au développement simultané du matériel et du logiciel au sein d'un processus dénommé "hardware-software codesign". Les prototypes matériels étant initialement indisponibles, les développeurs logiciel s'appuient sur des prototypes virtuels du SoC visé. Un prototype virtuel est un simulateur capable d'exécuter le logiciel destiné au SoC en cours de conception et exécutable sur un ordinateur conventionnel appelé l'hôte. La bibliothèque SystemC/TLM-2.0 est parmi les plus populaires pour le prototypage virtuel de SoC. Elle permet la modélisation du matériel ainsi que sa simulation suivant le principe de la simulation à événements discrets (DES). Cette technique de simulation exécute séquentiellement les divers processus représentant le comportement du matériel modélisé d'après la sémantique dite de coroutines. Cela garanti la reproductibilité des simulations tout en simplifiant l'écriture des modèles. Cependant, la DES contraint également à l'utilisation d'un unique cœur de l'hôte, limitant grandement la vitesse de simulation. Cette thèse propose une technique de parallélisation de simulation SystemC à temps dit relâché et qui préserve la sémantique de coroutine. SCale 2.0, le noyau SystemC parallèle proposé, repose sur l'évaluation parallèle des processus de chaque phase d'évaluation ainsi que sur l'observation de leurs interactions, principalement via mémoire partagée. Chaque ressource partagée est ainsi associée à une machine-à-états conçue afin de classifier ces ressources et de définir la politique d'accès à ces dernières. Ainsi, chaque processus peut éventuellement être séquentialité avant l'accès à une certaine ressource partagée afin d'empêcher toute interaction avec les autres processus, ce qui risquerait de violer la sémantique de coroutines. Malgré cela, des dépendances peuvent se former entre les processus, lors de l'accès à une même adresse mémoire par exemple. En particulier, en cas de dépendance circulaire entre processus appelée conflit, la sémantique de coroutine n'est plus respectée et la simulation devient invalide. L'intégralité des interactions est donc contrôlée à l'issue de chaque phase d'évaluation afin de valider son bon déroulement. Le stockage de ces dépendances permet aussi de rejouer une simulation à l'identique. En cas d'erreur, un retour en arrière est opéré à l'aide d'un système de sauvegarde et restauration de processus Linux basé sur CRIU afin de réexécuter la simulation en évitant l'erreur. La simulation d'un système d'exploitation complet tel que Linux engendre cependant dans cette configuration un nombre très important de conflits dont le coût annule les bénéfices obtenus par parallélisation. Les conflits étant très majoritairement causés par le code du système d'exploitation lui-même, il a été choisi de détecter ce dernier via le niveau de privilège des processeurs simulés et de forcer la simulation séquentielle du code du système d'exploitation. Cette méthode a été évaluée sur une variété de modèles composés de 1 à 32 cœurs RISC-V simulés, exécutant des benchmarks avec et sans Linux et simulés sur une machine biprocesseur comportant 36 cœurs. Lors de la simulation parallèle de 32 cœurs, les gains de performance (speedup) face au noyau SystemC de référence Accellera atteignent alors x15 sur les benchmarks sans Linux avec des vitesses entre 800 et 2000 millions d'instructions simulées par seconde. Le speedup varie entre x9 et x13 dans le cas des benchmarks s'appuyant sur Linux et entre x12 et x24 en rejouant ces simulations
Origine : Version validée par le jury (STAR)