TP Se

Université Hassiba Benbouali de Chlef
Faculté des Sciences
Département d'informatique
Système d’exploitation
Niveau: Licence 2
Group:5
Année scolaire : 2022-2023
TP5: Mini-Projet 1
Realized by:
• HAMMADI Mohammed 161832017273
Dirge:
Mr. Tahraoui
Exercice 1
Le programme utilise la fonction fork() pour
créer des processus enfants. Il initialise une
variable "i" à 1 et incrémente "i" dans chaque
processus enfant créé jusqu'à ce que 10
processus enfants soient créés. Le programme
affiche ensuite la valeur finale de "i", qui est 11
Exercice 2
l’arbre des processus.
Exercice 3
programme C qui génère une chaîne de processus linéaire, où chaque
processus créé en crée un autre jusqu'à atteindre le processus final 'pn'.
p1-->p2-->p3-->p4-->pn
#include <stdio.h>
#include <unistd.h>
int main() {
int i, n = 5;
for (i = 1; i <= n; i++) {
if (fork() == 0) {
printf("Je suis le processus p%d, mon PID est %d, le PID de mon
père est %d\n", i, getpid(), getppid());
} else {
wait(NULL);
break;
if (i > n) {
printf("Je suis le processus pn, mon PID est %d, le PID de mon père
est %d\n", getpid(), getppid());
return 0;
Exercice 4
programme C qui permet de réaliser la communication suivante:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#define MAX_LEN 256
int main() {
int pipefd[2];
pid_t pid;
char buffer[MAX_LEN], reversed[MAX_LEN];
if (pipe(pipefd) == -1) {
perror("pipe");
exit(EXIT_FAILURE);
pid = fork();
if (pid == -1) {
perror("fork");
exit(EXIT_FAILURE);
if (pid == 0) {
close(pipefd[1]);
int n = read(pipefd[0], buffer, MAX_LEN);
close(pipefd[0]);
for (int i = 0; i < n; i++) {
reversed[i] = buffer[n-i-1];
}
reversed[n] = '\0';
printf("Chaîne inversée : %s\n", reversed);
exit(EXIT_SUCCESS);
} else {
close(pipefd[0]);
printf("Entrez une chaîne de caractères : ");
fgets(buffer, MAX_LEN, stdin);
int len = strlen(buffer) - 1;
write(pipefd[1], buffer, len);
close(pipefd[1]);
wait(NULL);
return 0;
Exercice 5
trois processus qui communiquent au moyen de pipes nommés selon
l’architecture .
p1:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int main()
int tube1_fd;
char message[50];
int a, b;
// Ouverture du tube 1 en écriture
tube1_fd = open("tube1", O_WRONLY);
if (tube1_fd == -1) {
perror("Erreur lors de l'ouverture du tube 1 en écriture");
exit(EXIT_FAILURE);
// Lecture des valeurs de a et b depuis l'utilisateur
printf("Entrez deux entiers pour la somme : ");
scanf("%d %d", &a, &b);

// Construction du message à envoyer dans le tube 1
sprintf(message, "%d+%d", a, b);
// Ecriture du message dans le tube 1
if (write(tube1_fd, message, strlen(message) + 1) == -1) {
perror("Erreur lors de l'écriture dans le tube 1");
exit(EXIT_FAILURE);
// Fermeture du tube 1 en écriture
if (close(tube1_fd) == -1) {
perror("Erreur lors de la fermeture du tube 1 en écriture");
exit(EXIT_FAILURE);
return EXIT_SUCCESS;
p2:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
int main()
// Create tube1
mkfifo("tube1", 0666);
// Open tube1 for reading
int fd1;
char buffer[1024];
fd1 = open("tube1", O_RDONLY);
read(fd1, buffer, 1024);
close(fd1);
// Parse message from tube1
char *a_str = strtok(buffer, "+");
char *b_str = strtok(NULL, "+");
char *op_str = strtok(NULL, "+");
int a = atoi(a_str);
int b = atoi(b_str);
// Perform calculation
int result;
if (strcmp(op_str, "+") == 0) {
result = a + b;
} else {
printf("Invalid operator\n");
exit(1);
// Create tube2
// Open tube2 for writing
int fd2;
char *message1 = "5";
char *message2 = "8";
char *message3 = "+";
fd2 = open("tube2", O_WRONLY);
write(fd2, message1, strlen(message1) + 1);

close(fd2);
exit(0);
p3:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
int main()
// Create tube2
// Open tube2 for reading

int fd2;
char buffer[1024];
fd2 = open("tube2", O_RDONLY);
read(fd2, buffer, 1024);
close(fd2);
// Parse messages from tube2
char *a_str = strtok(buffer, "+");
char *b_str = strtok(NULL, "+");
char *op_str = strtok(NULL, "+");
int a = atoi(a_str);
int b = atoi(b_str);
// Perform calculation
int result;
if (strcmp(op_str, "+") == 0) {
result = a + b;
} else {
printf("Invalid operator\n");
exit(1);
}
// Open tube3 for writing
int fd3;
char message[1024];
sprintf(message, "%d", result);
fd3 = open("tube3", O_WRONLY);
write(fd3, message, strlen(message) + 1);
close(fd3);
exit(0);
Exercice 6
Les cinq processus fils sont fork0, fork1, fork2, fork3 et fork4.
Lorsque le programme est exécuté, le processus initial fork0

crée deux nouveaux processus fork1 et fork2. fork1 crée
ensuite deux nouveaux processus fork3 et fork4. Ainsi, il y a
maintenant cinq processus en cours d'exécution: fork0, fork1,
fork2, fork3 et fork4.
Selon l'algorithme d'ordonnancement FIFO, les processus sont

exécutés dans l'ordre dans lequel ils ont été créés. Ainsi, le
processus fork0 est exécuté en premier, suivi des processus
fork1, fork2, fork3 et fork4.
Voici l'exécution des processus:

fork0 (PID 2401) crée fork1 (PID 2402) et fork2 (PID 2403)
fork1 (PID 2402) crée fork3 (PID 2404) et fork4 (PID 2405)
fork2 (PID 2403) se termine
Le programme affichera alors les résultats suivants:
Pere: 2000 Fils: 2401.
Pere: 2401 Fils: 2402.
Pere: 2402 Fils: 2404.
Pere: 2402 Fils: 2405.
Le programme se termine ensuite.

TP Se

Transféré par

Droits d'auteur :

Formats disponibles

TP Se

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

TP Se

Transféré par

Droits d'auteur :

Formats disponibles

Université Hassiba Benbouali de Chlef

Faculté des Sciences

Année scolaire : 2022-2023

for (i = 1; i <= n; i++) {

#define MAX_LEN 256

char buffer[MAX_LEN], reversed[MAX_LEN];

int n = read(pipefd[0], buffer, MAX_LEN);

for (int i = 0; i < n; i++) {

printf("Chaîne inversée : %s\n", reversed);

printf("Entrez une chaîne de caractères : ");

fgets(buffer, MAX_LEN, stdin);

int len = strlen(buffer) - 1;

write(pipefd[1], buffer, len);

// Ouverture du tube 1 en écriture

tube1_fd = open("tube1", O_WRONLY);

perror("Erreur lors de l'ouverture du tube 1 en écriture");

// Lecture des valeurs de a et b depuis l'utilisateur

printf("Entrez deux entiers pour la somme : ");

scanf("%d %d", &a, &b);

sprintf(message, "%d+%d", a, b);

// Ecriture du message dans le tube 1

if (write(tube1_fd, message, strlen(message) + 1) == -1) {

perror("Erreur lors de l'écriture dans le tube 1");

// Fermeture du tube 1 en écriture

perror("Erreur lors de la fermeture du tube 1 en écriture");

// Open tube1 for reading

fd1 = open("tube1", O_RDONLY);

read(fd1, buffer, 1024);

// Parse message from tube1

char *a_str = strtok(buffer, "+");

char *b_str = strtok(NULL, "+");

char *op_str = strtok(NULL, "+");

// Open tube2 for writing

char *message1 = "5";

char *message2 = "8";

char *message3 = "+";

fd2 = open("tube2", O_WRONLY);

write(fd2, message1, strlen(message1) + 1);

write(fd2, message2, strlen(message2) + 1);

write(fd2, message3, strlen(message3) + 1);

// Open tube2 for reading

fd2 = open("tube2", O_RDONLY);

read(fd2, buffer, 1024);

// Parse messages from tube2

char *a_str = strtok(buffer, "+");

char *b_str = strtok(NULL, "+");

char *op_str = strtok(NULL, "+");

sprintf(message, "%d", result);

fd3 = open("tube3", O_WRONLY);

write(fd3, message, strlen(message) + 1);

Lorsque le programme est exécuté, le processus initial fork0

Selon l'algorithme d'ordonnancement FIFO, les processus sont

Voici l'exécution des processus:

fork2 (PID 2403) se termine

fork3 (PID 2404) se termine

fork4 (PID 2405) se termine

fork1 (PID 2402) se termine

fork0 (PID 2401) se termine