Exercice 1:

#include < s t d i o . h>

#include < s t d l i b . h>
#include <u ni s t d . h>
#include <sys / types . h>
#include <sys / wait . h>
void merge ( int a r r [ ] , int l e f t , int mid , int r i g h t ) {
int i , j , k ;
int n1 = mid − l e f t + 1 ;
int n2 = r i g h t − mid ;

int L [ n1 ] , R[ n2 ] ;

for ( i = 0 ; i < n1 ; i +
+) L [ i ] = a r r [ l e f t
+ i];
for ( j = 0 ; j < n2 ; j++)
R[ j ] = a r r [ mid + 1 + j ] ;

i = 0;
j = 0;
k = left;
while ( i < n1 && j < n2 ) {
i f ( L [ i ] <= R[ j ] ) {
arr[k] = L[i
]; i ++;
} else {
a r r [ k ] = R[
j ]; j ++;
}
k++
 }

while ( i < n1 ) {
arr[k] = L[i
]; i ++;
k++;
}

while ( j < n2 ) {
a r r [ k ] = R[
j ]; j ++;
k++;
}
}

void merge Sort ( int a r r [ ] , int l e f t , int r i g h t ) {

if (left < right) {
int mid = l e f t + ( r i g h t − l e f t ) / 2 ;

pid t pid left , pid right;

i f ( ( p i d l e f t = f o r k ( ) ) == 0 ) {
// Processus f i l s − t r i de l a p a r t i e gauche
merge Sort ( arr , l e f t ,
mid); e x i t ( 0 ) ;
} else i f ( ( p i d r i g h t = f o r k ( ) ) == 0 ) {
// Processus f i l s − t r i de l a p a r t i e d r o i t e
merge Sort ( arr , mid + 1 , r i g h
t); e x i t ( 0 ) ;
} else {
 // Processus p r e − a t t e n t e des deux processus f i l s
waitpid ( p i d-l e f t , NULL, 0 )
waitpid ( p i d-r i g h t , NULL, 0 )
;

// Fusion des p a r t i e s triées

merge ( arr , l e f t , mid , r i g h t ) ;
}
}
}

int main ( ) {
int a r r [ ] = { 12 , 11 , 13 , 5 , 6 , 7 , 3 , 9 , 10 , 2 , 1 , 8 , 4 } ;
int n = s izeof ( a r r ) / s izeof ( a r r [ 0 ] ) ;

// Divisez l e t ab l eau en quatre p a r t i e s

int mid1 = n / 4 ;
int mid2 = mid1 ∗ 2 ;
int mid3 = mid1 ∗ 3 ;

// U t i l i s e z l ’ appel s y s t m e f ork ( )
p i d t pid1 , pid2 , pid 3 ;

i f ( ( pid 1 = f o r k ( ) ) == 0 ) {
// Processus f i l s 1 − t r i de l a première p a r t i e
merge Sort ( arr , 0 , mid1
−1) ; e x i t ( 0 ) ;
} else i f ( ( pid 2 = f o r k ( ) ) == 0 ) {
// Processus f i l s 2 − t r i de l a p a r t i e deux
merge Sort ( arr , mid1 , mid2
−1); e x i t ( 0 ) ;
} else i f ( ( pid 3 = f o r k ( ) ) == 0 ) {
// Processus f i l s 3 − t r i de l a p a r t i e trois
merge Sort ( arr , mid2 , mid3
−1); e x i t ( 0 ) ;
} else {
// Processus p r e − t r i de l a p a r t i e quatre
merge Sort ( arr , mid3 , n − 1 ) ;

// Attendez que tous l e s processus f i l s a i ent t e r m i nées avant l a f

usion
waitpid ( pid1 , NULL,0);
waitpid ( pid2 , NULL,0);
waitpid ( pid3 , NULL,0)
;
 // Fusionnez l e s quatre p a r t i e s t r iée s
merge ( arr , 0 , mid1 − 1 , n − 1 ) ;
}

// A f f i c h e z l e t ableau t r ié
p r i n t f ( ” Tableau - t r i - : - ” ) ;
for ( int i = 0 ; i < n ; i ++) {
p r i n t f ( ”%d - ” , a r r [ i ] ) ;
}
p r i n t f ( ” \n” ) ;

return 0 ;
}

Question 2
#include < s t d i o . h>
#include < s t d l i b . h>
#include <pthread . h>
#define MAX SIZE 100
void merge ( int a r r [ ] , int l e f t , int mid , int r i g h t ) {
int n1 = mid − l e f t + 1 ;
int n2 = r i g h t − mid ;

int L [ n1 ] , R[ n2 ] ;

for ( int i = 0 ; i < n1 ; i +

+) L [ i ] = a r r [ l e f t +
i];
for ( int j = 0 ; j < n2 ; j++)
R[ j ] = a r r [ mid + 1 + j ]
;

int i = 0 , j = 0 , k = l e f t ;

while ( i < n1 && j < n2 ) {

i f ( L [ i ] <= R[ j ] ) {
arr[k] = L[i
]; i ++;
} else {
a r r [ k ] = R[
j ]; j ++;
}
k++;
}

while ( i < n1 ) {
 arr[k] = L[i
]; i ++;
k++;
}

while ( j < n2 ) {
a r r [ k ] = R[
j ]; j ++;
k++;
}
}

