Articles on ENSEIRB-MATMECA

Architecture des processeurs 0: Introduction

Wed, 11 Feb 2026 00:00:00 +0200

Les processeurs modernes sont des systèmes complexes, résultat de plusieurs décennies de travaux. Les plus avancés intègrent de nombreux mécanismes permettant de répondre aux besoins, notamment en performances, de multiples applications.

Organisation du cours

0 - Introduction

1 - Simulation de microarchitectures

2 - Exécution d'un programme

3 - ISA RISC-V

4 - Pipeline

5 - Prédiction de branchement

6 - Mémoire cache

Simulation

Architecture des processeurs 1: Simulateur de microarchitectures RISC-V

Wed, 11 Feb 2026 00:00:00 +0200

Lors de l’étude du fonctionnement des processseurs, il peut être utile de voir cycle par cycle comment évolue une exécution afin de comprendre l’impact des différents mécanismes. Cela s’applique aussi bien pour l’étude de la microarchitecture des processeurs, que pour d’autres expérimentations comme par exemple pour de la sécurité matérielle. Ainsi, un simulateur de microarchitectures est mis à disposition sur GitLab: https://gitlab.com/escou64-emmk/riscv-sim.git. Il permet de simuler l’exécution de différents programmes sur des processeurs implémentant le jeu d’instructions RISC-V. Les différents modèles de simulation sont en fait des exécutables générés directement à partir de description RTL de processeurs.

Architecture des processeurs 2: Exécution d'un programme

Wed, 11 Feb 2026 00:00:00 +0200

Dans un système informatique, un programme ou un logiciel est une suite d’opérations plus ou moins simples décrivant le fonctionnement attendu. Ces opérations sont transmises sous la forme d’instructions que le processeur pourra interpréter avant d’effectuer les tâches correspondantes. Quelque soit le jeu d’instructions ou le type de processeur, ce fonctionnement reste toujours le même.

Sur cette page, nous allons voir comment un programme est exécuté sur un processeur et certains des éléments nécessaires à la compilation. Pour cela, l’objectif sera également de prendre en main l’environnement de simulation de processeurs RISC-V. L’ensemble des expérimentations, sur cette page et les suivantes, seront réalisés à partir de plusieurs modèles de microarchitectures simulées.

Architecture des processeurs 3: ISA RISC-V

Wed, 11 Feb 2026 00:00:00 +0200

Avant même de commencer à commencer à concevoir un processeur, il est nécessaire de définir l’architecture de jeu d’instructions (ISA) qu’il implémentera. Cet élément est essentiel afin de définir comment les parties matérielles et logicielles du système pourront intérragir. C’est à ce niveau que sont définies les instructions (et doc opérations) disponibles, la taille des données manipulées, le nombre de registres etc. Différents types d’architectures de jeux d’instructions existent, avec leurs outils et écosystèmes respectifs.

Architecture des processeurs 4: Pipeline

Tue, 13 Jan 2026 00:00:00 +0200

Les capacités de calcul (ou performances) d’un processeur sont généralement la principale caractéristique à prendre en compte lors de la conception. Comme pour tout système numérique, l’une des solutions pour augmenter le débit de calculs réalisés est d’augmenter la fréquence d’horloge. Pour cela, un mécanisme essentiel est alors implémenté : le pipeline.

Sur cette page, nous allons étudier le fonctionnement d’un pipeline dans un processeur. Notamment, nous verrons comment il impacte l’exécution des programmes. Également, nous étudierons les différents aléas susceptibles de pénaliser le débit final.

Architecture des processeurs 5: Prédiction de branchement

Tue, 13 Jan 2026 00:00:00 +0200

Environnement de simulation

Pour effectuer les différentes simulations de cette page, ouvrez l’ensemble du répertoire riscv-sim avec Visual Studio Code. Dans le terminal de l’IDE, configurez l’environnement du simulateur puis placez-vous dans le répertoire sw/uarch/br.

Architecture des processeurs 6: Mémoire cache

Tue, 13 Jan 2026 00:00:00 +0200

Le processeur ne correspond qu’à la partie opérationnelle du système. Ainsi, pour avoir un système pleinement fonctionnel, il est également nécessaire de l’associer à une ou plusieurs mémoires afin de stocker les différentes instructions et données. Généralement, ces composants sont bien plus lents que le processeur lui-même, ce qui peut impacter les performances de l’ensemble du système.

Sur cette page, nous allon étudier le fonctionnement des mémoires caches, des mémoires intermédiaires permettant de réduire les limitations de la mémoire principale. À l’aide de simulations, nous verrons comment les temps d’accès peuvent varier selon les opérations effectuées. Nous verrons également l’impact du placement des données en mémoire, par exemple lors de la manipulation de tableaux ou matrices.

Programmation de microcontrôleurs STM32: GPIO

Tue, 06 Jan 2026 00:00:00 +0200

Cette page vise à présenter une première utilisation des GPIO sur un microcontrôleur STM32. À la suite de cette page, un développeur logiciel doit être capable:

