progsyst: publish project topic
authorStefano Zacchiroli <zack@upsilon.cc>
Wed, 4 Feb 2015 16:48:01 +0000 (17:48 +0100)
committerStefano Zacchiroli <zack@upsilon.cc>
Wed, 4 Feb 2015 16:48:01 +0000 (17:48 +0100)
teaching/1415/progsyst.mdwn
teaching/1415/progsyst/projet/index.css [new file with mode: 0644]
teaching/1415/progsyst/projet/index.html [new file with mode: 0644]

index f2e7a6d..b27d0c2 100644 (file)
@@ -34,6 +34,11 @@ concernant le projet doit être envoyée sur le
 * *Linux System Programming*, Robert Love. O'Reilly Media, 2007.
 
 
+## Projet
+
+* [[sujet|projet/index.html]]
+
+
 ## Transparents
 
 [[!inline
diff --git a/teaching/1415/progsyst/projet/index.css b/teaching/1415/progsyst/projet/index.css
new file mode 100644 (file)
index 0000000..83db291
--- /dev/null
@@ -0,0 +1,67 @@
+body {
+         background : #708090;
+         font-family : Arial, Verdana, sans-serif;
+}
+
+.bloc {
+  width: 80%; 
+  margin: 40px auto; 
+  background: #CCCCCC; 
+  border: 2px solid #104E8B;    /* DodgerBlue4  */ 
+  padding: 20px 50px; /*text-align: center;*/
+}
+
+.ssbloc {
+  width: 95%; 
+  /*margin: 0 auto; */
+  margin: 20px auto; 
+  background: #AAAAAA; 
+  border: 2px solid #104E8B;    /* DodgerBlue4  */ 
+  padding: 20px; /*text-align: center;*/
+  /*padding-top: 0;*/
+}
+
+.titre{
+  font-size : 110%; 
+  color : #104E8B;              /* DodgerBlue4  */
+} 
+
+h1{
+  font-size : 150%;
+  color : #104E8B;              /* DodgerBlue4  */
+}
+
+
+h2{
+  font-size : 125%;
+  color : #104E8B;              /* DodgerBlue4  */
+}
+
+h3{
+  font-size : 110%;
+  color : #104E8B;              /* DodgerBlue4  */
+}
+
+b{
+  color : #104E8B;   
+}
+
+code {
+  font-size : 120%;
+  color : #446666;
+  font-weight : bold;
+}
+var {
+  font-size : 100%;
+  font-weight : bold;
+  color : steelblue;
+}
+
+td {
+  padding-left : 10px;
+  padding-right : 10px;
+}
+
+dt {
+  margin : 5px 0;
+}
diff --git a/teaching/1415/progsyst/projet/index.html b/teaching/1415/progsyst/projet/index.html
new file mode 100644 (file)
index 0000000..e150120
--- /dev/null
@@ -0,0 +1,249 @@
+<!--?xml version="1.0" encoding="UTF-8"?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<link rel="stylesheet" type="text/css" href="index.css">
+<meta http-equiv="content-type" content="text/html; charset=UTF-8">
+  <title>Projet Programmation système 2014-2015</title>
+</head>
+
+<body>
+
+  <div class="bloc">
+<h1><span style="font-weight: bold;">Projet Programmation système (M1 2014-2015)</span></h1>
+
+<h1>Appels de Procédures Distantes, en version &laquo;&thinsp;locale&thinsp;&raquo;</h1>
+</div>
+
+<div class="bloc">
+<h2>But du projet</h2>
+
+  <p>On vous demande de réaliser (en C) un système permettant à diverses
+  applications de partager leurs compétences, en autorisant chaque
+  application à faire appel à des fonctions définies par les autres. Ce
+  mécanisme est appelé <em>Remote Procedure Call</em> ou <em>RPC</em>
+  dans son cadre général &ndash; appel à des procédures définies par une
+  application tournant <em>a priori</em> sur un serveur distant. Nous
+  nous contenterons ici d'une version locale, limitée à une seule
+  machine.
+  </p>
+
+  <p>Deux modèles sont à envisager&thinsp;:</p>
+
+  <div class="ssbloc">
+    <b><big>le modèle client/serveur</big></b>
+    dans lequel un seul serveur héberge les procédures et a pour unique
+    rôle de répondre aux requêtes de calcul&thinsp;; les clients s'adressent
+    donc systématiquement au serveur pour obtenir un calcul particulier.
+  </div>
+
+  <div class="ssbloc">
+    <b><big> le modèle distribué</big></b>
+    dans lequel chaque processus fait profiter les autres de ses
+    compétences particulières&thinsp;: chacun déclare publiquement les services
+    qu'il peut offrir, et joue alternativement le rôle du client (s'il a besoin
+    de faire effectuer un calcul par un autre processus) et du serveur
+    (si un autre processus lui demande un service).
+  </div>
+</div>
+
+<div class="bloc">
+  <h2>Modèle client/serveur</h2>
+
+  <p>Dans ce modèle, un seul processus répond aux requêtes de calcul des autres
+  processus impliqués&thinsp;; il doit traiter toutes les requêtes reçues,
+  et renvoyer à chaque demandeur le résultat du calcul correspondant. Le
+  serveur a donc trois types de tâches à effectuer&thinsp;:
+  <ul>
+    <li> lire les requêtes<!---- (par exemple sur un tube nommé)---->&thinsp;; </li>
+    <li> exécuter les calculs nécessaires&thinsp;;</li>
+    <li> transmettre le résultat<!---- (par exemple via un &ndash; autre
+    &ndash; tube nommé)---->.</li>
+  </ul>
+  </p>
+
+  <p> Dans l'hypothèse où un client demanderait un long calcul tandis que
+  d'autres ont des requêtes plus raisonnables, il est souhaitable que le
+  serveur ne reste pas bloqué sur le gros calcul. Une solution consiste à
+  déléguer une partie du travail (choisie selon une procédure à définir)
+  à un processus fils ou à un thread pour une exécution
+  <em>asynchrone</em>. Il pourrait aussi être envisagé d'interrompre les
+  calculs trop longs.</p>
+
+  <p>
+  Le format exact des messages transmis entre les différents processus
+  n'est pas spécifié, mis à part les conventions de sérialisation de
+  certains types (voir ci-dessous). À vous de définir en particulier le
+  format des requêtes.
+  </p>
+</div>
+
+
+<div class="bloc">
+  <h2>Modèle distribué</h2>
+
+  <p> Dans ce modèle, tout processus peut déclarer publiquement quels
+  calculs il sait effectuer, et tout processus peut lui adresser une
+  requête en ce sens. Ce rôle de &laquo;&thinsp;serveur&thinsp;&raquo;
+  vient en parallèle du rôle premier de ces processus, qui peut
+  nécessiter une interaction avec un utilisateur. Vous pouvez par exemple
+  penser à des petites calculatrices autorisant l'utilisateur à demander
+  d'évaluer n'importe quelle expression arithmétique, alors que chacune
+  ne &laquo;&thinsp;sait&thinsp;&raquo; effectuer qu'un type d'opération.</p>
+
+  <p> Cette déclaration publique nécessite une certaine
+  centralisation, pour que les processus sachent <em>où</em> trouver
+  les informations nécessaires à un appel de fonction externe, en
+  particulier&thinsp;:
+  <ul>
+    <li> quel(s) processus offre(nt) le service souhaité&thinsp;;</li>
+    <li> par quel canal la requête doit être adressée.</li>
+  </ul>
+  </p>
+
+  <p>Pour cela, une structure de donnée adaptée sera stockée dans un segment
+  de mémoire partagée, qui contiendra l'ensemble des informations utiles. Tout 
+  processus voulant offrir un service de calcul devra le faire en
+  enregistrant les informations adéquates dans le segment de mémoire
+  partagée, aussitôt qu'il sera prêt à offrir le service. Il devra
+  prendre soin de supprimer ces informations lorsqu'il ne souhaitera plus
+  offrir ledit service.
+  </p>
+
+  <p>Ce modèle pose naturellement des problèmes de concurrence auxquels
+  il faudra trouver des solutions.
+  </p>
+</div>
+
+
+<div class="bloc">
+  <h2>Syntaxe d'un appel à une fonction externe</h2>
+  <p>Un appel à une hypothétique fonction
+  <code>type <var>fonction</var>(type <var>arg</var>, ...)</code>
+  devra se faire via une fonction <var>appel_externe</var> de prototype
+  (à la mode <var>execl</var>)&thinsp;:
+  </p>
+  
+  <div class="ssbloc">
+  <code>int <var>appel_externe</var>(const char *<var>fonction</var>, int
+    <var>type</var>, void *<var>retour</var>, ... /* int <var>type_i</var>,
+    void *<var>arg_i</var> */, NULL);</code>
+  </div>
+  <p>
+  ou (à la mode <var>execv</var>)&thinsp;:
+  </p>
+  <div class="ssbloc">
+  <code>int <var>appel_externe</var>(const char *<var>fonction</var>, unsigned short <var>argc</var>, struct arg *<var>argv</var>);</code> 
+  
+  </div>
+
+<p>avec les notations suivantes&thinsp;:</p>
+<dl>
+  <dt><var>fonction</var></dt>
+  <dd>désigne l'identificateur externe (<em>i.e.</em> le nom) de la fonction&thinsp;;</dd>
+  <dt>les éventuels <var>arg_i</var> et <var>retour</var></dt> 
+  <dd>définissent les adresses auxquelles on trouvera,  
+  à l'appel, la valeur de ses <var>arg</var>uments, et, en retour, sa valeur de <var>retour&thinsp;; </dd>
+  <dt>chaque <var>type</var></dt>
+  <dd>définit le type C de l'<var>arg</var>ument (ou du <var>retour</var>) qui suit&thinsp;;</dd>
+  <dt>le type <code>struct arg</code></dt>
+  <dd> est composé de deux champs 
+    <code>int <var>type</var></code>
+    et 
+    <code>void *<var>arg</var></code> et sert à stocker ensemble le type et
+    l'adresse d'un argument (ou du retour) de la fonction&thinsp;;
+  </dd><dt><var>argc</var></dt>
+  <dd>correspond au nombre d'éléments du tableau <var>argv</var>.</dd>
+</dl>
+
+</div>
+
+<div class="bloc">
+  <h2> Constantes à définir</h2>
+
+<p>Les différents <var>type</var>s supportés sont (au moins) les suivants&thinsp;:</p>
+<table border="1">
+  <tbody><tr><th><var>type</var></th><th>type C</th><th>Commentaire</th></tr>
+  <tr><td><code>TYPE_VOID</code></td><td><code>void</code></td><td>ne peut apparaître que pour la valeur de retour</td></tr>
+  <tr><td><code>TYPE_INT</code></td><td><code>int *</code></td><td></td></tr>
+  <tr><td><code>TYPE_STRING</code></td><td><code>char *</code></td><td><!---ne peut apparaître comme valeur de retour---></td></tr>
+</tbody></table>
+
+<p>Ainsi un appel à une fonction d'addition de deux nombres entiers pourraît prendre la forme suivante&thinsp;:</p>
+<pre>int i, j , k, r;
+/* k = i+j; */
+r = appel_externe("plus", TYPE_INT, &amp;k, TYPE_INT, &amp;i, TYPE_INT, &amp;j,NULL);
+</pre>
+
+<p>La valeur de retour de la fonction <var>appel_externe</var> représente la condition de terminaison de l'appel. On trouvera entre autres&thinsp;:</p>
+
+<table border="1">
+  <tbody><tr><th>valeur</th><th>sémantique</th></tr>
+  <tr><td><code>APPEL_OK</code></td><td>tout s'est correctement déroulé</td></tr>
+  <tr><td><code>FONCTION_INCONNUE</code></td><td>la fonction demandée n'est pas disponible</td></tr>
+  <tr><td><code>MAUVAIS_ARGUMENTS</code></td><td>un problème concernant les arguments a été détecté (type, nombre)</td></tr>
+  <tr><td><code>PAS_DE_REPONSE</code></td><td>la fonction externe ne répond pas dans le délai imparti (5 secondes)</td></tr>
+</tbody></table>
+</div>
+
+<div class="bloc">
+
+  <h2>Format de sérialisation</h2>
+
+  <p>Seul le format de sérialisation des types définis ci-dessus vous est
+  imposé&thinsp;:</p>
+
+  <table border="1">
+    <tbody>
+      <tr><th><var>type</var></th><th>codage</th><th>exemple</th></tr>
+      <tr><td><code>TYPE_VOID</code></td><td>l'octet 0x00</td><td></td></tr>
+      <tr><td><code>TYPE_INT</code></td><td>l'octet 0x01, suivi d'un octet
+         donnant la longueur <var>lg</var> de l'écriture décimale de l'entier, 
+         <br> puis 
+         des <var>lg</var> caractères de cette écriture décimale</td>
+       <td> 123 est sérialisé 0x01, 0x03, '1', '2', '3'</td></tr>
+      <tr><td><code>TYPE_STRING</code></td><td>l'octet 0x02, suivi par un
+         octet donnant la
+         longueur <var>lg</var> de la chaîne, <br>puis des <var>lg</var>
+         caractères de la chaîne &ndash; caractère nul non compris&thinsp;!</td>
+       <td>"abc" est sérialisée  0x02, 0x03, 'a', 'b', 'c'</td></tr>
+  </tbody></table>
+</div>
+
+<div class="bloc">
+  <h2>Instructions diverses</h2>
+
+  <p> Le projet doit être réalisé par groupes de 2 ou 3 étudiants. Les
+  groupes devront être constitués <b>le 15 mars au plus tard</b>, et ne plus
+  varier ensuite. Lors de la soutenance (qui devra naturellement être
+  bien préparée), tous les membres du groupe devront intervenir.
+  </p>
+  
+  <p> Le strict minimum à réaliser est le modèle client/serveur en mode
+  synchrone, et des retours de fonction de type <code>void</code> ou
+  <code>int</code>. Vous pouvez ensuite améliorer votre projet en
+  autorisant d'autres types de retour, en permettant un fonctionnement
+  asynchrone du serveur, et/ou en implémentant le modèle distribué. Toute
+  application originale sera naturellement appréciée à sa juste valeur.
+  </p>
+
+  <p> Votre programme devra être accompagné d'un rapport décrivant le
+  travail réalisé&thinsp;; en particulier, ce rapport devra expliquer les
+  choix que vous serez amenés à faire concernant les protocoles de
+  communication entre les différents processus.  </p>
+
+  <p> Vous devrez réaliser différents tests pour vous convaincre que
+  votre réalisation fonctionne. Décrivez-les dans votre rapport, et
+  munissez-vous du nécessaire pour convaincre les examinateurs le jour de
+  la soutenance. N'hésitez pas à mentionner <em>aussi</em> les tests
+  négatifs&thinsp;! Vous pourrez également nous montrer les
+  développements que vous avez essayé de faire sans y parvenir
+  complètement. Cependant, la version de votre projet que vous
+  présenterez doit être complètement stable.</p> 
+
+  <p> La date et les modalités de rendu seront communiquées
+  ultérieurement.</p>
+</div>
+
+
+
+</body></html>