Institut National des Télécommunications
Télécom INT 2^è année

TP Noté CSC4508/M2 du 07/06/06

Modalités

• La clarté du code,
• Le fait que le code compile (sans warning),
• Le fait que le code répond correctement à la question posée,
• Le fait que le retour de chaque appel système, s'il y en a un, est testé et géré (traitement d'erreur),
• Le fait que les ressources système réservées pendant l'exécution du programme sont libérées à la fin de l'exécution.

cd votreRepertoireDeTravailPourCS22M1
tar cvfz $USER.tgz TPNote2006

Préparation

cd votreRepertoireDeTravailPourCS22M1
cp ~simatic/CS22M1/tPNote2006.tgz .
tar xvfz tPNote2006.tgz
cd TPNote2006

Question 1 : Questions de cours (5 points)

Question 1.1 : À propos des threads

#include <stdio.h>
#include <stdlib.h>

#include <pthread.h>

#define NBAFFICHAGE 5

void ajoute(char *val)
{
  static char cur;

  if (val != NULL)
    cur = *val;
  else
    cur = cur + 1;

  printf("cur = %c\n", cur);
}


void *pthread_func(void *arg)
{
  int i;
  char *val = (char *)arg;
  
  ajoute(val);

  sleep(2);

  for (i = 0; i < NBAFFICHAGE; i++)
    ajoute(NULL);

  pthread_exit(NULL);
}

int main(int argc, char **argv)
{
  pthread_t thread1, thread2;

  char val1 = 'a';
  char val2 = 'A';

  if (pthread_create(&thread1, NULL, pthread_func, &val1))
    {
      perror("pthread_create");
      exit(EXIT_FAILURE);
    }

  if (pthread_create(&thread2, NULL, pthread_func, &val2))
    {
      perror("pthread_create");
      exit(EXIT_FAILURE);
    }

  pthread_join(thread1, NULL);
  pthread_join(thread2, NULL);

  return EXIT_SUCCESS;
}

À un moment donné, combien y-a-t-il au maximum dans la mémoire du processus d'occurrences de:

• val1
• val2
• i
• cur
• val

Question 1.2 : Ordonnancement

/*******************************/
/* Essai de sched_setscheduler */
/*******************************/

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <sched.h>
#include <sys/types.h>
#include <sys/wait.h>

#define FATAL(msg) {\
  char m[128];       \
  sprintf(m, "%s in %s:%d:%s", msg, __FILE__, __LINE__, __func__); \
  perror(m); \
  abort(); \
}

/**********************************************************************/
/* Code execute par le processus enfant                               */
/**********************************************************************/
void codeEnfant()
{
  struct sched_param sp;

  sp.sched_priority = sched_get_priority_max(SCHED_FIFO);
  if (sched_setscheduler(0,SCHED_FIFO,&sp) < 0) {
    FATAL("sched_setscheduler");
  }

  while(1){
  }
}

/**********************************************************************/
/* Programme principal                                                */
/**********************************************************************/
int main(int argc, char* argv[])
{
  int status;

  switch (fork()) {
  case -1:
    FATAL("fork");
    break;
  case 0:
    codeEnfant();
    break;
  default:
    wait(&status);
  }

  return EXIT_SUCCESS;
}

Question 1.3 : Mémoire