void merge Sort ( int a r r [ ] , int l e f t , int r i g h t ) {

if (left < right) {
int mid = l e f t + ( r i g h t − l e f t ) / 2 ;
merge Sort ( arr , l e f t , mid ) ;
 merge Sort ( arr , mid + 1 , r i g h t ) ;
merge ( arr , l e f t , mid , r i g h t ) ;
}
}

void ∗ merge Sort Thread ( void ∗ arg ) {

int ∗ a r r = ( int ∗) arg ;
int mid1 = MAX SIZE / 4 ;
int mid2 = mid1 ∗ 2 ;
int mid3 = mid1 ∗ 3 ;

// Chaque thread t r i e sa propre p a r t i e du t ab l eau

merge Sort ( arr , mid1 , mid1 ∗ 2 − 1 ) ;

return NULL;
}

int main ( ) {
int a r r [ ] = { 12 , 11 , 13 , 5 , 6 , 7 , 3 , 9 , 10 , 2 , 1 , 8 , 4 } ;
int n = s izeof ( a r r ) / s izeof ( a r r [ 0 ] ) ;

// Creer un t ableau pour s t oc k e r l e s v a l eu r s t r ie s par chaque thread

int sorted Arr [ MAX SIZE ] ;

// C reer t r o i s t hreads pour t r i e r l e s t r o i s p a r t i e s du t ableau

p t h r e a d t thread 1 ;
p t h r e a d c r e a t e (& thread 1 , NULL, mergeSortThread , ( void ∗) a r r ) ;

// Le thread p r i n c i p a l t r i e l a quatrième p a r t i e du t ab l eau

merge Sort ( arr , 0 , n − 1 ) ;
 // Attendez que l e s t hreads a i ent t e r m i n avant l a f usion
p t h r e a d j o i n ( thread 1 , NULL) ;

// Fusionnez l e s quatre p a r t i e s t r iée s

merge ( sorted Arr , 0 , n / 4 − 1 , n − 1 ) ;

// A f f i c h e z l e t ableau t r ié
p r i n t f ( ” Tableau - t r i - : - ” ) ;
for ( int i = 0 ; i < n ; i ++) {
p r i n t f ( ”%d - ” , sorted Arr [ i ] ) ;
}
p r i n t f ( ” \n” ) ;

return 0 ;
}
Exercice 2:

Question 1

#include < s t d i o . h>

#include < s t d l i b . h>
#include <u ni s t d . h>
#include <sys / types . h>
#include <sys / i p c . h>
#include <sys /shm . h>
#include <sys / wait . h>

int main ( ) {
// C réez une clé pour l a mé m o i r e partagée
k e y t key = f t o k ( ” s h m f i l e ” , 6 5 ) ;
// C réez un segment pour l a mé m o i r e partagée
int shmid = shmget ( key , 1024 , 0666 | IPC CREAT ) ;

// Attachez l e segment de mémoire partagée au processus

int ∗ shared memory = ( int ∗) shmat ( shmid , ( void ∗) 0 , 0 ) ;

// créez un processus f i l s
p i d t pid = f o r k ( ) ;

i f ( pid == −1) {
perror(”fork”);
e x i t ( EXIT FAILURE ) ;
}

i f ( pid == 0 ) {
// Code du processus f i l s
 // accedez à la mémoire partagée pour lire les données
p r i n t f ( ” Processus - f i l s - l i t - l a - v a l e u r - : -%d\n” , ∗ shared memory ) ;

// Modifiez l e s d o n nées dans l a mm o i r e p a r t a g e

∗ shared memory = 4 2 ;

// détachez l e segment du processus f i l s

shmdt ( shared memory ) ;

e x i t ( EXIT SUCCESS ) ;
} else {
// Code du processus parent
 // Modifiez l e s données dans la mémoire partagée
∗ shared memory = 1 7 ;

// Attendez que l e processus f i l s se termine

wait (NULL) ;
p r i n t f ( ” Processus - parent - l i t - l a - v a l e u r - m o d i f i e - -
par - l e - f i l s - : -%d\n”, ∗

// détachez l e segment de mémoire partagée du processus

parent
shmdt ( shared memory ) ;

// Supprimez l e segment de mémoire partagéé

shmctl ( shmid , IPC RMID , NULL) ;

return 0 ;
}
}