update
This commit is contained in:
xdrm-brackets
parent
e634f84579
commit
15adaa105b
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -20,6 +20,7 @@
|
|||
<li><a href="../paradigmesdeprogrammation/compiled/README.html">Paradigmes de programmation</a></li>
|
||||
<li><a href="../theoriedeslangagesetcompilation/compiled/README.html">Théorie des langages et compilation</a></li>
|
||||
<li><a href="../systemesdistribues/compiled/README.html">Systèmes distribués</a></li>
|
||||
<li><a href="../reseaux/compiled/README.html">Réseaux</a></li>
|
||||
<li>Anglais</li>
|
||||
</ul>
|
||||
</body>
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
#!/bin/sh
|
||||
|
||||
pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html
|
||||
|
|
@ -0,0 +1,175 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h3 id="exercice-1">Exercice 1:</h3>
|
||||
<pre><code>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</code></pre>
|
||||
<h4 id="q-quel-est-leffet-de-lappel-swapi-ai">Q: Quel est l'effet de l'appel <code>swap(i, A[i]);</code></h4>
|
||||
<ol type="1">
|
||||
<li>Passage par valeur (<code>IN</code>)</li>
|
||||
<li>... / résultat (ADA)</li>
|
||||
<li>... / (ALGOLW)</li>
|
||||
<li>... par référence</li>
|
||||
<li>... par noms</li>
|
||||
</ol>
|
||||
<p><strong>Notations:</strong></p>
|
||||
<ul>
|
||||
<li><code>a := b</code> notation affectation algo</li>
|
||||
<li><code>a</code><span class="math inline">←</span><code>b</code> notation affectation interne</li>
|
||||
</ul>
|
||||
<h4 id="opérations-daffectation">Opérations d'affectation</h4>
|
||||
<p><code>i := 2</code> (<code>i</code><span class="math inline">←</span><code>2</code>);</p>
|
||||
<p><code>A[2] := 99</code> (<code>A[2]</code><span class="math inline">←</span><code>99</code>)</p>
|
||||
<h5 id="passage-par-valeur">1) Passage par valeur</h5>
|
||||
<ol type="1">
|
||||
<li>Execution de "IN" : Mettre la valeur dans les paramètres formels
|
||||
<ul>
|
||||
<li><code>x</code><span class="math inline">←</span><code>i</code> (<code>x</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>y</code><span class="math inline">←</span><code>A[2]</code> (<code>y</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
</ul></li>
|
||||
<li>Execution du code
|
||||
<ul>
|
||||
<li><code>z := x;</code> (<code>z</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>x := y;</code> (<code>x</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li><code>y := z;</code> (<code>y</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
</ul></li>
|
||||
</ol>
|
||||
<h5 id="passage-par-valeurrésultat-in-out-ada">2) Passage par valeur/résultat (IN OUT ADA)</h5>
|
||||
<ol type="1">
|
||||
<li>Calcul d'adressage
|
||||
<ul>
|
||||
<li><span class="math inline"><em>P</em><sub>1</sub></span> <code>= &i</code></li>
|
||||
<li><span class="math inline"><em>P</em><sub>2</sub></span> <code>= &A[i] = &A[2]</code></li>
|
||||
</ul></li>
|
||||
<li>Exécution du "IN"
|
||||
<ul>
|
||||
<li><code>x</code><span class="math inline">←</span><code>i</code> (<code>x</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>y</code><span class="math inline">←</span><code>A[2]</code> (<code>y</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
</ul></li>
|
||||
<li>Exécution du code
|
||||
<ul>
|
||||
<li><code>z := x</code> (<code>z</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>x := y</code> (<code>x</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li><code>y := z</code> (<code>y</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
</ul></li>
|
||||
<li>Exécution du "OUT" : Mettre la valeur des paramètres effectifs
|
||||
<ul>
|
||||
<li><code>i := 2</code> (<code>i</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>A[2] := 99</code> (<code>A[2]</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li>dans les paramètres effectifs <strong>à travers le calcul d'adressage:</strong>
|
||||
<ul>
|
||||
<li><span class="math inline"><em>P</em><sub>1</sub>←</span><code>x</code> (<code>i</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li><span class="math inline"><em>P</em><sub>2</sub>←</span><code>y</code> (<code>A[2]</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
</ul></li>
|
||||
</ul></li>
|
||||
</ol>
|
||||
<p>Conclusion : <code>i</code> et <code>A[2]</code> ont été échangés et permutés</p>
|
||||
<h5 id="passage-par-valeurrésultat-algolw">3) Passage par valeur/résultat (ALGOLW)</h5>
|
||||
<p>Mêmes étapes que <code>2)</code>, mais dans l'ordre suivant : b, c, a, d</p>
|
||||
<h5 id="passage-de-paramètre-par-référence">4) Passage de paramètre par référence</h5>
|
||||
<p><strong>Notation</strong> : Pour une variable <code>x</code>, on appelle :</p>
|
||||
<ul>
|
||||
<li><code>l.value</code> de <code>x</code>, son emplacement (adresse) <em>l(eft)</em></li>
|
||||
<li><code>r.value</code>, la valeur de <code>x</code> <em>r(ight)</em></li>
|
||||
<li>mémo: <code>x := 10</code> (<em>left</em> := <em>right</em>)</li>
|
||||
</ul>
|
||||
<ol type="1">
|
||||
<li><code>l.value</code> de <code>x</code> est la même que celle de <code>i</code>
|
||||
<ul>
|
||||
<li><code>l.value</code> de <code>y</code> est la même que celle de <code>A[i]</code> c'est à dire <code>A[2]</code></li>
|
||||
</ul></li>
|
||||
<li>Exécution du code
|
||||
<ul>
|
||||
<li><code>z := x</code> (<code>z</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><code>x := y</code> (<code>x</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li><code>y := z</code> (<code>A[2]</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
<li><strong>Conclusion:</strong> <code>i</code> et <code>A[2]</code> on été permutés</li>
|
||||
</ul></li>
|
||||
</ol>
|
||||
<h5 id="passage-pde-paramètre-par-nom">5) Passage pde paramètre par nom</h5>
|
||||
<ol type="1">
|
||||
<li>Substitution des paramètres formels par les paramètres effectifs de manière textuelle <strong>sans évaluation</strong>
|
||||
<ul>
|
||||
<li><code>z := x</code> <span class="math inline">→</span> <code>z</code><span class="math inline">←</span><code>i</code></li>
|
||||
<li><code>x := y</code> <span class="math inline">→</span> <code>i</code><span class="math inline">←</span><code>A[i]</code></li>
|
||||
<li><code>y := z</code> <span class="math inline">→</span> <code>A[i]</code><span class="math inline">←</span><code>z</code></li>
|
||||
</ul></li>
|
||||
<li>Exécution du code
|
||||
<ul>
|
||||
<li><code>z := i</code> (<code>z</code><span class="math inline">←</span><code>2</code></li>
|
||||
<li><code>i := A[i]</code> (<code>i</code><span class="math inline">←</span><code>A[2]</code><span class="math inline">←</span><code>99</code>)</li>
|
||||
<li><code>A[i] := z</code> (<code>A[99]</code><span class="math inline">←</span><code>2</code>)</li>
|
||||
</ul></li>
|
||||
<li><strong>Conclusion:</strong>
|
||||
<ul>
|
||||
<li><code>i</code> a été changé</li>
|
||||
<li><code>A[2]</code> inchangé mais</li>
|
||||
<li><code>A[99]</code> a été modifié</li>
|
||||
</ul></li>
|
||||
</ol>
|
||||
<h3 id="exercice-2">Exercice 2</h3>
|
||||
<pre><code>Procedure Quelmode(x)
|
||||
A[1] := 6;
|
||||
elt := 2;
|
||||
x := x+3;</code></pre>
|
||||
<h5 id="appel-par-valeur">1) Appel par valeur</h5>
|
||||
<ul>
|
||||
<li>A[1] := 1 (A[1] <span class="math inline">←</span> 1)</li>
|
||||
<li>A[2] := 2 (A[2] <span class="math inline">←</span> 2)</li>
|
||||
<li>elt := 1 (elt <span class="math inline">←</span> 1)</li>
|
||||
</ul>
|
||||
<ol type="1">
|
||||
<li>Exécution du <code>IN</code>
|
||||
<ul>
|
||||
<li>x <span class="math inline">←</span> A[elt] (x <span class="math inline">←</span> A[1] <span class="math inline">←</span> 1)</li>
|
||||
</ul></li>
|
||||
<li>Exécution du code
|
||||
<ul>
|
||||
<li>A[1] := 6 (A[1] <span class="math inline">←</span> 6)</li>
|
||||
<li>elt := 2 (elt <span class="math inline">←</span> 2)</li>
|
||||
<li>x := x+3 (x <span class="math inline">←</span> 4)</li>
|
||||
</ul></li>
|
||||
<li><strong>Conclusion:</strong>
|
||||
<ul>
|
||||
<li>A[1] <span class="math inline">←</span> 6</li>
|
||||
<li>A[2] <span class="math inline">←</span> 2</li>
|
||||
<li>elt <span class="math inline">←</span> 2</li>
|
||||
</ul></li>
|
||||
</ol>
|
||||
<h5 id="par-valeurrésultat">2) Par valeur/résultat</h5>
|
||||
<ol type="1">
|
||||
<li>Calcul d'adressage
|
||||
<ul>
|
||||
<li><span class="math inline"><em>P</em><sub>1</sub></span> <code>= &A[1]</code></li>
|
||||
</ul></li>
|
||||
<li>Exécution du <code>IN</code></li>
|
||||
</ol>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -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
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h2 id="réseaux">Réseaux</h2>
|
||||
<h4 id="cours">Cours</h4>
|
||||
<ol type="1">
|
||||
<li><a href="../cours/compiled/introduction.html">Introduction - Notions et notes</a></li>
|
||||
<li><a href="../cours/compiled/1.html">Cours 1 -</a></li>
|
||||
</ol>
|
||||
<h4 id="tds">TDs</h4>
|
||||
<h4 id="tps">TPs</h4>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -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
|
||||
|
||||
|
||||
|
||||
_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 !!
|
||||
|
||||
|
||||
|
||||
|
||||
##### 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
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
#!/bin/sh
|
||||
|
||||
pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h1 id="cours-1-gestion-de-lactivité">Cours 1 : Gestion de l'activité</h1>
|
||||
<h3 id="processus">Processus</h3>
|
||||
<h4 id="notion-de-processus">Notion de processus</h4>
|
||||
<h5 id="définition">1. Définition:</h5>
|
||||
<ul>
|
||||
<li>activité/programme en exécution</li>
|
||||
<li>aspect actif vs. passif (programme/fichier)</li>
|
||||
<li>unité de travail dans la plupart des sys.</li>
|
||||
</ul>
|
||||
<h5 id="objectif">2. Objectif:</h5>
|
||||
<ul>
|
||||
<li>exécution concurrente</li>
|
||||
<li>multiprogrammation</li>
|
||||
<li>temps partagé</li>
|
||||
</ul>
|
||||
<h4 id="quelques-aspects-des-processus">Quelques aspects des processus</h4>
|
||||
<ul>
|
||||
<li>les processus utilisent des ressources
|
||||
<ul>
|
||||
<li>processeur</li>
|
||||
<li>mémoire</li>
|
||||
<li>I/O</li>
|
||||
<li>..</li>
|
||||
</ul></li>
|
||||
<li>processus sys. vs. processus util.</li>
|
||||
<li>le S.E. est responsable de la gestion des processus:
|
||||
<ul>
|
||||
<li>création</li>
|
||||
<li>destruction</li>
|
||||
<li>allocation de ressources</li>
|
||||
<li>ordonnancement</li>
|
||||
<li>synchronisation</li>
|
||||
<li>communication inter-processus</li>
|
||||
<li>..</li>
|
||||
</ul></li>
|
||||
<li>processus à multiples flots de contrôle (threads)</li>
|
||||
</ul>
|
||||
<h2 id="implantation-dun-processus">Implantation d'un processus</h2>
|
||||
<h5 id="eléments-consistuants-dun-processus">1. Eléments consistuants d'un processus:</h5>
|
||||
<table>
|
||||
<thead>
|
||||
<tr class="header">
|
||||
<th style="text-align: left;">composante</th>
|
||||
<th style="text-align: left;">description</th>
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
<tr class="odd">
|
||||
<td style="text-align: left;">section de texte</td>
|
||||
<td style="text-align: left;">source en asm</td>
|
||||
</tr>
|
||||
<tr class="even">
|
||||
<td style="text-align: left;">compteur d'instructions</td>
|
||||
<td style="text-align: left;">position actuelle dans le prog.</td>
|
||||
</tr>
|
||||
<tr class="odd">
|
||||
<td style="text-align: left;">contenu des registres</td>
|
||||
<td style="text-align: left;">dans le cache proc.</td>
|
||||
</tr>
|
||||
<tr class="even">
|
||||
<td style="text-align: left;">pile d'exécution</td>
|
||||
<td style="text-align: left;">mémoire dynamique d'exécution</td>
|
||||
</tr>
|
||||
<tr class="odd">
|
||||
<td style="text-align: left;">section des données</td>
|
||||
<td style="text-align: left;">variables globales</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
<p><em>Remarque</em>: 2 processus peuvent exécuter le même programme mais ils ne partagent rien.</p>
|
||||
<h5 id="bloc-de-contrôle-dun-processus">2. Bloc de contrôle d'un processus</h5>
|
||||
<pre><code>+----------+--------------------+
|
||||
| pointeur | état du processus |
|
||||
+----------+--------------------+
|
||||
| numéro de processus |
|
||||
+-------------------------------+
|
||||
| compteur de programme |
|
||||
+-------------------------------+
|
||||
| registres |
|
||||
+-------------------------------+
|
||||
| limites mémoire |
|
||||
+-------------------------------+
|
||||
| liste des fichiers ouverts |
|
||||
+-------------------------------+
|
||||
| ... |
|
||||
+-------------------------------+</code></pre>
|
||||
<p><em>PCB: Process Control Bloc</em></p>
|
||||
<h6 id="contenu-dun-pcb">Contenu d'un PCB</h6>
|
||||
<ul>
|
||||
<li>état courant du processus</li>
|
||||
<li>compteur d'instructions: adresse de la prochaine exécution à exécuter</li>
|
||||
<li>registres de processeur: doivent être sauvegardés afin de revenir au processus après interruption</li>
|
||||
<li>..</li>
|
||||
<li>informations sur la gestion de mémoire: valeur des registres de base et de limite, tables de pages ou de segments</li>
|
||||
<li>information de comptabilisatio: temps CPU et réel, limite de temps, etc</li>
|
||||
<li>information de statut I/O: listes des périphériques alloués</li>
|
||||
</ul>
|
||||
<h5 id="etat-dun-processus">Etat d'un processus</h5>
|
||||
<figure>
|
||||
<img src="./diagrammeetat.png" alt="Diagramme d'états" /><figcaption>Diagramme d'états</figcaption>
|
||||
</figure>
|
||||
<p><em>Remarque</em>: à un instant donné</p>
|
||||
<ul>
|
||||
<li>un processus au plus est en exécution par le processeur</li>
|
||||
<li>plusieurs processus peuvent être prêts ou en attente</li>
|
||||
</ul>
|
||||
<h5 id="commutation-de-contexte">Commutation de contexte</h5>
|
||||
<ul>
|
||||
<li>c'est la sauvegarde de l'état du processus courant et le chargement de l'état sauvegardé d'un nouveau processus</li>
|
||||
<li>contexte = <strong>PCB</strong></li>
|
||||
<li>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.</li>
|
||||
<li>aspect critique de l'efficacité d'un système !!</li>
|
||||
</ul>
|
||||
<figure>
|
||||
<img src="./commutation.png" alt="Schéma de commutation" /><figcaption>Schéma de commutation</figcaption>
|
||||
</figure>
|
||||
<h5 id="threads">Threads</h5>
|
||||
<ul>
|
||||
<li>implémentent les flots d'exécution multiples (processus <em>multithreadés</em> - multithreaded processes)</li>
|
||||
<li>intérêt:
|
||||
<ul>
|
||||
<li>contrôle centralisé des différentes tâches (un seul processus) par le programmeur</li>
|
||||
<li>économie de mém. (la plupart des informations du PCB sont communes aux différents threads)</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="ordonnancement-des-processus">Ordonnancement des processus</h5>
|
||||
<ul>
|
||||
<li>Objectif: gérer l'accès concurrent aux ressources par les processus</li>
|
||||
<li>Gestion par files d'attentes
|
||||
<ul>
|
||||
<li>file d'attente des travaux : tous les processus</li>
|
||||
<li>file d'attente des processus prêts (liste chainée de PCBs)</li>
|
||||
<li>file d'attente pour chaque périphérique</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="ordonnanceurs">Ordonnanceurs</h5>
|
||||
<ol type="1">
|
||||
<li><strong>ordonnanceur</strong> : programme chargé pour gérer l'ordonnancement</li>
|
||||
<li><strong>ordrdonnanceur à long terme</strong> : dans un contexte de traitement par lots (mode batch)</li>
|
||||
<li><strong>ordrdonnanceur à court terme</strong> : gère l'allocation du processeur (classique)</li>
|
||||
<li><strong>ordrdonnanceur à moyen terme</strong> : 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)</li>
|
||||
</ol>
|
||||
<h5 id="problèmes-de-systèmes-interactifs">Problèmes de systèmes interactifs</h5>
|
||||
<ul>
|
||||
<li>sur certains systèmes interactifs comme Unix, il n'y a pas d'ordonnanceur long terme (logique)</li>
|
||||
<li>si trop de processus (en particulier si beaucoup d'util.) la mémoire ne peut plus les contenir tous <strong>Solutions</strong></li>
|
||||
<li>"Ejecter" des utilisateurs (bof bof)</li>
|
||||
<li>swap</li>
|
||||
</ul>
|
||||
<h5 id="ordonnanceur-à-moyen-terme">Ordonnanceur à moyen terme</h5>
|
||||
<ul>
|
||||
<li>Régule le <em>degré de multiprogrammation</em> en implémentant un mécanisme de transfert de processus de la mém. vers les unités de stockage et inversement : <em>permutation</em> ou <em>swap</em></li>
|
||||
<li>Critères:
|
||||
<ul>
|
||||
<li>taux d'utilisation de la mém. principale (majorité du temps)</li>
|
||||
<li>dosage entre les processus usant du processeur et processus usant des I/O</li>
|
||||
</ul></li>
|
||||
<li>Algorithme assez couteux et donc fréquence d'exécution faible (plusieurs sec)</li>
|
||||
</ul>
|
||||
<h5 id="ordonnancement-à-court-terme">Ordonnancement à court terme</h5>
|
||||
<ul>
|
||||
<li>fréquence d'exécution élevée (<code>< 0.1s</code>)</li>
|
||||
<li>l'algorithme doit être efficace</li>
|
||||
</ul>
|
||||
<p><strong>exemple</strong>: si temps d'exécution = <code>0.01s</code>, alors <code>9%</code> du temps perdu dans l'ordonnancement.</p>
|
||||
<h5 id="processus-coopérants">Processus coopérants</h5>
|
||||
<ul>
|
||||
<li>Intérêts:
|
||||
<ul>
|
||||
<li>partage d'information</li>
|
||||
<li>accélération du calcul</li>
|
||||
<li>modularité</li>
|
||||
<li>commodité</li>
|
||||
<li>interactivité</li>
|
||||
</ul></li>
|
||||
<li>Requiert des mécanismes permettant aux processus de coopérer
|
||||
<ul>
|
||||
<li>exemple: producteur/consommateur</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="communication-inter-processus">Communication inter-processus</h5>
|
||||
<ul>
|
||||
<li>Première solution: mémoire partagée
|
||||
<ul>
|
||||
<li>pas évident dans le cadre général (implantation des mécanismes de protection mém. plus complexe)</li>
|
||||
<li>impossible dans un contexte distribué</li>
|
||||
</ul></li>
|
||||
<li>Seconde solution: fournir une fonctionnalité de communication interprocessus<br />
|
||||
(IPC: <code>InterProcess Communication</code>)
|
||||
<ul>
|
||||
<li>communication + synchronisation</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="implantation-dun-ipc">Implantation d'un IPC</h5>
|
||||
<ul>
|
||||
<li>Par un système de passage de messages
|
||||
<ul>
|
||||
<li>2 primitives de base : <code>send</code> et <code>receive</code></li>
|
||||
</ul></li>
|
||||
<li>Implantation logique vs. physique</li>
|
||||
<li>Implantation physique
|
||||
<ul>
|
||||
<li>mémoire partagée</li>
|
||||
<li>bus matériel</li>
|
||||
<li>réseau</li>
|
||||
</ul></li>
|
||||
<li>Implantation logique
|
||||
<ul>
|
||||
<li>communication directe ou indirecte</li>
|
||||
<li>communication symétrique ou asymétrique</li>
|
||||
<li>mise en tampon automatique ou explicite</li>
|
||||
<li>envoi par copie ou par référence</li>
|
||||
<li>messages de taille fixe ou variable</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="nommage">Nommage</h5>
|
||||
<ul>
|
||||
<li>Afin de pouvoir s'envoyer des messages les processus doivent pouvoir s'identifier et donc être nommés</li>
|
||||
<li>Communication directe
|
||||
<ul>
|
||||
<li>symétrique
|
||||
<ul>
|
||||
<li><code>send(proc1,message)</code> / <code>receive(proc2,{message})</code></li>
|
||||
</ul></li>
|
||||
<li>asymétrique
|
||||
<ul>
|
||||
<li><code>send(proc2,message)</code> / <code>receive({id_envoyeur},{message})</code></li>
|
||||
</ul></li>
|
||||
<li>inconvénient: renommage d'un processus lourd à gérer (définition de tous ses liens à redéfinir)</li>
|
||||
</ul></li>
|
||||
<li>Communication indirecte
|
||||
<ul>
|
||||
<li>utilisation d'une boite aux lettres (port)</li>
|
||||
<li><code>send(A,message)</code> / <code>receive(A,message)</code></li>
|
||||
<li>boites aux lettres publiques ou privées
|
||||
<ul>
|
||||
<li>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)</li>
|
||||
<li>boite publique créée par le système</li>
|
||||
</ul></li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h5 id="synchronisation-des-processus">Synchronisation des processus</h5>
|
||||
<ul>
|
||||
<li>Passage de message peut être synchrone ou asynchrone (bloquant ou non)
|
||||
<ul>
|
||||
<li>envoi bloquant</li>
|
||||
<li>envoi non bloquant</li>
|
||||
<li>réception bloquante</li>
|
||||
<li>réception non bloquante</li>
|
||||
</ul></li>
|
||||
<li>Envoi et réception bloquants = rendez-vous</li>
|
||||
</ul>
|
||||
<h5 id="mise-en-tampon">Mise en tampon</h5>
|
||||
<ul>
|
||||
<li>Que la communication soit directe ou non, les messages sont stockés dans une file d'attente
|
||||
<ul>
|
||||
<li>capacité zéro: revient à envoi bloquant</li>
|
||||
<li>capacité bornée: envoi bloquant si file pleine</li>
|
||||
<li>capacité non bornée: envoi non bloquant</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
</body>
|
||||
</html>
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 171 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 476 KiB |
|
|
@ -0,0 +1,109 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<pre><code>... prendre sur lucas ...</code></pre>
|
||||
<h3 id="commutation-de-paquets-multiplexage-statistique">Commutation de paquets : Multiplexage statistique</h3>
|
||||
<p>Le routeur via un algorithme (le <strong>multiplexage statistique</strong>) 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)</p>
|
||||
<h5 id="exemple">Exemple</h5>
|
||||
<ul>
|
||||
<li>Lien à 1Mbps</li>
|
||||
<li>Utilisateur
|
||||
<ul>
|
||||
<li>Emet 100kbps si actif</li>
|
||||
<li>Actif 10% du temps</li>
|
||||
</ul></li>
|
||||
<li>Commutation de circuits
|
||||
<ul>
|
||||
<li>10 utilisateurs concurrents</li>
|
||||
</ul></li>
|
||||
<li>Commutation de paquets
|
||||
<ul>
|
||||
<li>Avec 35 utilisateurs : probabilité d'avoir plus de 10 acrifs < 0,0004</li>
|
||||
<li><span class="math inline"><em>Σ</em><sub><em>i</em> = 0</sub><sup>10</sup>0, 1<sup><em>i</em></sup> × 0, 9<sup>35 − <em>i</em></sup> × <em>C</em><sub>35</sub><sup><em>i</em></sup></span></li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h3 id="réseaux-à-commutation-de-paquets-routage">Réseaux à commutation de paquets : routage</h3>
|
||||
<h5 id="objectif">Objectif</h5>
|
||||
<p>Transmettre des paquets de la source à la destination au travers de routeurs.</p>
|
||||
<blockquote>
|
||||
<p>Algorithmes de sélection de chemin</p>
|
||||
</blockquote>
|
||||
<h5 id="réseau-datagramme">Réseau datagramme</h5>
|
||||
<ul>
|
||||
<li>L'<strong>adresse de destination</strong> du paquet détermine le prochain saut</li>
|
||||
<li>La <strong>route</strong> peut changer au cours d'une session</li>
|
||||
</ul>
|
||||
<blockquote>
|
||||
<p>Analogie: Conduire en demandant plusieurs fois son chemin</p>
|
||||
</blockquote>
|
||||
<h5 id="réseau-à-circuit-virtual">Réseau à circuit virtual</h5>
|
||||
<ul>
|
||||
<li>Chaque paquet porte un <strong>tag</strong> (identifiant du circuit virtuel)</li>
|
||||
<li>Le tag détermine le <strong>prochain saut</strong></li>
|
||||
<li>Un chemin fixe déterminé à la connexion (reste fixe ensuite)</li>
|
||||
<li>Information consesrvée par les routeurs</li>
|
||||
</ul>
|
||||
<h3 id="commutation-de-paquets-ou-de-circuits">Commutation de paquets ou de circuits</h3>
|
||||
<p>La commutation de paquets semble être meilleure car chaque machine est toujours servie (mais plus ou moins bien).</p>
|
||||
<ul>
|
||||
<li>Bien pour les données éclatées
|
||||
<ul>
|
||||
<li>Partage de ressources</li>
|
||||
<li>Plus simple, pas d'établissement de circuit</li>
|
||||
</ul></li>
|
||||
<li><strong>Congestion excessive</strong>
|
||||
<ul>
|
||||
<li>Perte et délai des paquets.</li>
|
||||
<li>Besoin de protocoles avec fiabilité de contrôle de congestion</li>
|
||||
</ul></li>
|
||||
<li>Peut-on simuler la commutation des circuits ?
|
||||
<ul>
|
||||
<li>Applications audio/vidéo <span class="math inline">→</span> besoin de bande passante garantie</li>
|
||||
<li><em>Problème toujours ouvert</em></li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h3 id="internet">Internet</h3>
|
||||
<ul>
|
||||
<li>Fournit aux applications des services en mode connecté (TCP) et en mode non-connecté (UDP).</li>
|
||||
<li>Est constitué d'un ensemble de réseaux à commutation de paquets.</li>
|
||||
</ul>
|
||||
<h1 id="processus-communiquants">Processus communiquants</h1>
|
||||
<h3 id="processus">Processus</h3>
|
||||
<blockquote>
|
||||
<p>Programme s'exécutant sur un hôte</p>
|
||||
<ul>
|
||||
<li>Sur un même hôte : <strong>communication inter-processus</strong> (définies par l'OS)</li>
|
||||
<li>Entre deux hôtes : échange de <strong>messages</strong> entre processus</li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
<h3 id="principes-de-base">Principes de base</h3>
|
||||
<blockquote>
|
||||
<p>Processus client: Initie la communication</p>
|
||||
<p>Processus serveur: attend d'être contacté</p>
|
||||
</blockquote>
|
||||
<h3 id="sockets">Sockets</h3>
|
||||
<p>La socket est controllée par un processus pour utiliser TCP.</p>
|
||||
<h3 id="ports">Ports</h3>
|
||||
<p><code>0 - 1023</code> <span class="math inline">→</span> contrôlés par l'IANA, dénommés <em>Well Known Ports</em>.</p>
|
||||
<p><code>1024 - 49151</code> <span class="math inline">→</span> les ports enregistrés (<em>Registered Ports</em>) (pour serveurs)</p>
|
||||
<p><code>49152 - 65535</code> <span class="math inline">→</span> les ports dynamiques ou privés (clients).</p>
|
||||
<h3 id="protocoles-transport">Protocoles transport</h3>
|
||||
<ul>
|
||||
<li>TCP - fiabilité</li>
|
||||
<li>UDP - rapidité</li>
|
||||
<li>DCCP (Datagram Congestion Control Protocol) : TCP avec gestion du flux (1paq/s)</li>
|
||||
<li>SCTP (Stream Control Transmission Protocol : Demande de réduction de débit</li>
|
||||
</ul>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -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
|
||||
|
|
@ -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`
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
#!/bin/sh
|
||||
|
||||
pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css $1.md -o compiled/$1.html
|
||||
|
|
@ -0,0 +1,134 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h1 id="exercice-1">Exercice 1</h1>
|
||||
<p>On a vue en cours que le langage <code>PAIR</code> peut être défini par :</p>
|
||||
<ul>
|
||||
<li>Définition 1:
|
||||
<ul>
|
||||
<li><strong>base</strong> : <span class="math inline">2 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><strong>règle</strong> : si <span class="math inline"><em>x</em> ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span>, alors <span class="math inline"><em>x</em> + 2 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ul></li>
|
||||
<li>Définition 2:
|
||||
<ul>
|
||||
<li><strong>base</strong> : <span class="math inline">2 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><strong>règle</strong> : si <span class="math inline">(<em>x</em>, <em>y</em>) ∈ <em>P</em><em>A</em><em>I</em><em>R</em><sup>2</sup></span>, alors <span class="math inline"><em>x</em> + <em>y</em> ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h3 id="question-1">Question 1</h3>
|
||||
<blockquote>
|
||||
<p>Vérifier que <code>16</code> est dans <code>PAIR</code></p>
|
||||
</blockquote>
|
||||
<h5 id="en-utilisant-la-définition-1">En utilisant la <em>Définition 1</em></h5>
|
||||
<ul>
|
||||
<li><span class="math inline">2 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 2 + 2 = 4 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">4 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 4 + 2 = 6 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">6 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 6 + 2 = 8 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">8 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 8 + 2 = 10 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">10 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 10 + 2 = 12 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">12 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 12 + 2 = 14 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">14 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 14 + 2 = 16 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ul>
|
||||
<h5 id="en-utilisant-la-définition-2">En utilisant la <em>Définition 2</em></h5>
|
||||
<ul>
|
||||
<li><span class="math inline">2 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 2 + 2 = 4 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">8 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 4 + 4 = 8 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li><span class="math inline">8 ∈ <em>P</em><em>A</em><em>I</em><em>R</em> → 8 + 8 = 16 ∈ <em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ul>
|
||||
<h1 id="exercice-2">Exercice 2</h1>
|
||||
<p>Soit <span class="math inline"><em>Σ</em> = {<em>a</em>, <em>b</em>, <em>c</em>}</span> et soit deux mots : <span class="math inline"><em>ω</em> = <em>a</em><em>b</em><em>a</em><em>b</em><em>c</em></span> et <span class="math inline"><em>q</em> = <em>c</em><em>a</em><em>b</em><em>a</em></span></p>
|
||||
<h3 id="question-1-1">Question 1</h3>
|
||||
<blockquote>
|
||||
<ol type="1">
|
||||
<li>Calculer <span class="math inline"><em>ω</em><sup>0</sup></span></li>
|
||||
<li><span class="math inline"><em>ω</em><sup>1</sup></span></li>
|
||||
<li><span class="math inline"><em>ω</em><sup>2</sup></span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ol type="1">
|
||||
<li><span class="math inline"><em>ω</em><sup>0</sup> = <em>ϵ</em></span></li>
|
||||
<li><span class="math inline"><em>ω</em><sup>1</sup> = <em>ω</em> = <em>a</em><em>b</em><em>a</em><em>b</em><em>c</em></span></li>
|
||||
<li><span class="math inline"><em>ω</em><sup>2</sup> = <em>ω</em><em>ω</em> = <em>a</em><em>b</em><em>a</em><em>b</em><em>c</em><em>a</em><em>b</em><em>a</em><em>b</em><em>c</em></span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<h3 id="question-2">Question 2</h3>
|
||||
<blockquote>
|
||||
<p>Calculer <span class="math inline"><em>ω</em><em>q</em><sup>2</sup><em>ω</em></span></p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<p><span class="math inline"><em>ω</em><em>q</em><sup>2</sup><em>ω</em> = <em>ω</em><em>q</em><em>q</em><em>ω</em> = <em>a</em><em>b</em><em>a</em><em>b</em><em>c</em><em>c</em><em>a</em><em>b</em><em>a</em><em>c</em><em>a</em><em>b</em><em>a</em><em>a</em><em>b</em><em>a</em><em>b</em><em>c</em></span></p>
|
||||
</blockquote>
|
||||
<h3 id="question-3">Question 3</h3>
|
||||
<blockquote>
|
||||
<ol type="1">
|
||||
<li>Calculer <span class="math inline">|<em>ω</em>|<sub><em>a</em><em>b</em></sub></span></li>
|
||||
<li>Calculer <span class="math inline">|(<em>a</em><em>b</em>)<sup>4</sup>|</span></li>
|
||||
<li>Calculer <span class="math inline">|(<em>a</em><em>b</em>)<sup>4</sup>|<sub><em>a</em><em>b</em><em>a</em></sub></span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ol type="1">
|
||||
<li><span class="math inline">|<em>ω</em>|<sub><em>a</em><em>b</em></sub> = 2</span></li>
|
||||
<li><span class="math inline">|(<em>a</em><em>b</em>)<sup>4</sup>|=4</span></li>
|
||||
<li><span class="math inline">|(<em>a</em><em>b</em>)<sup>4</sup>|<sub><em>a</em><em>b</em><em>a</em></sub> = 3</span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<h3 id="question-4">Question 4</h3>
|
||||
<blockquote>
|
||||
<p>Donner pour q :</p>
|
||||
<ol type="1">
|
||||
<li>les préfixes</li>
|
||||
<li>les préfixes propres</li>
|
||||
<li>les suffixes</li>
|
||||
<li>les suffixes propres</li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<p>On a :</p>
|
||||
<ol type="1">
|
||||
<li>préfixes de q = <span class="math inline">{<em>ϵ</em>, <em>c</em>, <em>c</em><em>a</em>, <em>c</em><em>a</em><em>b</em>, <em>c</em><em>a</em><em>b</em><em>a</em>}</span></li>
|
||||
<li>préfixes propres de q = <span class="math inline">{<em>ϵ</em>, <em>c</em>, <em>c</em><em>a</em>, <em>c</em><em>a</em><em>b</em>}</span></li>
|
||||
<li>suffixes de q = <span class="math inline">{<em>c</em><em>a</em><em>b</em><em>a</em>, <em>a</em><em>b</em><em>a</em>, <em>b</em><em>a</em>, <em>a</em>, <em>ϵ</em>}</span></li>
|
||||
<li>suffixes propres de q = <span class="math inline">{<em>a</em><em>b</em><em>a</em>, <em>b</em><em>a</em>, <em>a</em>, <em>ϵ</em>}</span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<h1 id="exercice-3">Exercice 3</h1>
|
||||
<h3 id="question-1-2">Question 1</h3>
|
||||
<blockquote>
|
||||
<p>Quels sont les 2 langages dont la fermeture en étoile donne le langage uniquement composé du mot vide <span class="math inline"><em>ϵ</em></span> ?</p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ol type="1">
|
||||
<li><span class="math inline">{<em>ϵ</em>}</span></li>
|
||||
<li><span class="math inline">{}</span></li>
|
||||
</ol>
|
||||
</blockquote>
|
||||
<h3 id="question-2-1">Question 2</h3>
|
||||
<blockquote>
|
||||
<p>Les mots suivants sont-ils générés par le langage <span class="math inline">(<em>a</em><em>b</em><sup>*</sup>)<em>b</em><sup>*</sup></span> :</p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ul>
|
||||
<li><span class="math inline"><em>ϵ</em> → <em>a</em><em>ϵ</em><em>ϵ</em>→</span> <code>FALSE</code></li>
|
||||
<li><span class="math inline"><em>a</em> → <em>a</em><em>ϵ</em><em>ϵ</em>→</span> <code>TRUE</code></li>
|
||||
<li><span class="math inline"><em>a</em><em>a</em> → <em>a</em><em>b</em><em>ϵ</em>→</span> <code>FALSE</code></li>
|
||||
<li><span class="math inline"><em>b</em><em>a</em> → <em>a</em><em>b</em><em>ϵ</em>→</span> <code>FALSE</code></li>
|
||||
<li><span class="math inline"><em>a</em><em>b</em><em>b</em><em>b</em> → <em>a</em><em>b</em><sup>4</sup><em>ϵ</em> = <em>a</em><em>ϵ</em><em>b</em><sup>4</sup> = <em>a</em><em>b</em><sup>2</sup><em>b</em><sup>2</sup> = ...→</span> <code>TRUE</code></li>
|
||||
<li><span class="math inline"><em>a</em><em>b</em><em>a</em><em>b</em><em>b</em> → <em>a</em><em>b</em><sup>1</sup>...→</span> <code>FALSE</code></li>
|
||||
<li><span class="math inline"><em>b</em><em>a</em><em>b</em><em>a</em>→</span> <code>FALSE</code></li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
</body>
|
||||
</html>
|
||||
Loading…
Reference in New Issue