De trouver les informations nécessaires dans une datasheet pour l’utilisation des GPIO,
De programmer les différents registres pour différentes utilisations des GPIO (LED, bouton-poussoir etc.)

Version des outils Les différentes étapes utilisent la version v1.12.0 du logiciel STM32CubeIDE. Certaines variations au niveau des captures d’écrans peuvent apparaître si vous utilisez des versions différentes. De même, la carte utilisée est la Nucleo-F446RE.

Clignotement d’une LED

Pour la première partie, on se propose de concevoir un programme faisant clignoter la LED d’une carte. Notamment, la carte Nucleo-F446RE dispose d’une LED directement intégrée sur la carte. Elle est connectée sur la broche (pin) 5 du port GPIO A.

Programmation de microcontrôleurs STM32: Interruptions

Tue, 06 Jan 2026 00:00:00 +0200

Cette page vise à présenter une première utilisation des interruptions sur un microcontrôleur STM32. À la suite de cette page, un développeur logiciel doit être capable:

De trouver les informations nécessaires dans une datasheet pour l’utilisation des interruptions,
De programmer les différents registres pour l’utilisation d’une interruption,
De comprendre le fonctionnement pour différentes sources d’interruption.

Détection d’un évènement

Précédemment, nous avons utilisé un bouton poussoir pour déclencher l’allumage d’une LED. La détection de l’état du bouton était alors faite de manière scrutative: le programme vérifiait régulièrement l’état du registre correspondant. Bien que fonctionnel, ce type de fonctionnement est peu efficace: le microcontrôleur exécute en boucle des opérations pour détecter le changement d’état. Ainsi, il ne peut exécuter aucune autre tâche utile pendant ce temps d’attente, en plus de continuer à consommer en réalisant les calculs.

Programmation de microcontrôleurs STM32: Timer

Tue, 06 Jan 2026 00:00:00 +0200

Cette page vise à présenter une première utilisation des interruptions sur un microcontrôleur STM32. À la suite de cette page, un développeur logiciel doit être capable:

De trouver les informations nécessaires dans une datasheet pour l’utilisation des timers,
De programmer les différents registres pour différentes utilisations des timers (LED, bouton-poussoir etc.),
D’adapter le fonctionnement d’un timer à l’utilisation d’un capteur externe.

Détection d’un obstacle

Dans cette partie, l’objectif va être de concevoir un système de détection d’obstacle. Le fonctionnement recherché sera le suivant: faire clignoter une LED de plus en plus rapidement selon la distance d’un obstacle. Pour cela, nous allons décomposer le problème en trois sous-arties:

Programmation de microcontrôleurs STM32: UART

Tue, 06 Jan 2026 00:00:00 +0200

Cette page vise à présenter une première utilisation des interruptions sur un microcontrôleur STM32. À la suite de cette page, un développeur logiciel doit être capable:

De trouver les informations nécessaires dans une datasheet pour l’utilisation du protocole UART,
De programmer les différents registres,
D’envoyer des informations octet par octet vers un ordinateur.

Version des outils Les différentes étapes utilisent la version v1.12.0 du logiciel STM32CubeIDE. Certaines variations au niveau des captures d’écrans peuvent apparaître si vous utilisez des versions différentes. De même, la carte utilisée est la Nucleo-F446RE.

Transmission/Réception UART

Lors de la conception d’un système à base de microcontrôleur, il est souvent utile de pouvoir échanger des informations avec un autre système. Par exemple, c’est le cas lorsque l’on souhaite envoyer des données vers un ordinateur responsable du traitement ou du contrôle. Un protocole de transmission permet alors de mettre en place une interface commune pour l’échange de ces données. Selon les applications, il existe de multiples types de protocoles. Dans le cadre de cet exercice, nous allons nous intéresser au protocole UART.

Programmation de microcontrôleurs STM32: Utilisation de l'IDE

Tue, 06 Jan 2026 00:00:00 +0200

Cette page vise à présenter une première utilisation du logiciel STM32CubeIDE pour la programmation de microcontrôleurs STM32. En la suivant pas-à-pas, un développeur logiciel doit être capable:

de créer un projet,
de savoir où ajouter son programme (simple) en langage C,
de connaître quelles informations sont mises à disposition par l’outil pour le débogage et comprendre à quoi elles servent.

Créer un projet

Pour créer un projet sur STM32CubeIDE, différentes étapes sont nécessaires. Celles-ci sont présentées ci-dessous.

Sécurité matérielle: Mémoires caches

Fri, 12 Dec 2025 00:00:00 +0200

Dans les tutoriels sur la récupération du flot d’exécution par la consommation, nous avons vu que des décalages temporels entre plusieurs exécutions pouvaient être observés par le biais des canaux auxiliaires. Notamment, cela engendrait de grandes différences dans l’évolution de la consommation ou du temps global d’exécution.

Dans ce tutoriel, nous allons à présent nous intéresser à l’observation des variations temporelles dûes à la microarchitecture des processeurs. Notamment, nous allons voir comment les mémoires caches, pourtant essentielles pour les performances de nombreux systèmes, peuvent aussi représenter une source de fuite.

