[bash] lancer X process en parallèle [Résolu]

[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 :

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 :

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 :

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 :

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 !

[frp31]

là c'est pas un code fonctionnel mais juste les grande lignes il faut broder autour après...
c'est juste "concept"...
il y a donc juste des "bouts de code" et pas un programme complet...

bien sur on peut simplifier le code mais il va être très très long dans ce cas...Si j'ai le temps je ferai un exemple dans la journée/soirée.

ps -ef ou ps -aux dans ce cas remonte la même info. puisqu'on coupe l'affichage
====================================================
voilà un exemple qui marche :

Code :

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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
#!/bin/sh
 
fin=1
compteur=0
listjob="abcdefghijk"
 
suivant()
{
        if [ $compteur -lt 2 ] ; then
                suivant=$(echo $listjob|cut -c 1)
                $suivant
                listjob=$(echo $listjob|cut -c 2-)
                echo $suivant" "$listjob
#retirer cette ligne echo si on veut pas d affichage
                compteur=$(($compteur + 1))
        else
                jobfini
        fi
}
jobfini()
{
        for x in a b c d e f g h i j k
        do
                if [ -f /tmp/$x ] ; then
                        t=$(grep TITI /tmp/$x|wc -l)
                        if [ $t -eq 1 ] ; then
                                compteur=$(($compteur - 1))
                        fi
                fi
        done
}
a()
{ (sleep 10
        echo TITI > /tmp/a)&
}
b()
{ (sleep 10
        echo TITI > /tmp/a)&
}
c()
{ (sleep 10
        echo TITI > /tmp/a)&
}
d()
{ (sleep 10
        echo TITI > /tmp/a)&
}
e()
{ (sleep 10
        echo TITI > /tmp/a)&
}
f()
{ (sleep 10
        echo TITI > /tmp/a)&
}
g()
{ (sleep 10
        echo TITI > /tmp/a)&
}
h()
{ (sleep 10
        echo TITI > /tmp/a)&
}
i()
{ (sleep 10
        echo TITI > /tmp/a)&
}
j()
{ (sleep 10
        echo TITI > /tmp/j)&
}
k()
{ (sleep 10
        echo TITI > /tmp/k)&
        fin=0
}
 
while [ $fin -eq 1 ] ; do
        suivant
done
rm /tmp/[a-k]
exit 0

et l'affichage rendu :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
/tmp# sh test
a bcdefghijk
b cdefghijk
c defghijk
d efghijk
e fghijk
f ghijk
g hijk
h ijk
i jk
j k
k
[1]   Done                    ( sleep 10; echo TITI >/tmp/a )
[2]   Done                    ( sleep 10; echo TITI >/tmp/a )
[3]   Done                    ( sleep 10; echo TITI >/tmp/a )
[4]   Done                    ( sleep 10; echo TITI >/tmp/a )
[5]   Done                    ( sleep 10; echo TITI >/tmp/a )
[6]   Done                    ( sleep 10; echo TITI >/tmp/a )
[7]   Done                    ( sleep 10; echo TITI >/tmp/a )
[8]   Done                    ( sleep 10; echo TITI >/tmp/a )
[9]   Done                    ( sleep 10; echo TITI >/tmp/a )
[10]-  Done                    ( sleep 10; echo TITI >/tmp/j )
[11]+  Done                    ( sleep 10; echo TITI >/tmp/k )

a & b sont executés en meme temps (si on veux abc pour le début suffit de changer la ligne compteur=0 par compteur=1 !) j'ai fait expres pour tomber sur k dans un pool de 3 jobs lors du test
puis cde
puis fgh
puis ijk



pour l'exploiter il suffit de changer sleep 10 par la commande que tu veux lancer (ça peut etre un script ou un programme)



en fait en utiliser un mot dans un fichier dans /tmp pour voir si une tache est finie ou pas ça simplifie vachement les choses....

[troumad]

Envoyé par frp31

pour l'exploiter il suffit de changer sleep 10 par la commande que tu veux lancer (ça peut etre un script ou un programme)

Pour comprendre, j'ai fait un essai avec un programme dont le nom est programmesanspareil.sh.
Je pense voir le process en faisant ps -ef | grep "programmesanspareil.sh" | grep -v grep. Le problème, c'est que je vois rien
Un ps uwx ne me montre que la commande bash que le script exécute
C'est à dire que si je mets sleep 100 comme seule commande de programmesanspareil.sh, seul sleep 100 apparaitra dans un ps uwx.
Si je réfléchis bien à tout ce que tu m'as écrit, je peux faire écrire un lock à chacun de mes process et vérifier sa présence pour en lancer un nouveau.
Voici un algo :

Code :

1
2
3
4
5
6
7
8
9
10
11
tant que ligne dans fichier
  i<-0
  tant que i<NB_MAX
     si lock_i absent
        appel procedure avec comme paramètre ligne et i
        i<-NB_MAX
     sinon
       i<-i+1
     fin si
  fin tant que
fin tant que

La dernière commande de la procédure appelée sera d'effacer lock_i et la première de l'écrire.

Correct non ?

Désolé pour le retard, mais mon serveur est(était ?) très malade et l'accès à internet ne marche plus beaucoup !

[frp31]

laisses tomber la methode lock et les ps
comme tu vois dans l'exemple revu et corriger le plus simple et de cree un fichier pour chaque "commande" terminée et donc de simplement tester si les fichiers sont presents ou pas pour savoir si elle est terminée.

tu n'as pas d'autre modifs à faire que remplacer le sleep 10 aucune ....

[troumad]

Le problème, c'est que je veux toujours lancer la même commande, mais avec un paramètre différent chaque fois !

Et je ne sais pas combien de fois j'aurais à la lancer en tout. Ça dépend de la longueur du fichier ! Le nombre de processus maximum à faire tourner en parallèle est en dur dans ton programme. Je préfère le laisser libre en fonction de la puissance de la machine.

J'ai moi aussi viré les ps. Mes lock, c'est comme tes fichiers ! La seule chose que je regarde, c'est s'ils sont présents ou non. Pas s'il est écrit quelque chose dedans !

[frp31]

ok donc la oui il faudra broder autour de la methode oui

[troumad]

Code :

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
MAX=15 # nombre max de processus en parallèle
 
proc()
{
 echo $1" et "$2
 
 # traitement à finir de mettre au point ;)
 
 rm -f lock_$2
 echo "fin $1 $2"
}
 
cat $1 | while read LINE ; do
 echo test $LINE
 drap=1
 while [ $drap -eq 1 ] ; do
  i=0
  while [ $i -lt $MAX ] ; do
   if ! [ -f lock_$i ] ; then
    touch lock_$i
    proc $LINE $i &
    drap=0
   fi
   i=$(($i + 1))
  done
 done
done

Voici mon code

[troumad]

Je me demande si ma boucle ne bouffe pas tout le temps CPU ! Des sleep seraient peut-être les bien venu !

[argoet]

Juste une remarque troumad :
Il me semble , qu'il y ait un effet de bord : vous lancer "n" fois la meme commande , si dans la boucle

Code :

 while [ $i -lt $MAX ]

tous les process sont teminés , je pense qu'il serait judicieux de rajouter

Code :

-a $drap -eq 1

Voici un exemple qui s'appuie sur une liste de commandes contenues dans le fichier "Les_CMD"

Code :

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
#!/bin/ksh
MAX=3 # nombre max de processus en parallèle
 
proc()
{
 echo $1 $2
 $1
 rm -f lock_$2
 echo "fin $1 $2"
}
 
while read LINE
do
 drap=1
 while [ $drap -eq 1 ] ; do
  i=0
  while [ $i -lt $MAX  -a $drap -eq 1 ] ; do
   if  [ ! -f lock_$i ] ; then
    touch lock_$i
    proc "$LINE" $i &
    drap=0
   fi
   i=$(($i + 1))
  done
 done
done < Les_CMD

Et un exemple de fichier "Les_CMD" pour tester

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
sleep 6
sleep 4
sleep 3
sleep 1
sleep 4
sleep 5
sleep 6
sleep 1
sleep 2
sleep 3
sleep 4
sleep 5
sleep 6
sleep 1
sleep 2
sleep 3
sleep 4
sleep 5
sleep 6

Envoyé par troumad

Je me demande si ma boucle ne bouffe pas tout le temps CPU ! Des sleep seraient peut-être les bien venu !

Absolument d'accord

[frp31]

ok

[troumad]

Merci pour la remarque !
J'avais déjà résolu le problème... La résolution étant un effet de bord d'un autre problème
En effet, je ne vais donner une ligne qu'à un seul process. Quand j'ai donné une ligne à un process, alors je sors de la boucle en instaurant i à MAX (=> sortie de la boucle) juste avant l'incrémentation de i. Ceci le mettra à MAX+1 en sortie de boucle. Donc, si je sors de la boucle sur MAX (il me semble en décrivant l'astuce que drap=0 aurait suffit !) c'est que tous les process travaillent et que donc, je peux attendre => sleep 10.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
cat $1 | while read LINE ; do
 drap=1
 while [ $drap -eq 1 ] ; do
  i=0
  while [ $i -lt $MAX ] ; do
   if ! [ -f lock_$i ] ; then
    touch lock_$i
    proc $LINE $i &
    drap=0
    i=$MAX
   fi
   i=$(($i + 1))
  done
  if [ $i -eq $MAX ] ; then
          sleep 10
  fi 
 done
done