diff options
Diffstat (limited to 'semestre 3/architecture des ordinateurs')
3 files changed, 151 insertions, 6 deletions
diff --git a/semestre 3/architecture des ordinateurs/.gitignore b/semestre 3/architecture des ordinateurs/.gitignore new file mode 100644 index 0000000..a136337 --- /dev/null +++ b/semestre 3/architecture des ordinateurs/.gitignore @@ -0,0 +1 @@ +*.pdf diff --git a/semestre 3/architecture des ordinateurs/1- Représentation de l'information.md b/semestre 3/architecture des ordinateurs/1- Représentation de l'information.md index ee2a51c..8ef0fc2 100644 --- a/semestre 3/architecture des ordinateurs/1- Représentation de l'information.md +++ b/semestre 3/architecture des ordinateurs/1- Représentation de l'information.md @@ -135,6 +135,9 @@ Le codage est la correspondance entre le représentation externe de l'informatio |> c'est comment on souhaite utiliser l'information qui définit quel codage on utilise ! -> est ce qui définit les grandes classes de processeur (Intel, ARM, RISC...) +> [!NOTE] Les bases $B$ sont toujours strictement supérieures à 1 ! +> Sinon, on ne peut représenter que $0$ + Tout entier naturel $N$ peut être exprimé comme une somme de multiples de puissance de la base $B$ |> $N = \sum_{i}a_iB^i$ avec $\forall i, a_i < B$ -> permet de convertir une notation dans la base $B$ vers $N$ |> notation condensée est $a_{n-1}\ldots a_0$ @@ -161,8 +164,7 @@ L'hexadécimal (de 0 à F) permet de compacter le binaire > [!danger] Interprétation > Le codage ne permet toujours pas d'interpréter les données brutes ! -## Entiers -### Entiers naturels +## Entiers naturels Comme les mots sont de taille bornée, il n'est pas possible de tout représenter Sur $p$ symboles en base $B$, on peut représenter tous les entiers dans $[0,B^p-1]$ @@ -248,10 +250,13 @@ Les additions / soustractions sont triviales Attention à l'overflow ! |> arrive quand on dépasse la taille du bit -|> est détectable à l'aide de la retenu -> revoir le moodle pour ça +|> est détectable à l'aide de la toute dernière retenu -> si elle est présente, on dépasse ! +|> la retenu est ignorée quand on dépasse -> est de l'arithmétique modulaire sur $2^n$ -Les décalages servent à multiplier / diviser (voir le diapo) -### Entiers relatifs +Décaler à gauche de $n$ revient à multiplier par la base $B^n$ +|> $(a_{p-1}\ldots a_0)_b\times 2^n = (a_{p-1}\ldots a_0)_b << n = (a_{p-1}\ldots a_0\underbrace{0\ldots0}_n)_b$ +|> $(a_{p-1}\ldots a_0)_b/2^n = (a_{p-1}\ldots a_0)_b >> n = (a_{p-1}\ldots a_{n})$ +## Entiers relatifs On les appelle les nombre entiers signés La représentation classique en signe/module (i.e. un bit pour le signe, le reste pour le module) @@ -265,6 +270,10 @@ où $(k_i)$ sont les bits représentés -> s'appelle représentation des entiers relatifs en complément à deux |> avec $n$ bits on peut donc représenter $[2^{n-1},2^{n-1}-1]$ +Exemples : +- $-1$ = `0b111` +- 1 = `0b001` + Pour prendre l'opposer, on prend son complémentaire et on lui ajoute 1 |> est appelé le complément à deux |> le complémentaire de `0b1001` est `0b0110` @@ -276,4 +285,69 @@ $$ = \mathrm{0b}1\ldots1 = -1 $$ Donc, on a que $\bar N$ doit être décalé de 1, d'où le plus 1 |> cela est dû au fait que l'intervalle ne soit pas symétrique -Voir le moodle pour la suite +Pour étendre un mot relatif de $p$ bits à $n$ bits ($n > p$), on doit : +- ne pas toucher aux $p$ bits +- on recopie le $p-1$ bits (bit de poids fort) sur tous les bits "vides" + +Exemples : +- `0b01` devient `0b0001` +- `0b10` devient `0b1110` + +**Preuve :** +$$ N_p = -a_{p-1}2^{p-1}+\sum^{p-2}_{i=0}a_i2^i $$ +$$ N_{p+1} -a_{p-1}2^p+a_{p-1}2^{p-1}+\sum^{p-2}_{i=0}a_i2^i = a_{p-1}(-2^p+2^{p-1})+\sum^{p-2}_{i=0}a_i2^i $$ +$$ N_{p+1} = -a_{p-1}2^{p-1}+\sum^{p-2}_{i=0}a_i2^i = N_p $$ +car $-2^p + 2^{p-1} = -2^{p-1}$. + +L'addition fonctionne de la même manière que pour les entiers naturels +La soustraction est l'addition de l'opposé + +Pour détecter le débordement sur entier relatif, on regarde les deux dernières retenues +|> si $C_{out,n-1}$ est différent de $C_{out,n-2}$, alors il y a un débordement + +Exemples : +- `0b0110` + `0b0011` = `0b1001` avec $C_{out,n-1} = 0$ et $C_{out,n-2} = 1$, donc débordement en relatif ! (besoin de poser le calcul pour s'en rendre compte) +- `Ob110` + `0b1011` = `0b1001` avec $C_{out,n-1} = C_{out,n-2} = 1$, donc pas de débordement en relatif ! +## Chaînes de caractères +Elles sont majoritairement codées à l'aide de l'ASCII et de l'UTF-8 +|> ASCII est le plus vieux + +ASCII n'est que sur 7 bits (et non sur 8) +|> le bit de poids fort vaut toujours 0 +|> est représenté dans un tableau à double entrée -> colonne = quartet de poids faible, ligne = quartet de poids fort +|> `0x0A` en ASCII est l'équivalent de `LF`et `0x0D` est le `CR` +-> besoin d'étendre le code ASCII pour représenter les autres tables +|> le bit de poids fort sert à ça, mais c'est peu pratique car n'est pas universel + +Une chaîne de caractère est une succession de caractère se terminant par `\0` qui est `0x00` en ASCII +-> **ne pas oublier le `\0` à la fin** + +> [!warning] `"123"` $\neq 123_d$ +## Rationnels +Un rationnel est $\frac ab$ où $a\in\mathbb{Z}$ et $b\in\mathbb{Z}^*$ +|> contient une partie entière et une partie fractionnaire -> est le développement décimale + +Pour représenter d'une manière exacte un rationnel dans une base $B$, on fait : +$$ \sum^{\infty}_{i=-\infty}a_iB^i $$ +Les $(a_i)$ sont les coefficients dans la base $B$. +|> on n'est pas obligé de mettre les 0 non significatifs +**Cette représentation n'est pas bornée** + +La partie entière est $(a_i)_{i\in\mathbb{N}}$ +La partie fractionnaire est $(a_i)_{i\in\mathbb{Z}^*_-}$ + +Si $a>0$ et $a,b$ premier entre eux, alors $a/b$ est unique +|> son développement décimal est toujours fini ou infini périodique +|> est vrai dans toutes les bases $B$ + +Voir le moodle pour la méthode par multiplications successives + +Deux manières de représenter : virgule fixe et virgule flottante + +Voir le moodle pour le codage en virgule fixe + +Virgule fixe est très simple à utiliser : il suffit de rajouter un facteur lors des opérations +|> les opérations fonctionnent pareilles que pour les autres représentations +|> les détections de l'overflow fonctionnent aussi + +Voir le moodle pour la représentation en virgule flottante
\ No newline at end of file diff --git a/semestre 3/architecture des ordinateurs/td/25-09-17.md b/semestre 3/architecture des ordinateurs/td/25-09-17.md new file mode 100644 index 0000000..cf81253 --- /dev/null +++ b/semestre 3/architecture des ordinateurs/td/25-09-17.md @@ -0,0 +1,70 @@ +--- +tags: + - sorbonne + - informatique + - architecture-des-ordinateurs + - td +semestre: 3 +--- +$127_d$ prend 7 bits +$32_d$ prend 6 bits (car le nombre max dans $n$ bits est $2^n-1$ !) + +Un mot hexa de taille $n$ permet de coder $16^n$ valeurs, soit toutes les valeurs entières dans $[0;16^n-1]$ + +| Mot binaire de 8 bits | Décimal | Mot hexa de 8 bits | +| --------------------- | ------- | ------------------ | +| `0b0000 1010` | 10 | `0x0A` | +| `0b0000 0010` | 2 | `0x02` | +| `0b0001 0000` | 16 | `0x10` | +| `0b0011 1001` | 57 | `0x3B` | +| `0b1000 0001` | 127 | `0x81` | +| `0b0001 0111` | 23 | `0x17` | +| `0b0101 1011` | 91 | `0x5B` | +| `0b0010 1001` | 41 | `0x29` | +| `0b1010 1010` | 170 | `0xAA` | +$5B_h+17_h = 72_h$ -> 7 bits +$71_h+B5_h = 126_h$ -> 9 bits + +`0x2B` + `0x95` = `0xC0` -> pas de dépassement en interprétation « entier naturel » +`0xC8` + `0x6D` = `0x35` -> dépassement en interprétation « entier naturel » +`0x8B57` + `0xA34F` = `0x2EA6` -> dépassement en interprétation « entier naturel » + +`0b1001 0011` - `0b1010 0011` = `0b1111 0000` -> dépassement en interprétation « entier naturel » +`0b1100 1111` - `0b1011 0011` = `0b0001 1100` -> pas de dépassement en interprétation « entier naturel » + +`M1 & M2` = `0b1000` +`M1 | M2` = `0b1101` +`~M1` = `0b0110` +`M1 ^ M2` = `0b0101` + +`M3 & 0x0000 FF00` +`M3 ^ M3 = 0x0000 0000` +`M3 ^ 0x0000 00FF` -> permet d'inverser les bits 0 à 7 (i.e. les 8 premiers) + +`M7` = `0b01010011` +`M7 << 1` = `0b10100110` +`M7 << 2`= `0b01001100` +`M7 >> 4`= `0b00000101` + +`<<` réduit le nombre entier naturel et `>>` l'augmente ! + +| Base 16 | Signe | Base 2 | Opposé base 2 | Opposé base 16 | +| -------- | ----- | ----------------------- | ----------------------- | -------------- | +| `0x0B24` | + | `0b0000 1011 0010 0100` | `Ob0111 0100 1101 1100` | `0x74DC` | +| `0xABCD` | - | `0b1010 1011 1100 1101` | `0b0101 0100 0011 0011` | `0x5433` | +| `0xFFFF` | - | `0b1111 1111 1111 1111` | `Ob0000 0000 0000 0001` | `0x0001` | +`0b01101001` + `0b10000000` = `0b11101001` +|> est valide pour des naturels (pas de retenu sortante) +|> est valide pour des relatifs (les deux dernières retenues sont identiques) + +`0b0110` + `0b0100` est valide en naturel, mais pas en relatif + +`127 - 128 = -1` -> pas de dépassement +`120 - (- 150) = 270 > 127` -> dépassement de capacité +`-64 + 127 + 1 = 64` -> pas de dépassement de capacité +|> on n'aurait pas pu réaliser `-64 + 128` directement car 128 ne rentre pas sur 8 bits +|> si on avait fait `opposer(64 - 128)`, on aurait pu le faire + +`0xFF` sur 32 bits, c'est `0xFFFFFFFF` +|> sa valeur en décimal (relatif en complément à 2), c'est $-1_d$ +|> si c'est un naturel, c'est plus du tout la même chose ! |