Sécurité matérielle: FPGA

Tue, 25 Nov 2025 00:00:00 +0200

Lors de l’introduction, nous avons vu les principes de l’analyse de la consommation des système matérielles. Ces principes ont été appliqués dans un environnement guidé (Jupyter) sur des systèmes dont l’utilisation est bien maîtrisée, mais dont la microarchitecture interne reste, au moins en partie, inconnue (un microcontrôleur STM32).

À présent, nous allons voir comment cibler un système dont toute l’organisation interne est disponible. Pour cela, l’objectif sera d’implémenter un processeur RISC-V sur une cible FPGA.

Sécurité matérielle: Introduction

Wed, 12 Nov 2025 00:00:00 +0200

Dans cette introduction, l’objectif est de se familiariser en pratique avec les problématiques de sécurité matérielle et avec l’environnement ChipWhisperer. L’ensemble des exercices est basé sur cet environnement et sur la plateforme matérielle du même nom.

Préparation

ChipWhisperer est le nom d’une plateforme fournissant un environnement logiciel (essentiellement en Python) permettant de reproduire des attaques matérielles. Pour cela, différentes cibles matérielles sont disponibles, avec aussi bien des microcontrôleurs que des FPGA. L’intérêt majeure de cette plateforme est sa simplicité d’utilisation: l’ensemble de la chaîne peut-être automatisé à l’aide de scripts Python, de la mesure de consommation par un ADC jusqu’au traitement des données. Ainsi, elle représente un moyen idéale pour une première approche des problématiques de sécurité.

Plateforme CALF: Organisation mémoire

Mon, 01 Sep 2025 00:00:00 +0200

Adresses

Au sein de la plateforme CALF, les adresses émises par le processeur sont utilisées pour rediriger les requêtes. Ainsi, selon les valeurs, certaines sont envoyées vers la mémoire RAM, les registres GPIO8, l’UART etc. La table ci-dessous présente les valeurs définies par défaut. Celles-ci peuvent être modifiées lors de la configuration du matériel (aussi bien dans la version VHDL que Chisel).

Nom	Début	Taille	Type	Description
RAM	`0x00000000`	`0x00000000`	`RWX`	Mémoire générale du système, utilisée pour les instructions et les données.
GPIO8	`0x00000800`	`0x00000010`	`RW-`	Registres de configuration des entrées et sorties génériques.
UART	`0x00000840`	`0x00000020`	`RW-`	Registres de configuration de l’UART.

Mémoire

Périphériques

GPIO8

GPIO8 est un périphérique basique permettant de contrôler l’état de 8 entrées/sorties. Pour cela, il utilise 3 registres de 8 bits: ENO, IN et OUT. Chaque bit b de ces registres correspond à l’entrée/sortie b.

Plateforme CALF: Processeur

Mon, 01 Sep 2025 00:00:00 +0200

Le processeur CALF est un processeur libre et ouvert basé sur l’architecture RISC-V. Au sein de la plateforme CALF, il est responsable de l’exécution des programmes permettant la réalisation d’application. La microarchitecture du processeur est conçu autour d’une machine d’états finis. Il réalise donc une implémentation multi-cycle de l’exécution des opérations, pouvant aller de 4 à 7 cycles selon le type d’instructions et des paramètres utilisés.

Plateforme CALF: Système global

Mon, 01 Sep 2025 00:00:00 +0200

CALF (pour Core Architecture to Learn Fundamentals) est une plateforme numérique conçue pour des projets pédagogiques et de recherche. Elle intègre tous les composants nécessaires pour l’implémentation d’un microcontrôleur minimaliste, sur FPGA ou ASIC:

Un processeur RISC-V responsable de l’exécution des programmes.
Une mémoire RAM paramétrable pour le code et les données.
Un bootloader pour l’initialisation de la mémoire au démarrage. Il est directement connecté au module UART pour la réception des données.
Un module UART pour les communications externes.
Un module GPIO8 pour le pilotage de 8 entrées / sorties.

Le système est disponible en 2 versions RTL: une décrite en Chisel et une autre en VHDL. L’intérêt majeur est de faciliter le passage d’un langage à un autre en fournissant des exemples de blocs aux fonctionnalités identiques.

Plateforme CALF: Utilisation

Mon, 01 Sep 2025 00:00:00 +0200

Installation

Téléchargement

Pour commencer, il est nécessaire de télécharger le projet. Celui-ci utilise git comme gestionnaire de versions et est hébergé sur Gitlab. Pour le télécharger, utiliser les commandes suivantes:

 # Avec SSH configuré sur Gitlab
 git clone git@gitlab.com:escou64-emmk/calf.git
 # Ou sans SSH: git clone https://gitlab.com/escou64-emmk/calf.git
 # Déplacement dans le répertoire
 cd calf
 # Utilisation de la branche riscv
 git checkout riscv

Configuration de l’environnement

Pour la simulation et l’implémentation de la plateforme, plusieurs outils sont nécessaires et doivent être installés: