Discussion :

[troumad]

Bonjour

J'aimerai pouvoir lancer disons 15 process en parallèle en permanence. C'est à dire que j'ai une file d'attente et que dès qu'un fini, je lance le suivant. Est-ce possible ?

[souviron34]

ben il suffit de mettre un '&' à la fin de chaque lancement...

Exemple :

start_proc.sh

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
BIN=/home/troumad/bin
 
$BIN/proc1 &
$BIN/proc2 &
$BIN/proc3 &
.....

ça c'est du parallèle..

Si tu veux du série (ce que tu décris à la fin (ta phrase est contradictoire)), il suffit d'enlever les &...

A ce compte-là le script lance le premier, et est suspendu jusqu'à ce que le premier processus s'arrête..

[frp31]

si je comprend bien tu veux lancer des chaines de jobs en parallele mais chacune en parallele ?

A-B-C-D
L-M-N-O
X-Y-Z

tu peux faire tout simplement
comme ça chaque chaines tourne en parallele mais chaque job à l'interrieur de chaque chaine attend la fin du precedent...
et bien sur on peut faire des condition par exemple pour que Y demarre que si C est fini
etc....etc...etc...

(A ; B ; C ; D) &
(L ; M ; N ; O) &
(X ; Y ; Z ) &

par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
#!/bin/sh
#(@) 0.0 moi 
#
( sleep 10 && echo toto > /tmp/a && sleep 20 && echo toto > /tmp/b ) &
( sleep 20 && echo toto > /tmp/c && sleep 30 && echo toto > /tmp/d ) &
( sleep 30 && echo toto > /tmp/e && sleep 40 && echo toto > /tmp/f ) &
( sleep 40 && echo toto > /tmp/h && until [ -f /tmp/b ] ; do sleep 1 ; done sleep 90 && echo toto > /tmp/g ) &

et hop au bout d'un instant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
-rw-r--r-- 1 root root  310 Sep 11 21:48 t
-rw-r--r-- 1 root root    5 Sep 11 21:50 a
-rw-r--r-- 1 root root    5 Sep 11 21:50 c
-rw-r--r-- 1 root root    5 Sep 11 21:50 e
-rw-r--r-- 1 root root    5 Sep 11 21:50 b
-rw-r--r-- 1 root root    5 Sep 11 21:50 h
-rw-r--r-- 1 root root    5 Sep 11 21:50 d
-rw-r--r-- 1 root root    5 Sep 11 21:51 f
-rw-r--r-- 1 root root    5 Sep 11 21:51 g
:/tmp #

les attentes ont bien fonctionnés successivement dans chaque chaines.

[troumad]

Bonjour

Je comprends ce que vous me montrez. Mais il me semble que ce n'est pas ce que je demande !

J'ai des process en attente : a, b, c, d, e, f...
Je ne veux en avoir que trois qui tourne en même temps.

Je lance a, b et c.
Dès qu'un des trois s'arrête je veux lancer e, dès qu'un nouveau s'arrête, je lance f....

La méthode de frp31 bien que meilleur qu'un méthode série peut ne pas accélérer beaucoup le processus si tous les process qui sont lents sont dans la ligne 1.

[frp31]

ah ok donc oui la methode cité au dessus ne va pas dans ce cas en effet.

le mieux est de lancer a,b,c comme précédament.
mais de controler la nombre de processus actifs (parmis ceux de la liste).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
33
34
35
36
37
38
39
40
41
42
43
 
touch /tmp/lock
to_do="abcdefgh"
a&
b&
c&
p1=$(ps -ef | grep "a" | awk '{print $2}')
p2=$(ps -ef | grep "b" | awk '{print $2}')
p3=$(ps -ef | grep "c" | awk '{print $2}')
actif=abc
 
#a optimiser par des tableaux de variables bien sur....
while [ -f /tmp/lock]
do
      for i in $p1 $p2 $p3 ; do
           if [ $(echo $i | wc -c) -le 1 ] 
           then
           switch ( actif )
           case abc :
              etata=$(  ps -ef | grep -v grep |grep $p1 | wc -l)
              if [ $etata -eq 0 ] ; then
                   to_do=$(echo $to_do | grep -va)
                   $(echo $todo|grep -ve b -e c |cut -b 1) &  
                   #ne pas oublier aussi de recalculer le nouveau "actif" 
                   activ=$(echo $todo|grep -ve b -e c |cut -b 1)bc
                   p1=$(ps -ef | grep $($(echo $todo|grep -ve b -e c |cut -b 1)) | awk '{print $2}')
 
              fi
              if [ $etata -eq 0 ] ; then
                   to_do=$(echo $to_do | grep -va)
                   $(echo $todo| grep -ve a -e c | cut -b 1) &  
                   #ne pas oublier aussi de recalculer le nouveau "actif" 
                   activ=$(echo $todo|grep -ve b -e c |cut -b 1)ac
#p2 pareil et à chaque fois le meme truc
              fi
              if [ $etata -eq 0 ] ; then
                   to_do=$(echo $to_do | grep -va)
                   $(echo $todo| grep -ve a -e b | cut -b 1) &  
 ...............
              break;
           case c,d,e ;
................
done

C'est un peu lourd comme syntaxe mais ça doit marcher
suffira de remplacer a,b,c,d, etc... par des fonctions dans le haut du script...
mais le principe est là :
en fait il y a que 3 trucs à changer à chaque fois
to_do (reste à faire)
actif (en cours)
p1 à p3 (pour les processus correspondants...)
donc ainsi la liste to_do="abcdefgh"
devient si a est fini to_do="defgh" et les actif=dbc
puis
liste to_do="bdefgh" (par exemple si c fini avant b)
devient si a est fini to_do="fgh" et les actif=dbe
puis si c'est alors d qui fini le premier
liste to_do="bdefgh" (par exemple si c fini avant b)
devient si a est fini to_do="gh" et les actif=bef
et ainsi de suite...
le dernier job detruira le fichier lock pour que le script qui controle les lancement ne finisse qu'apres ce dernier job.

en utilisant des tables de variables y'a moyen d'obtimiser ça je pense...
là c'est brouillon "de concept"...

[troumad]

J'avoue que je suis un peu planté devant un tel programme !

J'essaie de comprendre, mais c'est l'heure de me coucher...
Première question :
Pourquoi tu ne fais pas le grep -v grep dès p1, p2 et p3 ?
Cette liste doit identifier le processus a (il faut donc un nom plus compliqué !) Et Ce ps -ef ? pas ps ux ?

Dernière question pour ce soir
J'ai l'impression qu'une chose est copié trois fois ! La première fois ça doit être pour a, la seconde pour b, la troisième incomplète sur c. Pourquoi cette 3ème fois est incomplète ? Et j'avoue ne pas maîtriser assez le bash pour comprendre tout ça !