fin de matinée

Assembleur/cours.md

@@ -0,0 +1,213 @@
+# Architecture des processeurs, Langages d'assemblage et assembleur en ligne
+
+Benoit Morgan - Intel corp
+
+# Introduction
+
+L'assembleur est le langage qui permet de générer un langage machine / programme correct. Le langage est très proche du jeu d'instruction et de l'achitecture du processeur, mais suffisamment abstrait pour être lu et écrit par un humain. On associe une famille de processeur à un langage assemblage donnée
+
+# Architecture matérielles des processeurs
+
+## Processeur
+
+Il s'agit du composant essentiel d'une machine, il est capable d'exécuter des instructions machine d'un programme, il a accès à la mémoire, et aux périphériques. On l'associe en général à l'intelligence de la machine
+
+microprocesseur = processeur + mémoire + entrées / sorties + etc
+
+# Micro Processeur
+
+## Mémoire
+
+Plusieurs types de mémoires
+
+### Mémoire court termes - Registres
+
+Utilisés directement par les unités arithmétiques et logiques comme paramètre et stockage des opérations arithmétiques
+
+### Mémoire long terme - la RAM
+
+Utilisée pour le stockage des instruction ou les données d'un programme (variables temporaires, locales, globales...)
+
+### Périphériques
+
+Permettent l'acheminement du flot de données
+
+# Instructions machines
+
+Il s'agit des opérations élémentaires exécutées par un processeur. On en distingue plusieurs types :
+
+- UAL
+- Accès mémoire
+- I/O en lecture ou écriture
+- Gestion du flot d'exécution - Sauts, fonctions, interruptions
+- Système : configuration, noyau, VM, énergie...
+
+# Opérateurs binaires
+
+## Logique
+
+- & ET
+- | OU
+- $\oplus$ XOR
+
+## Arithmétiques
+
+- Addition +
+- Soustraction -
+- Multiplication x
+
+## Binaires
+
+# Architecture générique typique et simplifiée
+
+- Périph entrée et sortie
+- CPU
+- Mémoire
+- Jeu d'instructions
+  - Lire une entrée utilisateur
+  - Ecrire une entrée utilisateur
+  - Addition
+  - Soustraction
+  - Lecture mémoire
+  - Ecriture mémoire
+
+## Calcul arithmétique avec une UAL
+
+- Généralement deux entrées dans un CPU
+- Généralement une sortie
+- Processeur xbits <=> UAL x-bits
+
+Décomposition en suite d'instructions arithmétiques :
+
+sortie((entrée() +entrée()) * (entrée()+entrée()))
+
+<p align="center">
+  <img src="./Images/operation_to_instructions.png">
+</p>
+
+<p align="center">
+  <img src="./Images/o_t_i_inpc.png">
+</p>
+
+# Drapeaux et comparaisons
+
+## Drapeaux arithmétiques
+- Z : résultat nul
+- C (carry) - retenue
+- O (Overflow) l'espace des nombres signés a été dépassé
+- P : parité
+- S : Signé
+
+Encodage des nombres signés en mémoire 
+
+$n = -b_{n-1} \times 2^{n-1} + \sum_{i=0}^{n-2}{b_i\times2^i}$
+
+# Instructions de contrôle du flot d'exécution
+
+Permet la mise en oeuvre de tests et de bouvles quand utilisées en complément avec l'UAL. 
+
+```C
+if (expr.){statement} else {statement}
+while (expr.) {statements}
+for (statements;expr;statements){statements}
+```
+# Exemple de tests - if et boucles - for
+
+```C
+if (6==entrée()){
+    sortie(0);
+}
+else{
+    sortie(1);
+}
+```
+```x86asm
+Programme                         Commentaires
+A = 6                             if (6 - entrée() == 0)
+B = entrée
+A = A - B     ou A CMP B
+cpt. ordinal = 6 ssi Z = 0
+sortie = 0                        sortie(0)
+cpt. ordinal = 7                  else
+sortie = 1                        sortie(1)
+[..]
+```
+
+```C
+for (int i = 0; i < 10; i++) {
+sortie(i);
+}
+```
+
+Peut être traduit en suite d’instructions génériques suivantes :
+```x86asm
+Programme                         Commentaires
+A = 0                             int i = 0
+B = 10
+A CMP B                           i < 10 ?
+cpt. ordinal = 7 ssi Z = 1        {
+sortie = A                        sortie(i)
+A = A + 1                         i++
+cpt. ordinal = 2                  }
+[..]
+```
+
+# Support des procédures
+
+Une bonne façon de faire des appels de fonction supportant les appels de fonctions consécutifs et les appels imbriqués de fonction et de procéder de la façon suivante : 
+
+Un appel récursif avec pile et accès mémoire indirect : 
+
+```x86asm
+Programme                           Commentaires
+P = 41                              Initialisation pile
+A = 0                               main() {}
+appel 10                            f() et C = 2
+appel 10                            f() et C = 3
+[..]
+P = P - 1                           f() {} sauvegarde du contexte
+MEM[P] = C
+A = A + 1
+appel 20                            f2() et C = 14
+C = MEM[P]                          restauration du contexte
+P = P + 1
+cpt. ordinal = C                    cpt. ordinal = @retour
+[..]
+A = A + 2                           f2() {}
+cpt. ordinal = C                    cpt. ordinal = @retour
+```
+
+**Attention, il n'est pas toujours nécessaire de passer par la pile**. Par défaut ce sera cette structure qui sera utilisée dans une architecture x86, mais en soi, pour un simple appel de fonction non récursive, il suffirait de garder uniquement le registre C qui contient l'adresse de la ligne suivante de code à éxecuter.
+
+# Structure des instructions
+## Champ usuels
+
+| Code opération | Opérandes |
+- Code d'opération $\simeq$  Opération à exécuter, peut donc spécifier la taille des opérandes : 
+    - addition, appel, cpt.ord = etc...
+
+- Opérandes $\simeq$ les paramètres de l'instruction : 
+    - adresse absolue, registre, etc...
+
+## Taille d’une instruction
+- Jeu d’instruction à taille fixe
+    - Exemple : ARM, MIPS
+- Jeu d’instruction à taille variable
+    - Exemple : Intel x86
+
+## Sémantique et structure d'une opérande 
+
+- Généralement interprétés en fonction du code opération
+- Id du registre
+    - Ex : 0 = A, 1=B
+- Valeur imméditate 
+    - Ex : A=4
+- Adresse 
+    -Ex : appel 20
+
+Classification des processeurs
+- _Reduced Instruction Set Computer_ (RISC) : ARM Thumb, MIPS
+Peu d’instructions, faible emprunte silicium.
+- _Complex Instruction Set Computer_ (CISC) : Intel X86, ARMv8
+Instructions complexes simplifiantes. Énorme emprunte silicium.
+

