diff --git a/README.md b/README.md index 675cd8f..4b888a2 100755 --- a/README.md +++ b/README.md @@ -8,4 +8,5 @@ Cours de Licence3 Semestre 2 - [Paradigmes de programmation](../paradigmesdeprogrammation/compiled/README.html) - [Théorie des langages et compilation](../theoriedeslangagesetcompilation/compiled/README.html) - [Systèmes distribués](../systemesdistribues/compiled/README.html) +- [Réseaux](../reseaux/compiled/README.html) - Anglais diff --git a/compiled/README.html b/compiled/README.html index 9616de4..0be360e 100755 --- a/compiled/README.html +++ b/compiled/README.html @@ -20,6 +20,7 @@
  • Paradigmes de programmation
  • Théorie des langages et compilation
  • Systèmes distribués
    • +
  • Réseaux
  • Anglais
    • diff --git a/paradigmesdeprogrammation/td/1.md b/paradigmesdeprogrammation/td/1.md new file mode 100644 index 0000000..495e1fc --- /dev/null +++ b/paradigmesdeprogrammation/td/1.md @@ -0,0 +1,174 @@ +### Exercice 1: + + Programme xx; + var i : entier init à 0; + A[] : tableau init à 0; + + procedure swap(x,y) + var z : entier; + + debut + z := x; + x := y; + y := z; + fin + + debut + i := 2; + A[2] := 99; + swap(i, A[i]); + fin + +#### Q: Quel est l'effet de l'appel `swap(i, A[i]);` + +1. Passage par valeur (`IN`) +2. ... / résultat (ADA) +3. ... / (ALGOLW) +4. ... par référence +5. ... par noms + + +**Notations:** + +* `a := b` notation affectation algo +* `a `$\leftarrow$` b` notation affectation interne + +#### Opérations d'affectation + + +`i := 2` (`i `$\leftarrow$` 2`); + +`A[2] := 99` (`A[2] `$\leftarrow$` 99`) + + + + +##### 1) Passage par valeur + +1. Execution de "IN" : Mettre la valeur dans les paramètres formels + * `x `$\leftarrow$` i` (`x `$\leftarrow$` 2`) + * `y `$\leftarrow$` A[2]` (`y `$\leftarrow$` 99`) +2. Execution du code + * `z := x;` (`z `$\leftarrow$` 2`) + * `x := y;` (`x `$\leftarrow$` 99`) + * `y := z;` (`y `$\leftarrow$` 2`) + +##### 2) Passage par valeur/résultat (IN OUT ADA) + +1. Calcul d'adressage + * $P_1$ ` = &i` + * $P_2$ ` = &A[i] = &A[2]` +2. Exécution du "IN" + * `x `$\leftarrow$` i` (`x `$\leftarrow$` 2`) + * `y `$\leftarrow$` A[2]` (`y `$\leftarrow$` 99`) +3. Exécution du code + * `z := x` (`z `$\leftarrow$` 2`) + * `x := y` (`x `$\leftarrow$` 99`) + * `y := z` (`y `$\leftarrow$` 2`) +4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs + * `i := 2` (`i `$\leftarrow$` 2`) + * `A[2] := 99` (`A[2] `$\leftarrow$` 99`) + * dans les paramètres effectifs **à travers le calcul d'adressage:** + * $P_1 \leftarrow$` x` (`i `$\leftarrow$` 99`) + * $P_2 \leftarrow$` y` (`A[2] `$\leftarrow$` 2`) + +Conclusion : `i` et `A[2]` ont été échangés et permutés + +##### 3) Passage par valeur/résultat (ALGOLW) + +Mêmes étapes que `2)`, mais dans l'ordre suivant : b, c, a, d + +##### 4) Passage de paramètre par référence + +**Notation** : Pour une variable `x`, on appelle : + +* `l.value` de `x`, son emplacement (adresse) _l(eft)_ +* `r.value`, la valeur de `x` _r(ight)_ +* mémo: `x := 10` (_left_ := _right_) + + +1. `l.value` de `x` est la même que celle de `i` + * `l.value` de `y` est la même que celle de `A[i]` c'est à dire `A[2]` +2. Exécution du code + * `z := x` (`z `$\leftarrow$` 2`) + * `x := y` (`x `$\leftarrow$` 99`) + * `y := z` (`A[2] `$\leftarrow$` 2`) + * **Conclusion:** `i` et `A[2]` on été permutés + + +##### 5) Passage pde paramètre par nom + +1. Substitution des paramètres formels par les paramètres effectifs de manière textuelle **sans évaluation** + * `z := x` $\rightarrow$ `z `$\leftarrow$` i` + * `x := y` $\rightarrow$ `i `$\leftarrow$` A[i]` + * `y := z` $\rightarrow$ `A[i] `$\leftarrow$` z` +2. Exécution du code + * `z := i` (`z `$\leftarrow$` 2` + * `i := A[i]` (`i `$\leftarrow$` A[2] `$\leftarrow$` 99`) + * `A[i] := z` (`A[99] `$\leftarrow$` 2`) +3. **Conclusion:** + * `i` a été changé + * `A[2]` inchangé mais + * `A[99]` a été modifié + + + +### Exercice 2 + + Procedure Quelmode(x) + A[1] := 6; + elt := 2; + x := x+3; + +* A[1] := 1 (A[1] $\leftarrow$ 1) +* A[2] := 2 (A[2] $\leftarrow$ 2) +* elt := 1 (elt $\leftarrow$ 1) + +##### 1) Appel par valeur + +1. Exécution du `IN` + * x $\leftarrow$ A[elt] (x $\leftarrow$ A[1] $\leftarrow$ 1) +2. Exécution du code + * A[1] := 6 (A[1] $\leftarrow$ 6) + * elt := 2 (elt $\leftarrow$ 2) + * x := x+3 (x $\leftarrow$ 4) +3. **Conclusion:** + * A[1] $\leftarrow$ 6 + * A[2] $\leftarrow$ 2 + * elt $\leftarrow$ 2 + +##### 2) Par valeur/résultat (IN OUT ADA) + +1. Calcul d'adressage + * $P_1$ ` = &A[1]` +2. Exécution du `IN` + * x <- A[1] (x <- 1) +3. Exécution du code + * A[1] := 6 + * elt := 2 + * x := x+3 (x <- 4) +4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs + * $P_1 \leftarrow $ A[1] (A[1] <- 4) + +##### 3) Par valeur/résultat (ALGOLW) + + +### Exercice 3: + + var elt : entier init à 1; + A[] : tableau d'entiers init à 0; + + Procedure quelmdoe(x, y) + debut + elt := elt + 1; + A[x] := 5+elt; + y := y+A[x]; + fin + + Procedure Inc() + debut + elt := elt + 1; + + return(elt); + fin + diff --git a/paradigmesdeprogrammation/td/compile b/paradigmesdeprogrammation/td/compile new file mode 100755 index 0000000..a7959af --- /dev/null +++ b/paradigmesdeprogrammation/td/compile @@ -0,0 +1,3 @@ +#!/bin/sh + +pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html diff --git a/paradigmesdeprogrammation/td/compiled/1.html b/paradigmesdeprogrammation/td/compiled/1.html new file mode 100644 index 0000000..5b99897 --- /dev/null +++ b/paradigmesdeprogrammation/td/compiled/1.html @@ -0,0 +1,175 @@ + + + + + + + + + + + + +

    Exercice 1:

    +
    Programme xx;
