**
[ ''Start'' ]
[ __[wiki:Howto-TP Config]__ ]
[ __[htdocs:cours/doc_MIPS32.pdf MIPS User]__ ]
[ __[wiki:Doc-MIPS-Archi-Asm-kernel MIPS Kernel]__ ]
—
[ __[htdocs:cours/AS5-9-4p.pdf Cours 9]__ ]
[ __[htdocs:cours/AS5-10-4p.pdf Cours 10]__ ]
[ __[htdocs:cours/AS5-11-4p.pdf Cours 11]__ ]
—
[ __[https://www-soc.lip6.fr/trac/archi-l3s5/wiki/AS5-TME9 TME 9]__ ]
[ __[https://www-soc.lip6.fr/trac/archi-l3s5/wiki/AS5-TME10 TME 10]__ ]
[ __[https://www-soc.lip6.fr/trac/archi-l3s5/wiki/AS5-TME11 TME 11]__ ]
**
[[PageOutline]]
{{{#!html 
<h1><font size=+2> Architecture des ordinateurs L3S5
}}}

Ce site est dédié aux 3 dernières séances du module Architecture des ordinateurs (LU3NI029).\\
Vous y trouverez : 
 1. les documents sur le MIPS : mode user et mode kernel et celui sur l'environnement des TP
 2. les objectifs généraux des séances en lien avec ce que vous avez déjà vu
 3. une explication du principe pédagogique utilisé pour présenter l'architecture 
 4. le fonctionnement des séances de TD-TP, c'est-à-dire ce qui vous ai demandé
 5. les liens vers les slides des cours en PDF
 6. les liens vers les textes de séances de TD et TP.



= A. Documents sur le MIPS et sur l'environnement de TP



Vous devez lire ou au moins parcourir ces 3 documents : **A1** (MIPS/user), **A2** (MIPS/kernel) et **A3** (environnement TP).

Vous avez déjà lu le document **A1**, mais pour pouvoir bien comprendre les notions vues lors des 3 séances, vous devez lire les deux autres. Par exemple, le MIPS fonctionne dans deux modes : le mode user et le mode kernel. 
Le mode kernel permet aux programmes d'accéder à toutes les ressources de l'ordinateur, ce que cela signifie en détail est présenté dans le document **A2**. Autre exemple, vous devez exécuter vos programmes sur un prototype virtuel d'ordinateur. La configuration de votre environnement de travail est dans le document **A3**.

Pour vous aider, le plan des sections de ces documents est recopié ci-après.

* **A1. [htdocs:cours/doc_MIPS32.pdf Documentation MIPS32 architecture et assembleur en mode user ⟶]**
  1. Registres de l'architecture externe accessible en mode user (p. 2)
  1. Espace d'adressage du MIPS32 (p. 4)
  1. Syntaxe et principales directives du langage assembleur (p. 5)
  1. Codage des instructions utilisateur du MIPS32 (p. 9)
  1. Instructions accessibles en mode utilisateur (p. 11)
  1. Appels système de simulateur de processeur **Mars** (p. 22)
  1. Convention d'appel des fonctions (p. 24)

* **A2. [wiki:Doc-MIPS-Archi-Asm-kernel Documentation MIPS32 architecture et assembleur en mode kernel ⟶]**
  1. Modes d'exécution du processeur MIPS
  2. Registres protégés utilisables seulement en mode kernel
  3. Découpage de l'espace d'adressage
  4. Instructions protégées
  5. Cause d'entrée et de sortie du noyau du système d'exploitation
  6. Fonctionnement du registre d'état `c0_sr`
  7. Fonctionnement du registre de cause `c0_cause`

* **A3. [wiki:Howto-TP Configuration de l'environnement des TP ⟶]
  1. Environnement de travail pour les TP
  1. Prototype virtuel et chaîne de compilation MIPS
  1. Compilation et exécution des programmes



= B. Objectifs généraux des 3 séances



Les **premières séances de l'UE** décrivent l'architecture externe du MIPS (celle visible du programmeur) et la programmation structurée en assembleur (avec des fonctions et une pile). Les programmes réalisés utilisent des structures de données simples telles que des tableaux à une dimension et des enregistrements (les ''struct'' du C). L'accès aux entrées-sorties se fait par des demandes de services en utilisant l'instruction `syscall` du MIPS. Les programmes sont exécutés sur le simulateur de processeur **MARS** permettant d'observer l'évolution des registres du processeur et l'évolution des segments de mémoire utilisés par le code, les data et la pile.

Il s'avère que, dans cette première partie, l'architecture de l'ordinateur, au centre duquel se trouve le processeur MIPS, n'est pas détaillée et ce que fait l'instruction `syscall` n'est pas détaillé non plus. Le but des 3 dernières séances est d'étudier plus en détail l'architecture d'un ordinateur simple, de type [https://www.wikiwand.com/fr/Microcontr%C3%B4leur microcontrôleur] à base de MIPS, et d'y exécuter une application au-dessus d'un embryon de système d'exploitation qui exécute les appels système, c'est-à-dire les services accessibles grâce à l'instruction `syscall`. 

Concernant le matériel, il est composé d'un processeur MIPS connecté à une mémoire et quelques périphériques. La mémoire contient le code et les données. Les périphériques sont les composants permettant les entrées-sorties (p. ex. le terminal écran-clavier) ou alors les composants offrant un service spécifique (p. ex. le ''timer'' qui compte le temps). Vous allez :

1. apprendre à manipuler les deux modes d'exécution du processeur (mode ''kernel'' et mode ''user'') ;
2. apprendre à communiquer avec les contrôleurs de périphériques grâce à des registres de commandes accessibles dans l'espace d'adressage du processeur en utilisant les instructions ''load''/''store'' (`lw`/`sw`);
3. apprendre à utiliser les lignes d'interruption des contrôleurs de périphériques permettant de prévenir le processeur d'un événement (une ligne d'interruption est un signal électrique à deux états : ''ON'' et ''OFF'') .

Concernant le logiciel, il est écrit principalement en langage C et un peu en langage assembleur. Il est composé d'un empilement de couches logicielles. Il y a tout d'abord le code de démarrage du processeur (le ''boot''), puis le noyau du système d'exploitation,  puis la bibliothèque système (la ''libc''), et enfin l'application de l'utilisateur. Le code de ''boot'' initialise l'ordinateur. Le noyau gère les ressources matérielles et exécute les appels système (`syscall`). La bibliothèque système (la ''libc'') est un ensemble de fonctions standards tel que `fprintf()` invoquant l'instruction `syscall`. Et enfin, l'application de l'utilisateur est un algorithme utilisant les fonctions de la ''libc''. Vous allez :

1. apprendre à programmer en langage C et à utiliser une chaîne de compilation standard (compilateur + éditeur de liens) via un `Makefile` ;
2. apprendre à exécuter les programmes sur un simulateur d'ordinateur complet avec processeur, mémoire et contrôleurs de périphériques ; 
3. comprendre quelques services proposés par un système d'exploitation simple tels que les pilotes de périphérique et les gestionnaires de syscall et d'interruptions.



= C. Principe pédagogique



Pour présenter les concepts des systèmes d'exploitation, la méthode employée en général est ''top-down''.
On vous présente les services des systèmes (gestion des fichiers, gestion des processus, gestion des 
communications interprocessus, etc.), puis on vous présente comment un système ''open source'' tel que Linux 
conçu pour rendre ces services. C'est très intéressant, mais le système pris comme base est tellement 
complexe, qu'il est juste possible d'en voir une petite partie, et certains étudiants perdent la vue d'ensemble. 
Pour l'UE d'architecture des ordinateurs, c'est une approche impossible parce qu'elle est trop éloignée 
de l'architecture matérielle.

{{{#!comment
Si Linux est trop complexe alors pourquoi ne pas prendre un petit système ad hoc, mais en conservant 
l'approche ''top-down'' ? Oui, cela peut être envisagé, c'est d'ailleurs ce qui a été fait dans un ancien 
module. Toutefois, c'est encore difficile, parce que pour bien comprendre comment fonctionne un service du 
système d'exploitation, il faut avoir une vue d'ensemble du système et ce n'est pas simple à présenter.
}}}

Nous avons choisi, une approche ''bottom-up''. Nous partons d’une feuille blanche, et nous ajoutons progressivement
les services en limitant le nombre de fichiers et la taille des codes. Chaque nouveau service qui s'ajoute
s'appuie sur les services précédemment construits.

{{{#!comment
Pour conclure, si on devait vous apprendre comment est faite une voiture.
L'approche ''top-down'' consiste à prendre une voiture du commerce et à la démonter pour voir de quoi elle est faite.
L'approche ''bottom-up'' consiste à assembler des éléments pour construire une toute petite voiture (genre 2CV :-) ).
}}}

Il n'y a que trois séances, c'est donc juste le début. 
La suite est vue au second semestre dans l'UE Archi 2 (LU3NI031) pour ceux que cela intéressent.



= D. Fonctionnement des séances de TD et TP



Le but des TD est de préparer le travail que vous devez faire dans le TP.
L'idée générale des TP est de créer, très progressivement, un tout petit système d'exploitation.
Évidemment, dans le temps imparti, il n'est pas envisageable de créer un système complexe.
Ce système est petit, mais il se veut simple à comprendre.

Toutes les séances sont structurées de la même manière. Chaque séance est découpée en étapes qui doivent être suivies dans l'ordre. Chaque étape est indépendante des autres du point de vue des fichiers, c'est-à-dire qu'elle n'utilise pas les fichiers des étapes précédentes et donc s'il y a des fichiers en commun entre les étapes, ceux-ci sont répliqués. Le code fourni est toujours fonctionnel et il y a toujours un `Makefile` pour produire l'exécutable et le faire tourner sur le simulateur du prototype d'ordinateur. Le code est très commenté et il n'y a pas — ou peu — de "trous" à remplir.

Chaque étape introduit un petit nombre de concepts. 
Dans la première étape de la première séance, il n'y a que 2 fichiers sources (`hcpu.S` et `kernel.ld`) et 1 `Makefile` simple (de type ''collection de script Shell''). Dans les étapes suivantes, on ajoute progressivement des fichiers et des services.

**Le travail demandé pour chaque étape est le suivant :**

 1. Il faut répondre à des questions de la partie TP portant sur le code et sur l'architecture dans un compte-rendu. Les réponses aux questions sont en général dans le code ou dans les commentaires du code ou dans les réponses aux questions du TD qui a préparé la séance de TP ou enfin, dans les diapositives du cours.\\
    Le but de ces questions est de pointer les difficultés introduites dans l'étape et de les associer à des éléments de réponses vus précédents. Par exemple, dans la première étape, une question est : « ''- Quelle est l'adresse en mémoire de la première instruction du MIPS?'' ». La réponse est dans le cours et dans le TD et dans le fichier `ldscript.ld`. La réponse est « ''L'adresse de la première instruction est ''`0xBFC00000` ».

 2. Il faut ajouter une fonctionnalité au programme dans un ou plusieurs fichiers et décrire cet ajout dans le compte-rendu. Cet ajout peut nécessiter la création d'un nouveau fichier source.\\
    Le but de cet ajout est de s'approprier le code grâce à une petite modification et d'en voir toutes les implications. Par exemple, dans la première étape de la première séance, il est demandé d'afficher deux messages au lieu d'un.




= E. Cours



> ''Cliquez sur les titres pour accéder aux slides''

== [htdocs:cours/AS5-9-4p.pdf 1. Cours démarrage de l'ordinateur ⟶]
  1. Architecture d'un SoC minimal (SoC = ordinateur intégré sur une puce), celui que vous allez utiliser en TP.
  1. Chaîne de compilation du langage C puisque vous allez utiliser le langage C
  1. Présentation des piles de couches logicielles pour comprendre comment l'application communique avec le système d'exploitation
  1. Présentation du prototype virtuel du SoC que vous allez utiliser en TP

== [htdocs:cours/AS5-10-4p.pdf 2. Cours application en mode user ⟶]
  1. Modes d'exécution du MIPS
  1. Composants du noyau et de la libc
  1. Communication entre kernel.x et user.x 
  1. Visite guidée du code sur un exemple

== [htdocs:cours/AS5-11-4p.pdf 3. Cours interruptions et threads ⟶]
  1. Définition des interruptions
  1. Vue matérielle et gestion logicielle des interruptions
  1. Définition d'un fil d'exécution 
  1. Principe de l'exécution en temps partagé



= F. Séances de TD et TP



> ''Cliquez sur les titres pour accéder aux sujets''

Les séances commencent par des questions traitées en TD puis elles continuent par les travaux pratiques à faire vous-même.
== [wiki:AS5-TME9 1. Boot et premier programme en mode kernel ⟶]

Dans cette séance, il s'agit de comprendre comment un ordinateur simple démarre et comment le programmeur peut interagir avec le monde extérieur via les contrôleurs de périphériques. Il s'agit également d'utiliser le langage C pour les programmes et donc la chaîne de compilation ''GCC'' ainsi que d'introduire l'usage d'un `Makefile`. Nous décrivons aussi les fonctions C pour les entrées-sorties telles que `printf()` et `gets()`. Pour toutes les étapes, le nom de l'exécutable produit est `kernel.x`.

L'architecture de l'ordinateur utilisé dans cette séance est composée d'un processeur MIPS, d'une mémoire multisegment et d'un contrôleur de terminal qui peut contrôler jusqu'à 4 terminaux indépendants.

==  [wiki:AS5-TME10 2. Application simple en mode utilisateur ⟶]

Dans cette séance, nous utilisons les deux modes d'exécution du processeur, le mode ''kernel'' et le mode ''user''. En mode ''kernel'', le processeur a droit à toutes les instructions et à tout l'espace d'adressage. En mode ''user'', le processeur est bridé, certaines instructions sont interdites et seule une partie de l'espace d'adressage est autorisé. Nous allons voir comment se passe le passage d'un mode à l'autre. Dans toutes les étapes, le code se répartie dans deux exécutables: `kernel.x` et `user.x`. Nous allons voir en particulier comment fonctionne le gestionnaire d'appel système.

== [wiki:AS5-TME11 3. Gestionnaire d'interruption et thread ⟶]

Dans cette troisième séance, il s'agit de comprendre comment fonctionnent le gestionnaire des interruptions et le principe d'exécution de plusieurs fils d'exécution (thread) en temps partagé. Pour cela, nous allons ajouter dans l'architecture deux composants : un timer qui active périodiquement une ligne d'interruption et un concentrateur de lignes d'interruption. Le concentrateur permet de combiner toutes les lignes d'interruptions des contrôleurs de périphériques pour n'en produire qu'une seule à destination du processeur MIPS. Pour l'exécution des programmes en temps partagé, nous allons décrire le principe de fil d'exécution un processus, nous allons voir comment les créer et comment ils peuvent s'exécuter à tour de rôle sur le processeur.