Cours du 22 au 26 septembre

12 files changed, 324 insertions, 0 deletions

diff --git a/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md b/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md
new file mode 100644
index 0000000..bbc1631
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/2- Programmation en ASM Mips.md
@@ -0,0 +1,157 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - architecture-des-ordinateurs
+semestre: 3
+---
+## Registres
+Un registre de $n$ bits est un composant capable de mémoriser un mot binaire de $n$ bits
+|> changement de valeur possible uniquement lors de front montant/descendant du signal de l’horloge
+|> émission de la valeur contenue dans le registre en continu
+|> les registres dépendent du processeur
+-> contient toutes les informations utilisées par le processeur
+
+Tous les registres du Mips font 32 bits et en possèdent 32
+|> les registres sont nommés par leur numéro
+
+PC (Program Counter) = adresse de l’instruction en cours d’exécution (ou la suivante)
+|> modifié après l’exécution de chaque instruction
+
+IR (Instruction Register) = instruction en cours de traitement
+
+HI/LO (High/Low) = les registres contenant le résultat d’opérations de multiplication ou de division
+
+Il y a d'autres registres qu'on n'utilisera pas en cours
+
+> [!info] L'architecture moderne du Mips est le RISC-V
+
+Processus d'exécution :
+1. Lire une instruction en mémoire (dans IR)
+2. Décoder l'instruction
+3. Exécuter l'instruction
+4. Calculer l'adresse de l'instruction suivante : mettre à jour le PC
+
+Utilisation des registres :
+- `$0` contient la valeur 0 -> est le générateur du 0
+- `$1` registre réservé à l'assembleur (programme qui génère le binaire)
+- `$2 - $3` contiennent les résultats des appels de fonction
+- `$2` peut aussi contenir le numéro d'appel système
+- `$4 - $7` (est aussi appelé de `a0` à `a3`) utilisés pour le passage d'arguments lors des appels de fonctions ou appels systèmes
+- `$8 - $15` contiennent les valeurs non persistantes (libre)
+- `$16 - $25` contiennent les valeurs persistantes (libre)
+- `$26 - $27` contiennent les valeurs OS
+-> voir les diapos pour les autres
+
+Les valeurs persistantes gardent les valeurs avant les appels
+
+> [!NOTE] Notation des registres
+> En Mips, on peut les notés avec `R`, `r` ou `$`, ainsi `R1 = r1 = $1`
+
+> [!danger] On **doit** respecter les règles d'utilisation
+## Jeu d'instruction
+La vue externe d'un CPU peut être définie par l'ensemble des instructions qu'il est capable de traiter
+
+Jeu d'instruction d'un CPU (aussi appelé ISA) est la donnée :
+- de l'ensemble des instructions qu'il peut effectuer
+- le codage de ces instructions en binaire
+
+Une instruction, c'est une commande définissant le traitement à effectuer et quelle sera la prochaine instruction à exécuter
+-> le traitement séquentiel est implicite
+
+On peut spécifier quelle autre ligne à utiliser après l'instruction en cours
+-> c'est un « saut »
+
+Le code d'opération définit quelle opération utiliser
+|> elle porte sur les opérandes
+|> opérandes immédiates sont codées dans l'instruction
+|> les autres opérandes sont dans des registres indiqués
+
+`add $4, $2, $5` signifie `$4 <- $2 + $5`
+`ori $4, $2, 0xABCF` signifie `$4 <- $2 | (0x0000 ABCF)`
+`addi $4, $2, 0xABCF`signifie `$4 <- $2 + (0xFFFF ABCF)` car, par défaut, les entiers sont considérés comme relatifs
+`mult $3, $4` signifie `(HI/LO) <- $3 × $4`
+`div $3, $4` signifie `(HI/LO) <- $3 ÷ $4` (`HI` contient le quotient et `LO` le reste)
+
+On peut définir un label pour savoir où sauter
+
+4 classes d'instructions :
+- arithmétique et logique -> addition, and...
+- transfert mémoire -> lire la mémoire...
+- rupture de séquence -> faire un saut...
+- appels systèmes -> lire un caractère, écrire un entier sur l'écran
+
+Voir le memento pour la liste des instructions
+
+L'instruction `ori` permet de placer une certaine valeur dans un registre
+|> `ori $2, $0, 0x1234` place `0x1234` dans `$2`
+
+Les instructions en Mips possèdent 3 formats :
+- R -> quand on utilise 3 registres
+- I -> quand on fait des calculs avec des immédiats
+- J -> quand on fait des sauts
+
+| Nom\n° de bit | 31 - 26 | 25 - 21 | 20 - 16 | 15 - 11 | 10 - 6 | 5 - 0 |
+| ------------- | ------- | ------- | ------- | ------- | ------ | ----- |
+| **R**         | OPCODE  | RS      | RT      | RD      | SH     | FUNC  |
+| **I**         | OPCODE  | RS      | RT      | IMM     | IMM    | IMM   |
+| **J**         | OPCODE  | JUMP    | JUMP    | JUMP    | JUMP   | JUMP  |
+OPCODE est spécifié dans un codage normé
+|> détecte le format utilisé en fonction de l'OPCODE
+
+Le codage normé ne contient pas tous les OPCODE
+|> s'il n'est pas dedans, l'OPCODE est le "special" et l'opération est dans la case FUNC
+|> l'opération dans FUNC est aussi dans un codage normé
+
+On regarde le memento pour savoir ce que signifie RS, RT et RD
+|> j'ai l'impression que le registre contenant le résultat est toujours le dernier affiché, mais c'est à vérifier
+
+SH permet d'utiliser le shift
+
+Langage haut niveau :
+- $\forall$ ISA
+- notions de type
+- peut créer des variables
+- structure les traitements
+- gestions d'erreurs
+
+Assembleur :
+- Allocation des données et gestion mémoire
+- Suite d'instructions spécifiques
+- Présence d'étiquettes pour désigner les adresses (données ou instructions)
+
+Un programme de haut niveau peut être :
+- natif, i.e. il est compilé pour être exécuté sur la machine cible
+- interprété, i.e. un programme natif interprète le programme et l'exécuté
+
+Nous, on ne regarde que les programmes natifs
+
+Assemblage = assembleur -> binaire
+Désassemblage = binaire -> assembleur
+
+Un label (ou étiquette) s'écrit comme : `nom: add $4, $4, $3`
+|> ici le label `nom` désigne la ligne `add $4, $4, $3`
+-> elles ne sont pas conservées par lors de l'assemblage
+
+En Mips, toujours deux sections différentes :
+1. les données du programme
+2. la section de code
+
+Directive `.data` permet de dire que la suite sera des données
+Directive `.text` indique que la suite sera des instructions
+
+On met toujours `.data`, y compris si c'est vide (dans le cadre de cette UE)
+
+Pour exécuter un programme, on a besoin de le charger
+|> le mettre en mémoire
+|> mettre dans PC la première adresse à exécuter
+
+En Mips, les syscall se font à l'aide de `syscall`
+|> il cherche toujours le numéro de l'appel dans `$2`
+-> se finit donc toujours par
+```asm
+ori $2, $0, 10 # place 10 dans $2
+syscall # syscall dans $2, i.e. syscall 10, i.e. fin du programme
+```
+
+On utilise le simulateur Mars pour écrire / exécuter des programmes
\ No newline at end of file
diff --git a/semestre 3/architecture des ordinateurs/td/25-09-24.md b/semestre 3/architecture des ordinateurs/td/25-09-24.md
new file mode 100644
index 0000000..c00232d
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/td/25-09-24.md
@@ -0,0 +1,48 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - architecture-des-ordinateurs
+  - td
+semestre: 3
+---
+## Exercice 1
+e = 8, f = 23
+
+| Base 10 | Base 2           |
+| ------- | ---------------- |
+| 2.5     | 10.1             |
+| 1.125   | 1.001            |
+| 0.75    | 0.11             |
+| 0.1     | 0.00011...       |
+| 0.2     | 0.0011           |
+| 63.8    | 11 111.110011... |
+## Exercice 2
+
+| Base 10 | Base 2 $m=5$, $n=3$ | Base 2 $m=4$, $n=4$ | Base 2 $m=3$, $n=5$ |
+| ------- | ------------------- | ------------------- | ------------------- |
+| 2.5     | 00010 100           | 0010 1000           | 010 10000           |
+| 1.125   | 00001 001           | 0001 0010           | 001 00100           |
+| 0.75    | 00000 110           | 0000 1100           | 000 11000           |
+| 0.1     | 00000 000*          | 0000 0001*          | 000 00011*          |
+| 0.2     | 00000 001*          | 0000 0011*          | 000 00111*          |
+| 63.8    | 11111 110*          | non représentable   | non représentable   |
+
+| Base 10 | Base 2 $m=5$, $n=3$ | Base 2 $m=6$,$n=2$ |
+| ------- | ------------------- | ------------------ |
+| -0.5    | 11111 100           | 111111 10          |
+| -4.125  | 11011 111           | 111011 11          |
+| -16.75  | 10111 010           | 110111 01          |
+| -31.5   | 10000 100           | 110000 10          |
+| -32.0   | 10000 000           | 110000 00          |
+| -32.8   | non représentable   | 101111 00          |
+## Exercice 3
+$101,01_2 = 1,0101_2\times 2^2$ -> `0b0 010 0101`
+$0,01 = 1,00\times 2^{-2}$ -> `0b0 111 0000`
+
+Plus grand est `0b0 011 1111`, i.e. $1,1111_2\times 2^3 = 1111,1_2 = 15,5$
+|> son pas est $0.5$
+
+Plus proche de 0 est `0b0 100 0001`, i.e. $0,0001_2\times 2^{-3} =0,000 0001_2=0,0078125$
+|> on peut représenter 0 avec que des 0 partout
+|> on peut représenter un dépassement de capacité en regardant s'il y a une retenue sortante au niveau de l'exponent
\ No newline at end of file
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q1.c b/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q1.c
new file mode 100644
index 0000000..83f9ece
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q1.c
@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+int main(){
+    int i;
+    for(i = 0; i>= 0; i++);
+    printf("int\nmax: %d\nmin: %d\n\n", i-1, i);
+
+    char j;
+    for(j = 0; j>= 0; j++);
+    printf("char\nmax: %d\nmin: %d\n\n", (char) (j-1), j);
+
+    short k;
+    for(k = 0; k>= 0; k++);
+    printf("short\nmax: %d\nmin: %d\n\n", (short) (k-1), k);
+
+    return 0;
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q2.c b/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q2.c
new file mode 100644
index 0000000..4350455
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo1/q2.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int main(){
+    unsigned int i = 0;
+    i--;
+    printf("int\nmax: %u\nmin: %d\n\n", i, 0);
+
+    unsigned char j = 0;
+    j--;
+    printf("char\nmax: %u\nmin: %d\n\n", (unsigned char) j, 0);
+    return 0;
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo2/main b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/main
new file mode 100755
index 0000000..593ca11
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/main
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q1-q2.md b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q1-q2.md
new file mode 100644
index 0000000..d97fd9b
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q1-q2.md
@@ -0,0 +1,25 @@
+## Question 1
+
+S: 0
+E: 1000 0010
+M: 010 0000 0000 0000 0000 0000
+
+## Question 2
+
+41950e56
+
+0100
+0001
+1001
+0101
+
+0000
+1110
+0101
+0110
+
+S: 0 -> positif
+E: 1000 0011 -> -128 + 3 = -125
+M: 001 0101 0000 1110 0101 0110 -> 6 + 5×16 + 14×16^2 + 5×16^4 + 1×16^5 = c'est long
+=> 18,632
+
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q3.c b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q3.c
new file mode 100644
index 0000000..00e0325
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo2/q3.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+/* premier nombre est 1103888384 */
+/* deuxième est  */
+int main(){
+    int i;
+    scanf("%d", &i);
+    printf("%f\n", *((float*) &i));
+    return 0;
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1 b/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1
new file mode 100755
index 0000000..7eeefe1
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1.c b/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1.c
new file mode 100644
index 0000000..cac5209
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo3/q1.c
@@ -0,0 +1,23 @@
+#include <stdio.h>
+float suite(int n){
+    if (n == 0) return 1;
+    return 2*suite(n-1)+1;
+}
+
+unsigned long long int suiteInt(int n){
+    if (n==0) return 1;
+    return 2*suiteInt(n-1)+1;
+}
+
+int main(){
+    float val = 1;
+    int i;
+    for (i = 0; i < 129 && val > 0; i++) {
+        val = suite(i);
+        printf("%d — %f\n", i, val);
+        printf("%d — %llu\n", i, suiteInt(i));
+    }
+    /* Le code déborde à partir de 127 avec la valeur "inf"
+     * À partir du 24, la suite devient impaire à cause d'un manque de précision des floats
+     * */
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c b/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c
new file mode 100644
index 0000000..0338dec
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+int main(){
+    char s[25];
+    for (int i = 0; i< 25; i++) s[i] = 0;
+    scanf("%s", s);
+    s[24] = '\0';
+    for (int i = 0; s[i] != '\0'; i++){
+        if (s[i] > 'Z' ) {
+            printf("%c\n", s[i]);
+            s[i] = *s - ('a' - 'A');
+        }
+    }
+    printf("%s\n", s);
+    return 0;
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c.bp b/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c.bp
new file mode 100644
index 0000000..53259cc
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/exo4.c.bp
@@ -0,0 +1,16 @@
+#include <stdio.h>
+
+int main(){
+    char s[25];
+    for (int i = 0; i< 25; i++) s[i] = 0;
+    scanf("%s", s);
+    s[24] = '\0';
+    for (int i = 0; s[i] != '\0'; i++){
+        if (s[i] > 'Z' ) {
+            printf("%c\n", s[i]);
+            s[i] = (char) ((int) *s - ('a' - 'A'));
+        }
+    }
+    printf("%s\n", s);
+    return 0;
+}
diff --git a/semestre 3/architecture des ordinateurs/tme/tme2/main b/semestre 3/architecture des ordinateurs/tme/tme2/main
new file mode 100755
index 0000000..781d5c7
--- /dev/null
+++ b/semestre 3/architecture des ordinateurs/tme/tme2/main