+var i : entier init à 0;
+A[] : tableau init à 0;
+
+procedure swap(x,y)
+    var z : entier;
+
+    debut
+        z := x;
+        x := y;
+        y := z;
+    fin
+
+debut
+    i := 2;
+    A[2] := 99;
+    swap(i, A[i]);
+fin
    +

    Q: Quel est l'effet de l'appel swap(i, A[i]);

    +
      +
    1. Passage par valeur (IN)
      2. +
    2. ... / résultat (ADA)
      3. +
    3. ... / (ALGOLW)
      4. +
    4. ... par référence
      5. +
    5. ... par noms
      6. +
    +

    Notations:

    + +

    Opérations d'affectation

    +

    i := 2 (i←2);

    +

    A[2] := 99 (A[2]←99)

    +
    1) Passage par valeur
    +
      +
    1. Execution de "IN" : Mettre la valeur dans les paramètres formels +
      2. +
    2. Execution du code +
      3. +
    +
    2) Passage par valeur/résultat (IN OUT ADA)
    +
      +
    1. Calcul d'adressage +
      2. +
    2. Exécution du "IN" +
      3. +
    3. Exécution du code +
      4. +
    4. Exécution du "OUT" : Mettre la valeur des paramètres effectifs +
      5. +
    +

    Conclusion : i et A[2] ont été échangés et permutés

    +
    3) Passage par valeur/résultat (ALGOLW)
    +

    Mêmes étapes que 2), mais dans l'ordre suivant : b, c, a, d

    +
    4) Passage de paramètre par référence
    +

    Notation : Pour une variable x, on appelle :

    + +
      +
    1. l.value de x est la même que celle de i +
      2. +
    2. Exécution du code +
      3. +
    +
    5) Passage pde paramètre par nom
    +
      +
    1. Substitution des paramètres formels par les paramètres effectifs de manière textuelle sans évaluation +
      2. +
    2. Exécution du code +
      3. +
    3. Conclusion: +
      4. +
    +

    Exercice 2

    +
    Procedure Quelmode(x)