Safety/cours.md

@@ -0,0 +1,52 @@
+# Dependable Computing, From basic concepts to critical applications | Sureté de fonctionnement
+
+contact : Jean-Charles Fabre | INP
+
+Tout système est sujet à ses défaillances internes, matérielle ou logicielles. Aucun système complexe est totalement sans failles.
+
+La sureté de fonctionnement correspond à l'ensemble des méthodes et techniques concernant les fautes accidentelles et intentionnelles d'un système.
+
+Comment procéder ?
+
+- Prévenir
+- Tolérer
+- Eliminer
+- Mesurer
+
+Souvent cela se matérialise par l'ajout de mécanisme d'auto défense dans un système sujet aux failles.
+
+Safety : Défense contre les défaillaces
+Sécurité : Défense contre les attaques
+
+# Basic concepts of dependable computing
+
+Les systèmes industriels complexe sont obligatoirement sujets aux erreurs/failures, qu'elles soient hardware ou software.
+
+Pour y pallier, il existe deux approches : 
+
+- Le développement zéro failure, vaste utopie rarement atteinte
+- Le développement orienté safety qui vise à intégrer des mécanismes de défense
+
+Une façon de mettre en place des mécanisme de safety, est d'intégrer une analyse des signaux pour détecter soit une réponse qui laisse entendre une failure, soit une absence de réponse. Ces signaux d'erreurs, sont finalement symptomatiques des fautes qui sont l'origine du problème. L'idéal est de pouvoir remonter à partir d'un signal d'erreur, directement à l'origine de la faute. 
+
+On distingue plusieurs propriétés qui permettent d'assurer la sécurité et la sureté de fonctionnement d'un système : 
+
+- Disponibilité
+- Fiabilité
+- Safety
+- Confidentialité
+- Intégrité
+- Réparabilité
+
+# Méthodes de tests
+
+A partir de l'identification des fautes hard et soft on peut avoir deux approches : 
+
+- Déterministe, ou l'on sélectionne les entreées
+- Probabliste
+
+# Représentation Markovienne
+
+On peut représenter l'état d'un système via une chaine de markov qui repose sur la probabilité de tel ou tel composant de lacher. 
+
+Certains systèmes n'ont en effet pas besoin d'être 100% fonctionnels pour fournir la QoS attendue.