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 ?
Version imprimable
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 ?
ben il suffit de mettre un '&' à la fin de chaque lancement...
Exemple :
start_proc.sh
ça c'est du parallèle..Code:
1
2
3
4
5
6
7 BIN=/home/troumad/bin $BIN/proc1 & $BIN/proc2 & $BIN/proc3 & .....
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..
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 :
et hop au bout d'un instant :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 ) &
les attentes ont bien fonctionnés successivement dans chaque chaines.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 #
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.
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"...
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 !
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 :
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
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
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 testCode:
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 )
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)
:yaisse2:
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....
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 :La dernière commande de la procédure appelée sera d'effacer lock_i et la première de l'écrire.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
Correct non ?
Désolé pour le retard, mais mon serveur est(était ?) très malade et l'accès à internet ne marche plus beaucoup !
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 ....
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 !
ok donc la oui il faudra broder autour de la methode oui
Voici mon codeCode:
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
Je me demande si ma boucle ne bouffe pas tout le temps CPU ! Des sleep seraient peut-être les bien venu !
Juste une remarque troumad :
Il me semble , qu'il y ait un effet de bord 8O : vous lancer "n" fois la meme commande , si dans la boucle
tous les process sont teminés , je pense qu'il serait judicieux de rajouterCode:while [ $i -lt $MAX ]
;)Code:-a $drap -eq 1
Voici un exemple qui s'appuie sur une liste de commandes contenues dans le fichier "Les_CMD" :oops:
Et un exemple de fichier "Les_CMD" pour tester :aie: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
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
Absolument d'accordCitation:
Envoyé par troumad
ok :bug:
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