+    A[1] := 6;
+    elt  := 2;
+    x    := x+3;
    +
    1) Appel par valeur
    + +
      +
    1. Exécution du IN +
      2. +
    2. Exécution du code +
      3. +
    3. Conclusion: +
      4. +
    +
    2) Par valeur/résultat
    +
      +
    1. Calcul d'adressage +
      2. +
    2. Exécution du IN
      3. +
    + + diff --git a/reseaux/README.md b/reseaux/README.md new file mode 100755 index 0000000..fc53e02 --- /dev/null +++ b/reseaux/README.md @@ -0,0 +1,12 @@ +Réseaux +------- + +#### Cours + +1. [Introduction - Notions et notes](../cours/compiled/introduction.html) +2. [Cours 1 - ](../cours/compiled/1.html) + +#### TDs + +#### TPs + diff --git a/reseaux/compiled/README.html b/reseaux/compiled/README.html new file mode 100755 index 0000000..a3c43f4 --- /dev/null +++ b/reseaux/compiled/README.html @@ -0,0 +1,24 @@ + + + + + + + + + + + + +

    Réseaux

    +

    Cours

    +
      +
    1. Introduction - Notions et notes
      2. +
    2. Cours 1 -
      3. +
    +

    TDs

    +

    TPs

    + + diff --git a/reseaux/cours/1.md b/reseaux/cours/1.md new file mode 100755 index 0000000..bd2adfc --- /dev/null +++ b/reseaux/cours/1.md @@ -0,0 +1,204 @@ +Cours 1 : Gestion de l'activité +=============================== + + +### Processus + + +#### Notion de processus +##### 1. Définition: +- activité/programme en exécution +- aspect actif vs. passif (programme/fichier) +- unité de travail dans la plupart des sys. + +##### 2. Objectif: +- exécution concurrente +- multiprogrammation +- temps partagé + + +#### Quelques aspects des processus +- les processus utilisent des ressources + - processeur + - mémoire + - I/O + - .. +- processus sys. vs. processus util. +- le S.E. est responsable de la gestion des processus: + - création + - destruction + - allocation de ressources + - ordonnancement + - synchronisation + - communication inter-processus + - .. +- processus à multiples flots de contrôle (threads) + + +Implantation d'un processus +--------------------------- + +##### 1. Eléments consistuants d'un processus: +|composante|description| +|--|--| +| section de texte |source en asm| +| compteur d'instructions |position actuelle dans le prog.| +| contenu des registres |dans le cache proc.| +| pile d'exécution |mémoire dynamique d'exécution| +| section des données |variables globales| + +_Remarque_: 2 processus peuvent exécuter le même programme mais ils ne partagent rien. + +##### 2. Bloc de contrôle d'un processus + + +----------+--------------------+ + | pointeur | état du processus | + +----------+--------------------+ + | numéro de processus | + +-------------------------------+ + | compteur de programme | + +-------------------------------+ + | registres | + +-------------------------------+ + | limites mémoire | + +-------------------------------+ + | liste des fichiers ouverts | + +-------------------------------+ + | ... | + +-------------------------------+ +_PCB: Process Control Bloc_ + +###### Contenu d'un PCB +- état courant du processus +- compteur d'instructions: adresse de la prochaine exécution à exécuter +- registres de processeur: doivent être sauvegardés afin de revenir au processus après interruption +- .. +- informations sur la gestion de mémoire: valeur des registres de base et de limite, tables de pages ou de segments +- information de comptabilisatio: temps CPU et réel, limite de temps, etc +- information de statut I/O: listes des périphériques alloués + +##### Etat d'un processus + +![Diagramme d'états](./diagrammeetat.png) + +_Remarque_: à un instant donné + +- un processus au plus est en exécution par le processeur +- plusieurs processus peuvent être prêts ou en attente + +##### Commutation de contexte +- c'est la sauvegarde de l'état du processus courant et le chargement de l'état sauvegardé d'un nouveau processus +- contexte = **PCB** +- cout de la commutation (temps perdu) varie d'une machine à l'autre (sur certaines machines: dispositifs spéciaux pour la copie des registres) : de 1 à 1000 us. +- aspect critique de l'efficacité d'un système !! + +![Schéma de commutation](./commutation.png) + + +##### Threads +- implémentent les flots d'exécution multiples (processus _multithreadés_ - multithreaded processes) +- intérêt: + - contrôle centralisé des différentes tâches (un seul processus) par le programmeur + - économie de mém. (la plupart des informations du PCB sont communes aux différents threads) + +##### Ordonnancement des processus +- Objectif: gérer l'accès concurrent aux ressources par les processus +- Gestion par files d'attentes + - file d'attente des travaux : tous les processus + - file d'attente des processus prêts (liste chainée de PCBs) + - file d'attente pour chaque périphérique + +##### Ordonnanceurs +1. **ordonnanceur** : programme chargé pour gérer l'ordonnancement +2. **ordrdonnanceur à long terme** : dans un contexte de traitement par lots (mode batch) +3. **ordrdonnanceur à court terme** : gère l'allocation du processeur (classique) +4. **ordrdonnanceur à moyen terme** : pour le swap (quand plus assez de mém. dans la mémoire centrale, il retire un processus et le transfère dans le HDD) + +##### Problèmes de systèmes interactifs +- sur certains systèmes interactifs comme Unix, il n'y a pas d'ordonnanceur long terme (logique) +- si trop de processus (en particulier si beaucoup d'util.) la mémoire ne peut plus les contenir tous +**Solutions** +- "Ejecter" des utilisateurs (bof bof) +- swap + +##### Ordonnanceur à moyen terme + +- Régule le _degré de multiprogrammation_ en implémentant un mécanisme de transfert de processus de la mém. vers les unités de stockage et inversement : _permutation_ ou _swap_ +- Critères: + - taux d'utilisation de la mém. principale (majorité du temps) + - dosage entre les processus usant du processeur et processus usant des I/O +- Algorithme assez couteux et donc fréquence d'exécution faible (plusieurs sec) + +##### Ordonnancement à court terme +- fréquence d'exécution élevée (`< 0.1s`) +- l'algorithme doit être efficace + +**exemple**: si temps d'exécution = `0.01s`, alors `9%` du temps perdu dans l'ordonnancement. + +##### Processus coopérants +- Intérêts: + - partage d'information + - accélération du calcul + - modularité + - commodité + - interactivité + +- Requiert des mécanismes permettant aux processus de coopérer + - exemple: producteur/consommateur + +##### Communication inter-processus +- Première solution: mémoire partagée + - pas évident dans le cadre général (implantation des mécanismes de protection mém. plus complexe) + - impossible dans un contexte distribué +- Seconde solution: fournir une fonctionnalité de communication interprocessus + (IPC: `InterProcess Communication`) + - communication + synchronisation + + +##### Implantation d'un IPC +- Par un système de passage de messages + - 2 primitives de base : `send` et `receive` +- Implantation logique vs. physique +- Implantation physique + - mémoire partagée + - bus matériel + - réseau +- Implantation logique + - communication directe ou indirecte + - communication symétrique ou asymétrique + - mise en tampon automatique ou explicite + - envoi par copie ou par référence + - messages de taille fixe ou variable + + +##### Nommage + +- Afin de pouvoir s'envoyer des messages les processus doivent pouvoir s'identifier et donc être nommés +- Communication directe + - symétrique + - `send(proc1,message)` / `receive(proc2,{message})` + - asymétrique + - `send(proc2,message)` / `receive({id_envoyeur},{message})` + - inconvénient: renommage d'un processus lourd à gérer (définition de tous ses liens à redéfinir) +- Communication indirecte + - utilisation d'une boite aux lettres (port) + - `send(A,message)` / `receive(A,message)` + - boites aux lettres publiques ou privées + - boite privée propriété du processus qui l'a créée qui est le seul habilité à la lire (sauf s'il transmet le droit) + - boite publique créée par le système + + +##### Synchronisation des processus +- Passage de message peut être synchrone ou asynchrone (bloquant ou non) + - envoi bloquant + - envoi non bloquant + - réception bloquante + - réception non bloquante +- Envoi et réception bloquants = rendez-vous + + +##### Mise en tampon +- Que la communication soit directe ou non, les messages sont stockés dans une file d'attente + - capacité zéro: revient à envoi bloquant + - capacité bornée: envoi bloquant si file pleine + - capacité non bornée: envoi non bloquant diff --git a/reseaux/cours/compile b/reseaux/cours/compile new file mode 100755 index 0000000..a7959af --- /dev/null +++ b/reseaux/cours/compile @@ -0,0 +1,3 @@ +#!/bin/sh + +pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html diff --git a/reseaux/cours/compiled/1.html b/reseaux/cours/compiled/1.html new file mode 100755 index 0000000..27e9d28 --- /dev/null +++ b/reseaux/cours/compiled/1.html @@ -0,0 +1,277 @@ + + + + + + + + + + + + +

    Cours 1 : Gestion de l'activité

    +

    Processus

    +

    Notion de processus

    +
    1. Définition:
    + +
    2. Objectif:
    + +

    Quelques aspects des processus

    + +

    Implantation d'un processus

    +
    1. Eléments consistuants d'un processus:
    + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
    composantedescription
    section de textesource en asm
    compteur d'instructionsposition actuelle dans le prog.
    contenu des registresdans le cache proc.
    pile d'exécutionmémoire dynamique d'exécution
    section des donnéesvariables globales
    +

    Remarque: 2 processus peuvent exécuter le même programme mais ils ne partagent rien.

    +
    2. Bloc de contrôle d'un processus
    +
    +----------+--------------------+
