Vous êtes sur la page 1sur 11

Nicolas LEFEVRE-LAUMONIER

3402603
LI 219 : Multi PROGRAMMATION SYSTEME
12 janvier 2015
Montral

Exercice 1
Question 1
L'objectif est d'excuter les commandes commande1.sh commande2.sh
commande3 .sh du rpertoire /bin/groupe2. La variable PATH =
/bin/groupe1:/bin/groupe2:/bin/groupe3.
En excutant une des trois commande ci-dessus, le shell va chercher en premier
un fichier excutable dans le premier rpertoire du PATH soit /bin/groupe1. Or
les trois fichiers existent avec les droits en lecture et en excution pour tous les
utilisateurs : ce sont donc ces fichiers qui seront excuts.
Pour excuter les commandes commande1.sh commande2.sh commande3.sh du
rpertoire /bin/groupe2, la solution la plus simple est de retirer les droits en
excution du repertoire groupe1 comme ci dessous :
chmod a-x bin/groupe1
Ds lors l'excution des commandes
commande1.sh commande2.sh
commande3.sh seront celles du rpertoire /bin/groupe2
Question 2
L'objectif est d'excuter les commandes :
- commande1.sh du rpertoire /bin/groupe1
- commande2.sh du rpertoire /bin/groupe2
- commande3.sh du rpertoire /bin/groupe3
La variable PATH = /bin/groupe1:/bin/groupe2:/bin/groupe3.
En excutant une des trois commande ci-dessus, le shell va chercher les fichiers
excutables du rpertoire /bin/groupe1.
Il faut donc supprimer les droits en excution de
- commande2.sh du rpertoire /bin/groupe2
- commande3,sh du rpertoire /bin/groupe1
- commande3,sh du rpertoire /bin/groupe2
Ds lors, en excutant commande1.sh, le shell, partir du PATH excute
commande1.sh du rpertoire /bin/groupe1
Ds lors, en excutant commande2.sh, le shell, partir du PATH excute
commande2.sh du rpertoire /bin/groupe2
Ds lors, en excutant commande3,sh, le shell, partir du PATH excute
commande3.sh du rpertoire /bin/groupe3
Les commandes excuter :

chmod a-x bin/groupe1/commande2.sh bin/groupe1/commande3.sh


bin/groupe2/commande3.sh
Question 3
Dans le mme esprit que les question prcdente une solution possible est la
suivante :
- changement de propritaire du groupe1, affecter user1
- changement de propritaire du groupe2, affecter user2
- changement de propritaire du groupe3, affecter user3
- retirer les droits dexcution group et other pour les rpertoires groupe1,
groupe2, groupe3
Ainsi, si l'utilisateur user1 excute une commande, le Shell avec l'appui du
PATH excutera celle du rpertoire groupe1.
Ainsi, si l'utilisateur user2 excute une commande, le Shell avec l'appui du
PATH excutera celle du rpertoire groupe2.
Ainsi, si l'utilisateur user3 excute une commande, le Shell avec l'appui du
PATH excutera celle du rpertoire groupe3.
Les commandes excuter :
chown -R user1 bin/groupe1
chown -R user2 bin/groupe2
chown -R user3 bin/groupe3
chmod go-x bin/groupe1 bin/groupe2 bin/groupe3

Exercice 2
Question 1
Affichage produit par ./pere.sh 1 2 3
22
47
64
resultat: 20
Question 2
Les modifications sont les suivantes (surligns en vert):
#! /bin/bash
# pere.sh
val=20
export i val
for i in "$@"; do
./fils.sh
done
echo "resultat: $val"
#! /bin/bash
# fils.sh
x=`./alea.sh`
res=`expr $i \* $val`
res=`expr $res + $x`
echo $res
fils.sh ne prenant plus de valeurs Input, il faut donc crer une copie de la
variable i et val dans le contexte dexcution de la descendance du processus li
pere.sh : la commande export i val rempli ce rle. Il faut galement changer le
code de fils.sh en consquence.
Question 3
Les modifications sont les suivantes (surligns en vert):
#! /bin/bash
# pere.sh
val=20
somValAlea=0
for i in "$@"; do
./fils.sh $i $val
somValAlea=`expr $somValAlea + $?`
done
echo "resultat: $val"

echo "somme des valeurs alatoires: $somValAlea"


#! /bin/bash
# fils.sh
x=`./alea.sh`
res=`expr $1 \* $2`
res=`expr $res + $x`
echo $res
exit $x
La modification principale rside dans l'utilisation de exit $x qui permet de
donner de donner une valeur de retour fils.sh gale la valeur du chiffre
alatoire. Cette valeur est ensuite rcupre dans pere.sh via la commande $?
qui permet de rcuprer a valeur de retour du dernier processus excut en
premier plan. Il suffit ensuite de faire une somme et grer l'affichage au sein de
pere.sh.
Question 4
Les modifications sont les suivantes (surligns en vert):
#! /bin/bash
# pere.sh
val=20
produit=1
for i in "$@"; do
source ./fils.sh $i $val
produit=`expr $produit \* $res`
done
echo "resultat: $val"
echo "produit: $produit"
La modification principale rside dans l'utilisation de source qui permet
d'excuter les instructions de fils.sh dans le processus pere.sh. De la sorte la
variable res de fils.sh est accessible pere.sh la fin de l'appel de fils.sh et
permet de faire un produit. L'utilisation de source ne pose pas de souci car
fils.sh ne modifie pas la valeur de la variable val et rinitialise res chaque
passage avec res=`expr $1 \* $2`.
Question 5
Un processus ne peut jamais passer directement de ltat bloqu l'tat lu.
Pour tre lu, c'est dire en excution, un processus doit tre choisi par
l'ordonnanceur. L'ordonnanceur choisit le processus excuter parmi les
processus prt. Un Un processus ne peut donc jamais passer directement de

