Consignes [1 pts]

Consignes Examen 2022

  • Documents non autorisés : Email et messagerie

  • Documents autorisés : Sujets de TP et notes de cours

  • Durée de l’évaluation : 2 Heures

Merci de réinitialiser les machines virtuelles avant le début du TP
Comptes Rendus

Merci d’envoyer les comptes rendus de TP AVANT DE QUITTER LA SALLE à l’adresse suivante: kevin.toublanc@univ-tours.fr

MERCI DE RESPECTER LES CONTRAINTES CI-DESSOUS:

  • Objet du mail: [G1][ETUDIANT1][ETUDIANT2] TP SE 2022

  • Dans un ZIP :

    • Un fichier .c pour chaque exercice : exercice-1.c, exercice-2.c, …​

    • Un fichier .txt pour chaque question posée : question-1.txt, question-2.txt, …​

1. Questions sur les travaux pratiques [2 pts]

Un fichier .txt pour chaque question posée : question-1.txt, question-2.txt, question-3.txt.

1.1. Interruptions

Question : Expliquez le comportement du programme suivant (effets des appels à sigaction, kill, code de retour du programme).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <printf.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig) {
    printf("Signal received: %d\n", sig);
    exit(100);
}

int main() {
    struct sigaction new_action =  {};
    new_action.sa_handler = handler;

    if (sigaction(SIGINT, &new_action, NULL) == -1) {
        perror("Failed to call sigaction system call");
        return 0;
    }

    struct sigaction sigsev_new_action =  {};
    sigsev_new_action.sa_handler = SIG_IGN;
    if (sigaction(SIGSEGV, &sigsev_new_action, NULL) == -1) {
        perror("Failed to call sigaction system call");
        return 0;
    }

    kill(getpid(), SIGSEGV);
    kill(getpid(), SIGSEGV);
    kill(getpid(), SIGINT);

    return 0;
}

1.2. Descripteurs de fichiers

1
2
3
4
5

int main(void) {
    close(0);
    perror("Something went terribly wrong...");
    return 0;
}

Question : Quel est l’effet de ce code ?

1.3. Duplication de processus

Question : Quelles sont les valeurs de retour de l’appel système fork() ?

2. Utilisation de Fork [3 pts]

Un fichier exercice-2.c

Écrivez un programme qui se duplique (via un fork).

Le processus père exécute les instructions suivantes :

  • Se duplique (fork)

  • Attend la fin du processus fils

  • Récupère la valeur retournée par le processus fils.

  • Se termine en retournant la valeur retournée par le processus fils multiplié par 2

Le processus fils exécute les instructions suivantes :

  • Se duplique (fork)

  • Attend la fin du processus petit-fils

  • Récupère la valeur retournée par le processus petit-fils.

  • Se termine en retournant la valeur retournée par le processus fils multiplié par 3

Le processus petit-fils exécute les instructions suivantes :

  • Affiche "Hello World From Child" sur la sortie standard

  • Se termine en retournant la valeur 1

3. Utilisation des Threads [4 pts]

Un fichier exercice-3.c

Écrivez un programme répondant aux contraintes ci-dessous.

Le programme principal exécute les instructions suivantes :

  • Créé trois threads

  • Attend et récupère la valeur retournée par les trois threads

  • Affiche sur la sortie standard les valeurs récupérées additionnées

  • Se termine

Le premier thread exécute les instructions suivantes :

  • Retourne la valeur 10

Le second thread exécute les instructions suivantes :

  • Retourne la valeur 20

Le troisième thread exécute les instructions suivantes :

  • Retourne la valeur 30

4. Tubes et redirections [5 pts]

Un fichier exercice-4.c

Écrivez un programme qui se duplique (via un fork).

Le processus père exécute les instructions suivantes :

  • Créé un tube (pipe)

  • Se duplique (fork)

  • Attend la fin du processus fils

  • Lit le tube (read)

  • Affiche la valeur issue du tube sur la sortie standard

Le processus fils exécute les instructions suivantes :

  • Ferme sa sortie standard

  • Remplace la sortie standard par la partie de lecture du tube

  • Envoie la chaine suivante dans le tube : "Hello from child\n" (write)

  • Se termine en renvoyant 0

5. Synchronisation [5 pts]

Un fichier exercice-5.c 
#include 
#include 
#include 
#include 

long final_value = 0;

void increase_value(int increase_value) {
    for (int i = 0; i < increase_value; ++i) {
        usleep(100);
        final_value++;
    }
}

int main(int argc, char *argv[], char *arge[]) {
    increase_value(500);
    increase_value(1000);
    increase_value(1500);
    increase_value(2000);
    increase_value(2500);
    increase_value(3000);
    increase_value(3500);
    increase_value(4000);
    increase_value(4500);
    increase_value(5000);

    printf("Final processed value : %ld\n", final_value);
    return EXIT_SUCCESS;
}

Modifiez le programme ci-dessus pour que:

  • Chaque incrémentation soit réalisée dans un thread différent en utilisant la même fonction de traitement (10 threads)

  • Le programme principal attende la fin de l’exécution de tous les threads avant de se terminer

  • Les threads devront être créés en passant en argument la valeur à incrémenter (argument de la fonction increase_value()) ;

  • La modification de la valeur finale (final_value) doit être protégée par le mécanisme de synchronisation le plus approprié.