+| pointeur | état du processus  |
++----------+--------------------+
+| numéro de processus           |
++-------------------------------+
+| compteur de programme         |
++-------------------------------+
+| registres                     |
++-------------------------------+
+| limites mémoire               |
++-------------------------------+
+| liste des fichiers ouverts    |
++-------------------------------+
+| ...                           |
++-------------------------------+
    +

    PCB: Process Control Bloc

    +
    Contenu d'un PCB
    + +
    Etat d'un processus
    +
    +Diagramme d'états
    Diagramme d'états
    +
    +

    Remarque: à un instant donné

    + +
    Commutation de contexte
    + +
    +Schéma de commutation
    Schéma de commutation
    +
    +
    Threads
    + +
    Ordonnancement des processus
    + +
    Ordonnanceurs
    +
      +
    1. ordonnanceur : programme chargé pour gérer l'ordonnancement
      2. +
    2. ordrdonnanceur à long terme : dans un contexte de traitement par lots (mode batch)
      3. +
    3. ordrdonnanceur à court terme : gère l'allocation du processeur (classique)
      4. +
    4. ordrdonnanceur à moyen terme : pour le swap (quand plus assez de mém. dans la mémoire centrale, il retire un processus et le transfère dans le HDD)
      5. +
    +
    Problèmes de systèmes interactifs
    + +
    Ordonnanceur à moyen terme
    + +
    Ordonnancement à court terme
    + +

    exemple: si temps d'exécution = 0.01s, alors 9% du temps perdu dans l'ordonnancement.

    +
    Processus coopérants
    + +
    Communication inter-processus
    + +
    Implantation d'un IPC
    + +
    Nommage
    + +
    Synchronisation des processus
    + +
    Mise en tampon
    + + + diff --git a/reseaux/cours/compiled/commutation.png b/reseaux/cours/compiled/commutation.png new file mode 100755 index 0000000..894ab52 Binary files /dev/null and b/reseaux/cours/compiled/commutation.png differ diff --git a/reseaux/cours/compiled/diagrammeetat.png b/reseaux/cours/compiled/diagrammeetat.png new file mode 100755 index 0000000..5bc3670 Binary files /dev/null and b/reseaux/cours/compiled/diagrammeetat.png differ diff --git a/reseaux/cours/compiled/introduction.html b/reseaux/cours/compiled/introduction.html new file mode 100755 index 0000000..7f6c9e3 --- /dev/null +++ b/reseaux/cours/compiled/introduction.html @@ -0,0 +1,109 @@ + + + + + + + + + + + + +
    ... prendre sur lucas ...
    +

    Commutation de paquets : Multiplexage statistique

    +

    Le routeur via un algorithme (le multiplexage statistique) va tendre à : - servir équitablement chaque machine du réseau - maximiser le débit de chaque machine - minimaliser l'attente - gérer localement pour un résultat global (internet)

    +
    Exemple
    + +

    Réseaux à commutation de paquets : routage

    +
    Objectif
    +

    Transmettre des paquets de la source à la destination au travers de routeurs.

    +
    +

    Algorithmes de sélection de chemin

    +
    +
    Réseau datagramme
    + +
    +

    Analogie: Conduire en demandant plusieurs fois son chemin

    +
    +
    Réseau à circuit virtual
    + +

    Commutation de paquets ou de circuits

    +

    La commutation de paquets semble être meilleure car chaque machine est toujours servie (mais plus ou moins bien).

    + +

    Internet

    + +

    Processus communiquants

    +

    Processus

    +
    +

    Programme s'exécutant sur un hôte

    + +
    +

    Principes de base

    +
    +

    Processus client: Initie la communication

    +

    Processus serveur: attend d'être contacté

    +
    +

    Sockets

    +

    La socket est controllée par un processus pour utiliser TCP.

    +

    Ports

    +

    0 - 1023 → contrôlés par l'IANA, dénommés Well Known Ports.

    +

    1024 - 49151 → les ports enregistrés (Registered Ports) (pour serveurs)

    +

    49152 - 65535 → les ports dynamiques ou privés (clients).

    +

    Protocoles transport

    + + + diff --git a/reseaux/cours/introduction.md b/reseaux/cours/introduction.md new file mode 100755 index 0000000..a7bb2e7 --- /dev/null +++ b/reseaux/cours/introduction.md @@ -0,0 +1,110 @@ + + +``` +... prendre sur lucas ... +``` + + + + +### Commutation de paquets : Multiplexage statistique + + +Le routeur via un algorithme (le **multiplexage statistique**) va tendre à : +- servir équitablement chaque machine du réseau +- maximiser le débit de chaque machine +- minimaliser l'attente +- gérer localement pour un résultat global (internet) + +##### Exemple +- Lien à 1Mbps +- Utilisateur + - Emet 100kbps si actif + - Actif 10% du temps +- Commutation de circuits + - 10 utilisateurs concurrents +- Commutation de paquets + - Avec 35 utilisateurs : probabilité d'avoir plus de 10 acrifs < 0,0004 + - $\Sigma_{i=0}^{10} 0,1^i \times 0,9^{35-i} \times C^i_35$ + + +### Réseaux à commutation de paquets : routage + +##### Objectif +Transmettre des paquets de la source à la destination au travers de routeurs. + +> Algorithmes de sélection de chemin + +##### Réseau datagramme +* L'**adresse de destination** du paquet détermine le prochain saut +* La **route** peut changer au cours d'une session + +> Analogie: Conduire en demandant plusieurs fois son chemin + +##### Réseau à circuit virtual +* Chaque paquet porte un **tag** (identifiant du circuit virtuel) +* Le tag détermine le **prochain saut** +* Un chemin fixe déterminé à la connexion (reste fixe ensuite) +* Information consesrvée par les routeurs + + + + +### Commutation de paquets ou de circuits + +La commutation de paquets semble être meilleure car chaque machine est toujours servie (mais plus ou moins bien). + +* Bien pour les données éclatées + * Partage de ressources + * Plus simple, pas d'établissement de circuit +* **Congestion excessive** + * Perte et délai des paquets. + * Besoin de protocoles avec fiabilité de contrôle de congestion +* Peut-on simuler la commutation des circuits ? + * Applications audio/vidéo $\rightarrow$ besoin de bande passante garantie + * _Problème toujours ouvert_ + + +### Internet + +* Fournit aux applications des services en mode connecté (TCP) et en mode non-connecté (UDP). +* Est constitué d'un ensemble de réseaux à commutation de paquets. + + +# Processus communiquants + +### Processus + +> Programme s'exécutant sur un hôte +> +> * Sur un même hôte : **communication inter-processus** (définies par l'OS) +> * Entre deux hôtes : échange de **messages** entre processus + +### Principes de base + +> Processus client: Initie la communication +> +> Processus serveur: attend d'être contacté + + +### Sockets + +La socket est controllée par un processus pour utiliser TCP. + + +### Ports + +`0 - 1023` $\rightarrow$ contrôlés par l'IANA, dénommés _Well Known Ports_. + +`1024 - 49151` $\rightarrow$ les ports enregistrés (_Registered Ports_) (pour serveurs) + +`49152 - 65535` $\rightarrow$ les ports dynamiques ou privés (clients). + + + +### Protocoles transport + +* TCP - fiabilité +* UDP - rapidité +* DCCP (Datagram Congestion Control Protocol) : TCP avec gestion du flux (1paq/s) +* SCTP (Stream Control Transmission Protocol : Demande de réduction de débit diff --git a/theoriedeslangagesetcompilation/td/1.md b/theoriedeslangagesetcompilation/td/1.md new file mode 100644 index 0000000..95f33cb --- /dev/null +++ b/theoriedeslangagesetcompilation/td/1.md @@ -0,0 +1,117 @@ +Exercice 1 +========== + +On a vue en cours que le langage `PAIR` peut être défini par : + +* Définition 1: + * **base** : $2 \in PAIR$ + * **règle** : si $x \in PAIR$, alors $x+2 \in PAIR$ +* Définition 2: + * **base** : $2 \in PAIR$ + * **règle** : si $(x,y)\ \in PAIR^2$, alors $x+y \in PAIR$ + +### Question 1 + +> Vérifier que `16` est dans `PAIR` + + +##### En utilisant la *Définition 1* + +* $2 \in PAIR \rightarrow 2+2 = 4 \in PAIR$ +* $4 \in PAIR \rightarrow 4+2 = 6 \in PAIR$ +* $6 \in PAIR \rightarrow 6+2 = 8 \in PAIR$ +* $8 \in PAIR \rightarrow 8+2 = 10 \in PAIR$ +* $10 \in PAIR \rightarrow 10+2 = 12 \in PAIR$ +* $12 \in PAIR \rightarrow 12+2 = 14 \in PAIR$ +* $14 \in PAIR \rightarrow 14+2 = 16 \in PAIR$ + + +##### En utilisant la *Définition 2* + +* $2 \in PAIR \rightarrow 2+2 = 4 \in PAIR$ +* $8 \in PAIR \rightarrow 4+4 = 8 \in PAIR$ +* $8 \in PAIR \rightarrow 8+8 = 16 \in PAIR$ + + + + + + + +Exercice 2 +========== + +Soit $\Sigma=\{a, b, c\}$ et soit deux mots : $\omega = ababc$ et $q=caba$ + + +### Question 1 + +> 1. Calculer $\omega^0$ +> 2. $\omega^1$ +> 3. $\omega^2$ + + +> 1. $\omega^0 = \epsilon$ +> 2. $\omega^1 = \omega = ababc$ +> 3. $\omega^2 = \omega \omega = ababcababc$ + + +### Question 2 + +> Calculer $\omega q^2 \omega$ + +> $\omega q^2 \omega = \omega qq \omega = ababccabacabaababc$ + + +### Question 3 + +> 1. Calculer $|\omega|_{ab}$ +> 2. Calculer $|(ab)^4|$ +> 3. Calculer $|(ab)^4|_{aba}$ + + +> 1. $|\omega|_{ab} = 2$ +> 2. $|(ab)^4| = 4$ +> 3. $|(ab)^4|_{aba} = 3$ + + +### Question 4 + +> Donner pour q : +> +> 1. les préfixes +> 2. les préfixes propres +> 3. les suffixes +> 4. les suffixes propres + +> On a : +> +> 1. préfixes de q = $\{\epsilon,c,ca,cab,caba\}$ +> 2. préfixes propres de q = $\{\epsilon,c,ca,cab\}$ +> 3. suffixes de q = $\{caba,aba,ba,a,\epsilon\}$ +> 4. suffixes propres de q = $\{aba,ba,a,\epsilon\}$ + + +Exercice 3 +========== + +### Question 1 + +> Quels sont les 2 langages dont la fermeture en étoile donne le langage uniquement composé du mot vide $\epsilon$ ? + +> 1. $\{\epsilon\}$ +> 2. $\{\}$ + + +### Question 2 + +> Les mots suivants sont-ils générés par le langage $(ab^*)b^*$ : + + +> * $\epsilon \rightarrow a\epsilon\epsilon \rightarrow$ `FALSE` +> * $a \rightarrow a\epsilon\epsilon \rightarrow$ `TRUE` +> * $aa \rightarrow ab\epsilon \rightarrow$ `FALSE` +> * $ba \rightarrow ab\epsilon \rightarrow$ `FALSE` +> * $abbb \rightarrow ab^4 \epsilon = a\epsilon b^4 = ab^2b^2 = ... \rightarrow$ `TRUE` +> * $ababb \rightarrow ab^1 ... \rightarrow$ `FALSE` +> * $baba \rightarrow$ `FALSE` diff --git a/theoriedeslangagesetcompilation/td/compile b/theoriedeslangagesetcompilation/td/compile new file mode 100755 index 0000000..a7959af --- /dev/null +++ b/theoriedeslangagesetcompilation/td/compile @@ -0,0 +1,3 @@ +#!/bin/sh + +pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html diff --git a/theoriedeslangagesetcompilation/td/compiled/1.html b/theoriedeslangagesetcompilation/td/compiled/1.html new file mode 100644 index 0000000..8556b00 --- /dev/null +++ b/theoriedeslangagesetcompilation/td/compiled/1.html @@ -0,0 +1,134 @@ + + + + + + + + + + + + +

    Exercice 1

    +

    On a vue en cours que le langage PAIR peut être défini par :

    + +

    Question 1

    +
    +

    Vérifier que 16 est dans PAIR

    +
    +
    En utilisant la Définition 1
    + +
    En utilisant la Définition 2
    + +

    Exercice 2

    +

    Soit Σ = {a, b, c} et soit deux mots : ω = ababc et q = caba

    +

    Question 1

    +
    +
      +
    1. Calculer ω0
      2. +
    2. ω1
      3. +
    3. ω2
      4. +
    +
    +
    +
      +
    1. ω0 = ϵ
      2. +
    2. ω1 = ω = ababc
      3. +
    3. ω2 = ωω = ababcababc
      4. +
    +
    +

    Question 2

    +
    +

    Calculer ωq2ω

    +
    +
    +

    ωq2ω = ωqqω = ababccabacabaababc

    +
    +

    Question 3

    +
    +
      +
    1. Calculer |ω|ab
      2. +
    2. Calculer |(ab)4|
      3. +
    3. Calculer |(ab)4|aba
      4. +
    +
    +
    +
      +
    1. |ω|ab = 2
      2. +
    2. |(ab)4|=4
      3. +
    3. |(ab)4|aba = 3
      4. +
    +
    +

    Question 4

    +
    +

    Donner pour q :

    +
      +
    1. les préfixes
      2. +
    2. les préfixes propres
      3. +
    3. les suffixes
      4. +
    4. les suffixes propres
      5. +
    +
    +
    +

    On a :

    +
      +
    1. préfixes de q = {ϵ, c, ca, cab, caba}
      2. +
    2. préfixes propres de q = {ϵ, c, ca, cab}
      3. +
    3. suffixes de q = {caba, aba, ba, a, ϵ}
      4. +
    4. suffixes propres de q = {aba, ba, a, ϵ}
      5. +
    +
    +

    Exercice 3

    +

    Question 1

    +
    +

    Quels sont les 2 langages dont la fermeture en étoile donne le langage uniquement composé du mot vide ϵ ?

    +
    +
    +
      +
    1. {ϵ}
      2. +
    2. {}
      3. +
    +
    +

    Question 2

    +
    +

    Les mots suivants sont-ils générés par le langage (ab*)b* :

    +
    +
    + +
    + +