ltat bloqu l'tat lu.


Un processus ne peut jamais passer directement de ltat prt l'tat bloqu. Un
processus dans ltat prt attend d'tre choisit par l'ordonnanceur pour tre
excut. Il ne peut donc tre bloqu. Il passera ventuellement l'tat bloqu
lorsque l'ordonnanceur l'aura choisi pour tre excut. A ce moment, un
vnement pour bloquer le processus. Le processus sera en attente d'un autre
vnement pour reprendre son excution.

Exercice 3
Question 1
Les modifications sont les suivantes (surligns en vert):
#! /bin/bash
# proc1.sh
fic="$1"
max=$2
i=0
while [ $i -lt $max ] ; do
read a
echo $a
./proc2.sh $fic $i
i=`expr $i + 1`
done <$fic
La modification principale rside dans l'utilisation de <$fic au niveau de la
bloucle while de proc1.s. proc1.sh et proc2.sh partage le mme offset de lecture.
Voici le fonctionnement de la lecture.
proc

lecture

proc1

proc1

proc2

proc1

proc2

proc2

proc1

proc2

proc2

proc2

10

Question 2
#! /bin/bash
# proc1.sh
fic="$1"
max=$2
i=0

while [ $i -lt $max ] ; do


read a
echo $a
./proc2.sh $fic $i
i=`expr $i + 1`
done <$fic
#! /bin/bash
# proc2.sh
fic=$1
max=$2
i=0
while [ $i -lt $2 ] ; do
read a
echo $a
i=`expr $i + 1`
done <$fic
La modification principale rside dans l'utilisation de <$fic au niveau de la
boucle while de proc1.sh et proc2.sh. proc1.sh et proc2.sh ont des offset de
lecture diffrents. proc2.sh recommence la lecture du fichier au dbut a chaque
nouvel appel.
Voici le fonctionnement de la lecture.
proc

lecture

proc1

proc1

proc2

proc1

proc2

proc2

proc1

proc2

proc2

proc2

Exercice 4
Question 1
Affichage
Processus 1 : debut
Processus 2 : debut
Processus 3 : debut
Processus 4 : debut
Processus 4 : fin
Processus 3 : fin
Processus 2 : fin
Processus 1 : fin
Lutilisation de la commande wait bloque le processus courant tant que tous ses
fils ne sont pas termins.
Dans ce cas, il y a un appel rcursif de arbre.sh. 4 processus sont initis sans
pouvoir tre achev. Le premier processus terminer son excution est le plus
jeune des fils soit le processus4 car il ne fait pas appel la cration d'un
nouveau processus fils : la commande wait est donc inoprante. L'aboutissement
du processus4 permet de lever la contrainte de la commande wait pour le
processus3. Ainsi de suite jusqu'au processus1.
Question 2
Arbre.sh

Arbre.sh

Arbre.sh

Arbre.sh

Wait
Wait
Wait

Annulation Wait
Annulation Wait
Annulation Wait

Question 3
#! /bin/bash
# arbre2.sh
echo "Processus $1 : debut"
echo -n $2 > fic
if [ "$1" -lt "$2" ]; then
./arbre2.sh `expr $1 + 1` $2 &
while true;
do
sleep 1
read a < fic
if [ "$1" = "$a" ]; then
echo "Processus $1 : fin"
echo -n `expr $1 - 1` > fic
kill -SIGKILL $$
fi
done
fi
echo "Processus $1 : fin"
echo -n `expr $2 - 1` > fic
On utilise un fichier pour grer larrt des diffrent processus. La commande kill
-SIGKILL $$ permet de tuer le processus courant une fois que la condition est
remplie. La condition est base sur la valeur la plus leve de la boucle qui est
ensuite itre ngativement mesure que les processus sont tus.
Sans doute pas la manire la plus lgante de rsoudre le problme mais
fonctionne.

Exercice 5
Excution 1 : Possible
L'analyse du code permet de conclure assez aisment que :
- Pere : 1 arrive avant Pere : 2
La boucle for commence par i = 1 puis i = 2. La boucle est squentielle, pas de
processus parallle.
La condition est respecte
Le processus gnrant Fils : 1 est excut en parallle avant echo Pere :
$1 et echo Pere : $2 , il peut termin avant ces processus ou aprs
dpendamment du temps d'excution. Le processus gnrant Fils : 1 est
xcut en parallle avant le processus gnrant Fils : 2 : il peut termin
avant ou aprs le processus gnrant Fils : 2 dpendamment du temps
d'excution.
Excution 2 : Possible
L'analyse du code permet de conclure assez aisment que :
- Pere : 1 arrive avant Pere : 2
La boucle for commence par i = 1 puis i = 2. La boucle est squentielle, pas de
processus parallle.
La condition est respecte
Le processus gnrant Fils : 1 est excut en parallle avant echo Pere :
$1 et echo Pere : $2 , il peut termin avant ces processus ou aprs
dpendamment du temps d'excution. Le processus gnrant Fils : 1 est
xcut en parallle avant le processus gnrant Fils : 2 : il peut termin
avant ou aprs le processus gnrant Fils : 2 dpendamment du temps
d'excution.
Excution 3 : Impossible
Au moment de l'affichage de Pere : 1 , le processus gnrant Fils : 2 n'est
pas encore excut.
Excution 4 : Impossible
L'analyse du code permet de conclure assez aisment que :
- Pere : 1 arrive avant Pere : 2
La boucle for commence par i = 1 puis i = 2. La boucle est squentielle, pas de
processus parallle.