• Le programmeur pouvait spécifier que des sections de son code devaient être rangées dans des fichiers appelés "fichiers de recouvrement" (ou fichiers d'overlay).
• Ainsi un programme exécutable était constitué par :
  
• Un fichier exécutable contenant le main du programme.
• Un ou plusieurs fichiers de recouvrement, chargés dans la mémoire au delà des 640 Ko au moment de l'exécution.
• La zone de 640 Ko contenait une zone appelée "zone de recouvrement". Pour être utilisé, un fichier de recouvrement devait être transféré dans cette zone de recouvrement. Le programmeur souhaitant appeler une fonction située dans un fichier de recouvrement devait au préalable invoquer une primitive permettant le transfert du fichier de recouvrement dans la zone de recouvrement. L'appel de la fonction pouvait ensuite se faire normalement.
  NB : si le programmeur avait ensuite besoin d'invoquer une fonction présente dans un autre fichier de recouvrement, il devait préalablement demander le transfert de cet autre fichier qui recouvrait (remplaçait) alors le premier fichier dans la zone de recouvrement.
  
• Voici un exemple de main d'un programme qui utilisait 3 fonctions a et b stockées dans le fichier fichierRecouvrementAB et 2 fonctions y et z stockées dans le fichier fichierRecouvrementYZ :
  

  int main(){
     chargerFichierRecouvrement(fichierRecouvrementAB);
     a(); /* NB : a() appelle b(), ce qui ne pose aucun problème   */
          /* puisque b() est présente dans la zone de recouvrement */
     chargerFichierRecouvrement(fichierRecouvrementYZ); /* NB : ce fichier recouvre le fichier */
                                                        /* fichierRecouvrementAB : a() et b()  */
                                                        /* ne sont donc plus accessibles       */
     y();
     z();
     chargerFichierRecouvrement(fichierRecouvrementAB);
     a();
     return EXIT_SUCCESS;
  }
  

Question 2 : Il était une fois... (7 points)

• Une tâche Soleil racontant l'histoire du point de vue du soleil. Elle exécute l'algorithme suivant :
  
  faire
     Ecrire "Je me lève"
     dormir(12 heures)
     Ecrire "Je me couche"
     dormir(12 heures)
  tant que VRAI
  
  
• Une tâche BlancheNeige racontant l'histoire du point de vue de Blanche-Neige. Elle exécute l'algorithme suivant :
  
  faire
     Ecrire "Le soleil me reveille"
     Ecrire "Je réveille les nains"
     Ecrire "Je vis ma vie sans les nains"
     Ecrire "Je fais Bisou Bonne Nuit à chaque nain"
     Ecrire "Je dors"
  tant que VRAI
  
  
• 7 tâches Nain (une pour chacun des nains) racontant l'histoire du point de vue de chaque nain. Elles exécutent l'algorithme suivant :
  
  faire
     Ecrire "Blanche-Neige me reveille"
     Ecrire "Je vais à la mine"
     Ecrire "J'attends de pouvoir entrer dans la mine"
     Ecrire "J'entre dans la mine"
     faire
        Ecrire "Je travaille"
        dormir(nombreDeMinutesAleatoire)
        Ecrire "Je prends ma pause"
        Ecrire "Je prends un verre plein"
        Ecrire "Je bois cul sec !"
     tant que continuerTravail()
     Ecrire "Je quitte la mine"
     Ecrire "Je rentre à la maison"
     Ecrire "Blanche-Neige me fait Bisou Bonne Nuit"
     Ecrire "Je m'endors"
   tant que VRAI
  
  
• 3 tâches Ours (une pour pour chacun des ours) racontant l'histoire du point de vue de chaque ours. Elles exécutent l'algorithme suivant :
  
   faire
      Ecrire "Je vis une autre histoire avec Bouton d'Or"
      dormir(nombreDeMinutesAleatoire)
      si oursDecideDAllerTravaillerALaMine() == VRAI alors
         Ecrire "Je vais à la mine"
         Ecrire "J'attends de pouvoir entrer dans la mine"
         Ecrire "J'entre dans la mine et je travaille"
         dormir(nombreDeMinutesAleatoire)
         Ecrire "Je quitte la mine"
      finsi
   tant que VRAI
  
  
• 8 tâches Mesange (une pour chacune des mésanges) racontant l'histoire du point de vue de chaque mésange. Elles exécutent l'algorithme suivant :
  
   faire
      Ecrire "Je prends un verre plein chez Mère-Grand, je vais à la mine et j'attends de pouvoir le déposer sur le plateau"
      Ecrire "Je dépose le verre sur le plateau"
   tant que VRAI
  

Question 2.1 : Identification des paradigmes (2 points)

Question 2.2 : Conception à l'aide de sémaphores (5 points)

Question 3 : Nains, mésanges et code (8 points)

• 7 tâches Nain (une pour chacun des nains) racontant l'histoire (simplifiée) du point de vue de chaque nain. Elles exécutent l'algorithme suivant :
  
  faire
     Ecrire "Nain <numéroNain> : Je travaille"
     dormir(1 seconde)
     Ecrire "Nain <numéroNain> : Je prends ma pause"
     Ecrire "Nain <numéroNain> : Je prends un verre plein sur le plateau"
     Ecrire "Nain <numéroNain> : Je bois cul sec !"
   tant que VRAI
  
  
• 8 tâches Mesange (une pour chacune des mésanges) racontant l'histoire (simplifiée) du point de vue de chaque mésange. Elles exécutent l'algorithme suivant :
  
   faire
      Ecrire "Mésange <numéroMésange> : Je prends un verre plein chez Mère-Grand, je vais à la mine et j'attends de pouvoir le déposer sur le plateau"
      Ecrire "Mésange <numéroMésange> : Je dépose le verre sur le plateau"
   tant que VRAI

Question 3.1 : Conception (2 points)

Question 3.2 : Implémentation avec des threads (6 points)