7. Correction des exercices de la partie 2

7.1. Processus

7.1.1. Exercice 1

Ecrire un bout de code qui crée 15 processus avec les contraintes suivantes :

  • le processus initial est l'un des 15 ;

  • un processus donné a zéro, deux ou trois fils (mais jamais un seul) ;

  • tous les fils du processus initial ont eux-même des fils ;

  • le code est le plus simple possible et contient le plus petit nombre de fork() possibles.

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
main() {
  int i,j,k;
  printf("je suis un processus\n");fflush(stdout);
  for (i=1;i<3;i++) {
    if (fork()==0) {
      printf("Je suis un processus\n");fflush(stdout);
      sleep(1);
      for (j=1;j<3;j++) {
        if (fork()==0) {
          printf("Je suis un processus\n");fflush(stdout);
          sleep(1);
          for (k=1;k<3;k++) {
            if (fork()==0) {
              printf("Je suis un processus\n");fflush(stdout);
            }
            sleep(1);
          }
        }
      }
    }
  }
}

7.1.2. Exercice 2

Quelles traces génére le programme suivant ? Expliquez ..

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

int i;
main()
{
        pid_t ret;
        i=0;
        ret = fork();
        if (ret == 0)
        {       
                i+=10;
                printf("fils %d\n",i);  
                i+=20;
                printf("fils %d\n",i);
        }
        else
        {
                i+=1000;
                printf("pere %d\n",i);
                i+=2000;
                printf("pere %d\n",i);
                wait();
        }
}

----------------------
Exécution :

pere 1000
pere 3000
fils 10
fils 30

Dans ce programme, nous travaillons bien sur des processus "lourds" : les données sur lesquelles travaillent les deux processus père et fils sont protégés, même si elles sont déclarées pour les deux processus : la variable i que manipulent le père et le fils n'est pas la même dans chacun des deux fils d'exécution.

7.2. Ordonnancement

7.2.1. Exercice 1 (source : Joelle Delacroix - Cnam)

Cinq travaux A, B, C, D et E sont soumis à un processeur dans cet ordre, mais quasi simultanément. Ces travaux ne font pas d'entrées-sorties. Leurs durées respectives sont 10, 6, 2, 4 et 8 secondes. Déterminer les temps de réponse de chacun des travaux, ainsi que le temps de réponse moyen pour :

  1. l'algorithme FIFO

  2. l'algorithme SJF

  3. l'algorithme à priorité, avec P(A)=3, P (B)=5, P(C)=2, P(D)=1, P(E)=4

CAS FIFO
Ordre de passage : A B C D E
Tps réponse (A) = 10 s
Tps réponse (B) = 16 s
Tps réponse (C) = 18 s
Tps réponse (D) = 22 s
Tps réponse (E) = 30 s
CAS SJF
Ordre de passage : C D B E A
Tps réponse (A) = 30 s
Tps réponse (B) = 12 s
Tps réponse (C) = 2 s
Tps réponse (D) = 6 s
Tps réponse (E) = 20 s
CAS Priorité
Ordre de passage : D C A E B
Tps réponse (A) = 16 s
Tps réponse (B) = 30 s
Tps réponse (C) = 6 s
Tps réponse (D) = 4 s
Tps réponse (E) = 24 s

7.2.2. Exercice 2 (source : Christian Carrez - Cnam)

On considère un système monoprocesseur et les 4 processus P1, P2, P3 et P4 qui effectuent du calcul et des entrées/sorties avec un disque selon les temps donnés ci-dessous :


Processus P1                               Processus P2
    Calcul : 3 unités de temps                Calcul : 4 unités de temps
    E/S : 7 unités de temps                   E/S : 2 unités de temps
    Calcul : 2 unités de temps                Calcul : 3 unités de temps
    E/S : 1 unité de temps                    E/S : 1 unité de temps
    Calcul : 1 unité de temps                 Calcul : 1 unité de temps
Processus P3                               Processus P4
    Calcul : 2 unités de temps                Calcul : 7 unités de temps
    E/S : 3 unités de temps
    Calcul : 2 unités de temps

Remplissez le chronogramme pour cahcun des cas suivants :

  1. On considère que l'ordonnancement sur le processeur se fait selon une politique FIFO : le processus élu à un instant t est celui qui est le plus anciennement dans l'état prêt. Initialement, l'ordre de soumission des processus est P1, puis P2, puis P3, puis P4. De même, on considère que l'ordre de services des requêtes d'E/S pour le disque se fait selon une politique FIFO.

    Figure 15. Translation d'adresse

    Translation d'adresse


  2. On considère maintenant que l'ordonnancement sur le processeur se fait selon une politique à priorité préemptible : le processus élu à un instant t est celui qui le processus prêt de plus forte priorité. On donne priorité (P1) > priorité (P3) > priorité (P2) > priorité (P4). On considère que l'ordre de services des requêtes d'E/S pour le disque se fait toujours selon une politique FIFO.

    Figure 16. Translation d'adresse

    Translation d'adresse


  3. On considère toujours que l'ordonnancement sur le processeur se fait selon une politique à priorité préemptible : l'ordre des priorités des 4 processus reste inchangé. On considère maintenant que l'ordre de services des requêtes d'E/S pour le disque se fait également selon la priorité des processus : le processus commençant une E/S est celui de plus forte priorité parmi ceux en état d'attente du disque. Une opération d'E/S commencée ne peut pas être préemptée.

    Figure 17. Translation d'adresse

    Translation d'adresse


Skins :
Transparence
Simple
Page Accueil
Formation