Parallélisation de traitement via une boucle

Version imprimable

07/10/2016, 18h25
Chico008

Parallélisation de traitement via une boucle
Bonjour

J'ai ecrit un script en Ksh sous Linux, qui va lire un fichier contenant plusieurs lignes.
pour chaque ligne, via une boucle while read, j’exécute plusieurs traitements.

Actuellement, mon script est asser long et dure quasiment 1h.
j'ai voulu faire une // manuelle, via génération de script fils pour traiter le fichier par lot de 20 lignes, je suis descendu a 30 min.

ma // manuelle étant un peu chiante, disons le, je me demande si y'a pas moyen de faire en sorte de rendre la // automatique par le système (pour lancer la lecture de 8 lignes en // par exemple, et que ca continue jusqu'a ce que le fichier soit lu entièrement) ?

Je m'y connais pas asser dans ce domaine, du coup, pourriez vous m’éclairer ?

Merci

PI : mon script de base est asser con, pour exemple
Code:

1 2 3 4 5 6 7 8 #definition de variable FIC_LEC=toto.lst cat $FIC_LEC | while read line do cmd1 $line cmd2 $line done

Bonjour,
Es-tu obligé d'utiliser ksh ?
En bash, il existe une commande pratique pour ça, mais cela n'évite pas ta boucle:

Code:

1
2
3
4
5
6
7
8
9
10
11
$ help coproc
coproc: coproc [NOM] commande [redirections]
    Crée un coprocessus nommé NOM.
 
    Exécute la COMMANDE de manière asynchrone, en connectant la sortie et l'entrée standard
    de la commande par un tube aux decripteurs de fichier affectés aux indices 0 et 1
    d'une variable tableau NOM dans le shell en cours d'exécution.
    Le NOM par défaut est « COPROC ».
 
    Code de retour :
    Renvoie le même code de retour que la COMMANDE.

08/10/2016, 00h25
N_BaH

ou alors, tu installes, et apprends à utiliser GNU/parallel.
il est dit que ça fonctionne comme xargs...
08/10/2016, 08h24
Chico008

@disedorgue : aurait tu un exemple à me donner avec ce que tu me donnes ? pas sur de comprendre

@N_Bah : je suis pas admin du serveur sur lequel je bosse, et ne peut du coup pas installer d'outil, sinon ce serait trop simple :)
08/10/2016, 09h51
Escapetiger
Bonjour,
Citation:
Envoyé par Chico008

Actuellement, mon script est asser long et dure quasiment 1h.
j'ai voulu faire une // manuelle, via génération de script fils pour traiter le fichier par lot de 20 lignes, je suis descendu a 30 min.

ma // manuelle étant un peu chiante, disons le, je me demande si y'a pas moyen de faire en sorte de rendre la // automatique par le système (pour lancer la lecture de 8 lignes en // par exemple, et que ca continue jusqu'a ce que le fichier soit lu entièrement) ?
(.../...)
PI : mon script de base est asser con, pour exemple

Code:

1 2 3 4 5 6 7 8 #definition de variable FIC_LEC=toto.lst cat $FIC_LEC | while read line do cmd1 $line cmd2 $line done
On ne voit pas comment le script parallèlise par 20 et/ou par 8 en "manuel".

Suivant la cohérence des actions de cmd1 et cmd2, il est possible d'utiliser "basiquement" l'exécution en tâche de fond avec le caractère & qui "rends la main" soit cmd2 $line &, applicable à cmd1 selon le traitement.

Citation:

L’exécution en arrière-plan permet à un utilisateur de lancer une commande et de récupérer immédiatement la main pour lancer « en parallèle » la commande suivante (parallélisme logique). On utilise le caractère & pour lancer une commande en arrière-plan.

Source : http://eric-sanchis.developpez.com/l...duction#LI-4-2
08/10/2016, 10h31
disedorgue
coproc est la même chose que mettre la commande en background (comme expliqué par Escapetiger), avec la particularité de connecter l'entrée et la sortie sur un tube dont les fd sont déclarés dans un tableau.

Mais comme le dit Escapetiger , on ne comprends pas trop comment tu parallélises tes commandes...

Après, tu as peut-être déjà atteint la limite du passage de 1 heure à 30 minutes:
- combien de processeurs as-tu ?
- Quel est le taux d'occupation cpu de ta commande non // ?
- Est-ce que tu sollicites l'écriture disque pour chaque commande ?
Dis-toi, que si ton process normal prend 1 heure en utilisant par exemple 90 % du cpu, et que tu n'as que 2 coeurs, alors en parallélisant à 2 commandes, tu atteindras déjà ton max qui est ici dans ton exemple de 30 minutes.
Après lorsque l'on a plus de coeur (genre 24), bien souvent, on ne parallélise pas à 24 commandes car on restreint par des latence sur les bus d'entrée sortie.

Peut-être que ton algo n'est pas optimum et que l'on peut déjà l'améliorer ?
Mais pour ça, il faudrait que l'on sache ce que celui-ci doit faire et comment tu as pensé ça...

Que donne l'ajout d'une perluette?

Code:

1
2
3
4
5
6
7
#definition de variable
FIC_LEC=toto.lst
cat $FIC_LEC | while read line
do
   cmd1 $line &
   cmd2 $line &
done

ou bien, si cmd2 doit absolument être commencée après que cmd1 est terminée:

Code:

1
2
3
4
5
6
#definition de variable
FIC_LEC=toto.lst
cat $FIC_LEC | while read line
do
   { cmd1 $line ; cmd2 $line ; } &
done

08/10/2016, 18h08
disedorgue

Euh, un petit wait après le done peut-être ?
09/10/2016, 09h58
Chico008

Y'a une incompréhension

c'est pas les commandes dans la boucle que je souhaite mettre en //
mais le traitement par bloc de la boucle, cad mettre x itérations de la boucle en //, donc c'est le while read que je souhaite mettre en //

pour la // manuel, c'est fait via un autre script, que j'avais fait pour tester, ce n'est pas le script que j'ai mis la.

enfin, mon script utilise entre 1 et 3% de CPU sur 1 seul cœur, sur les 16 de dispo,
la cmd1 est une lecture d'un fichier, avec toto en paramètre.
la cmd2 est une commande progiciel avec en paramètre le résultat de la cmd1
une fois tout ça fait, j’agrège les données en sortie pour écrire 1 ligne dans un fichier de sortie.
Si vous voulez demain je vous met le script complet (il est sur mon poste au bureau, la c'est we :) )
09/10/2016, 18h43
disedorgue

La deuxième proposition de jack-ft semble la bonne, mais attendons d'avoir une vue plus complète du script pour comprendre comment tu agrèges tes résultats.
Car en l'état, si tu récupère la sortie des commandes dans la boucle, le fait de les mettre en background juste comme ça, tu ne peux garantir l'ordre d'arriver des résultats et tu auras de la perte si tout est redirigé sur le même flux de sortie.

Via script fils, pas de problème, je recupère bien mon resultat comme il faut.

par contre il semble que quelqu'un a virer mon script du serveur pendant le week-end :'(
du coup je peut pas vous le mettre ...

mais sinon oui, la 2nd solution de Jack semble pas mal, je vais tester ca.

Bon, j'ai pu retrouver mon script

Du coup le voici

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
 
#!/bin/ksh
 
echo "Start : $(date +'%F_%H:%M:%S')"
echo "DEBUT : Declaration variables"
 
 
cd /home/auto113/proc
FNOW=$(date +"%Y-%m-%d %H:%M:00")
SEARCH=/home/auto113/exploit/search_machine.sh
FIC_OUT=/home/auto113/lst/appsrv.csv
rm -f $FIC_OUT
CONF="./Conf_WHEREAMI ./Conf_HOMOL_WHEREAMI"
 
echo "Generation des scripts puis lancement"
cat $CONF | grev -v "#" | while read line
do
      APP=$(echo $line | cut -d'|' -f1)
      # on cherche si un jil existe
      ls ../jil/$APP.[jJ][iI][lL] > /dev/null 2>&1
      if [ $? -eq 0 ]; then
         $SEARCH ../jil/$APP.[jJ][iI][lL] | grep Machine > ./tmp1.lst
         cat ./tmp1.lst | while read linb
         do
            NCOL=$(echo $linb | awk '{print NF}')
            case $NCOL in
            4)
              echo $linb | awk '{print $(NF-1)","$NF}' >> ./tmp2.lst
              ;;
            5)
              echo $linb | awk '{print $(NF-2)","$(NF-1)","$NF}' >> ./tmp2.lst
              ;;
         esac
         done
         SRVLST=$(cat ./tmp2.lst | tr \"\n\" \":\" | sed -e "s/:$//")
         echo "$FNOW;$APP;$SRVLST" >> $FIC_OUT
         rm -f ./tmp2.lst
      else
         echo "$FNOW;$APP;Liste indisponible" >> $FIC_OUT
      fi
done
echo "FIN $(date +'%F_%H:%M:%S')"

du coup selon l'idée de Jack il faudrait ajouter un { après le do
et un } & avant le done c'est bien ca ?

Faudra que j'ajoute du code pour limiter le nombre de background et les attendre

Citation:

Envoyé par Chico008

du coup selon l'idée de Jack il faudrait ajouter un { après le do
et un } & avant le done c'est bien ca ?

Oui, c'est l'idée... J'ai pas tout lu, ni tout compris...

Mais ATTENTION!

Quand on parallèlise, il ne faut pas se marcher sur les pieds!
Dans ton code, toutes les itérations de la boucle principale utilisent (et partagent) le même fichier ./tmp1.lst et le même fichier ./tmp2.lst
Forcément, si tu parallèlise, ça va pas bien marcher du tout!
De manière générale, il faut toujours se méfier avec les fichiers temporaires.
Souvent on met "$$" dans le nom du fichier pour que 2 occurrences simultanées du même programme ne partagent pas le même fichier.
Ici, ça ne marcherait pas.
Il vaudrait mieux utiliser "mktemp" ou, mieux, se passer d'un fichier intermédiaire, si tu ne veux pas le conserver en fin de traitement.
Ici, il me semble que tu peux avantageusement remplacer:
Code:

1 2 $SEARCH ../jil/$APP.[jJ][iI][lL] | grep Machine > ./tmp1.lst cat ./tmp1.lst | while read linb
par

Code:

$SEARCH ../jil/$APP.[jJ][iI][lL] | grep Machine | while read linb

Pour tmp2.lst, ton script nettoie après la sous-boucle. Comme il n'y a pas de nettoyage avant, si jamais le script est interrompu pour une raison quelconque, alors, au prochain lancement, la première sous-boucle repartira avec un fichier tmp2.lst non vide (BUG!).

Vu le traitement que tu fais, tu peux envisager de le faire en ram plutôt que dans un fichier intermédiaire.
Par exemple quelque chose comme (à vérifier):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 $SEARCH ../jil/$APP.[jJ][iI][lL] | grep Machine | while read linb do SRVLST='' NCOL=$(echo $linb | awk '{print NF}') case $NCOL in 4) SRVLST=${SRVLST:+$SRVLST:}$(echo $linb | awk '{print $(NF-1)","$NF}') ;; 5) SRVLST=${SRVLST:+$SRVLST:}$(echo $linb | awk '{print $(NF-2)","$(NF-1)","$NF}') ;; esac done echo "$FNOW;$APP;$SRVLST" >> $FIC_OUT
mais le plus simple (et le plus rapide) serait de faire un seul script awk plutôt que grep Machine | while read linb...

PS: Pour la lisibilité, j'aime pas les petits "else" (surtout si c'est un cas d'erreur). Je préfère inverser le test et permuter les clauses du "if".

Comme le dit Jack-ft, tu peux par exemple remplacer avantageusement:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
         cat ./tmp1.lst | while read linb
         do
            NCOL=$(echo $linb | awk '{print NF}')
            case $NCOL in
            4)
              echo $linb | awk '{print $(NF-1)","$NF}' >> ./tmp2.lst
              ;;
            5)
              echo $linb | awk '{print $(NF-2)","$(NF-1)","$NF}' >> ./tmp2.lst
              ;;
         esac
         done
         SRVLST=$(cat ./tmp2.lst | tr \"\n\" \":\" | sed -e "s/:$//")

par:

Code:

SRVLST=$(awk 'NF==4 || NF==5 {NF==5 ? X=$(NF-2)","$(NF-1)","$NF : X=$(NF-1)","$NF ; printf Y X;Y=":"}' ./tmp1.lst)

11/10/2016, 07h29
Chico008

effectivement le tmp1 c'est du feneant que fait quand je code en vitesse pour pas trop me prendre la tete, mais je vais m'y mettre :)

par contre je comprend pas trop ta ligne

Code:

SRVLST=${SRVLST:+$SRVLST:}$(echo $linb | awk '{print $(NF-1)","$NF}')

ce serait equivalent à

Code:

SRVLST=$SRVLST":"$(echo $linb | awk '{print $(NF-1)","$NF}')

?

@disedorgue : je maitrise pas encore asser le awk pour pondre ce genre de code :p
et vu qu'il devra être maintenu ensuite par des collègues qui ne maitrisent pas du tout le script, je prefère garder mon case, plus lisible et plus simple a comprendre pour des neophytes
Mais je retient :)
11/10/2016, 08h22
jlliagre
Citation:
Envoyé par disedorgue

Es-tu obligé d'utiliser ksh ?
En bash, il existe une commande pratique pour ça, mais cela n'évite pas ta boucle:

Code:

1 2 3 $ help coproc coproc: coproc [NOM] commande [redirections] ...
Hmm, ksh a introduit les co-processes en 1988, dix neuf ans ans avant que bash ne finisse supporter le concept en 2009 (bash 4.0)...

Citation:

Envoyé par jlliagre

Hmm, ksh a introduit les co-processes en 1988, dix neuf ans ans avant que bash ne finisse supporter le concept en 2009 (bash 4.0)...

[HUMOUR]De 1988 à 2009, il y a 21 ans, ou alors tu voulais dire 1989 et 2008 [/HUMOUR] :)
Sinon, le coproc de ksh que tu parles, c'est bien le fameux |& ?
Si c'est celui-ci, il est tout de même limité à un seul coprocess à la fois, contrairement à celui plus explicite de bash qui permet d'en lancer plusieurs.

Citation:

Envoyé par Chico008

@disedorgue : je maitrise pas encore asser le awk pour pondre ce genre de code :p
et vu qu'il devra être maintenu ensuite par des collègues qui ne maitrisent pas du tout le script, je prefère garder mon case, plus lisible et plus simple a comprendre pour des neophytes
Mais je retient :)

Je croyais que tu recherchais de la performance, donc un exemple de ton approche et de l'approche awk:
La partie de ton code testé:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 $ cat scentest.sh cat $1 | while read linb do NCOL=$(echo $linb | awk '{print NF}') case $NCOL in 4) echo $linb | awk '{print $(NF-1)","$NF}' >> ./tmp2.lst ;; 5) echo $linb | awk '{print $(NF-2)","$(NF-1)","$NF}' >> ./tmp2.lst ;; esac done cat ./tmp2.lst | tr "\n" ":" | sed -e "s/:$//"
Testons sur un fichier de 1000 lignes ( en bash : for i in {1..500} ; do echo -e "A B C D E\nR T Y U" ; done >SCEN_1000.txt ) :
Code:

1 2 3 4 5 6 $ rm ./tmp2.lst $ time bash scentest.sh SCEN_1000.txt >/dev/null real 0m4.724s user 0m0.994s sys 0m2.815s
Testons la ligne awk sur les mêmes 1000 lignes:
Code:

1 2 3 4 5 $ time awk 'NF==4 || NF==5 {NF==5 ? X=$(NF-2)","$(NF-1)","$NF : X=$(NF-1)","$NF ; printf Y X;Y=":"}' SCEN_1000.txt >/dev/null real 0m0.005s user 0m0.004s sys 0m0.001s
Et la ligne awk n'est pas difficile à appréhender, ici j'utilise juste le if-else court ( expr ? action vrai : action faux ), sinon en syntaxe plus parlant:

Code:

awk 'NF==4 || NF==5 {if(NF==5){X=$(NF-2)","$(NF-1)","$NF}else{X=$(NF-1)","$NF};printf Y X;Y=":"}' file

Après, il serait intéressant de savoir quelle partie prend du temps et qui te pousse à faire du // ?

11/10/2016, 13h14
jlliagre

Citation:

Envoyé par disedorgue

[HUMOUR]De 1988 à 2009, il y a 21 ans, ou alors tu voulais dire 1989 et 2008 [/HUMOUR] :)

Ouch, il faudra que je réapprenne à compter ... :aie:

Citation:

Sinon, le coproc de ksh que tu parles, c'est bien le fameux |& ?

Oui, les co-processes ont été inventés par ksh avec la syntaxe |& qui me semble plus intuitive que coproc. On crée un pipe bidirectionnel et la commande est mise en arrière plan.

Citation:

Si c'est celui-ci, il est tout de même limité à un seul coprocess à la fois, contrairement à celui plus explicite de bash qui permet d'en lancer plusieurs.

Ça se discute, j'aurais tendance à penser l'inverse. La syntaxe étendue de la commande coproc de bash permet bien de nommer les descripteurs de fichiers à sa convenance, mais la page de manuel de bash précise dans le chapitre BUGS:

There may be only one active coprocess at a time.

Voir aussi https://lists.gnu.org/archive/html/b.../msg00053.html

Côté ksh, il n'est nulle part précisé qu'un seul co-process est supporté et rien n’empêche d'en lancer plusieurs. Il suffit dans ce cas de préserver en les dupliquant les deux descripteurs de fichiers du dernier co-process exécuté avant de lancer le suivant, par exemple comme ça :

Code:

exec 3>&p 4<&p

Mais cela dit, pour faire ce que permettent les co-processes, je préfère aujourd'hui plutôt utiliser des pipes nommés ou expect.
11/10/2016, 14h20
disedorgue

Super, je comprends mieux pourquoi j'avais des problèmes aléatoires quand j'avais essayé d'utiliser ce coproc de bash avec openssl et que j'ai fini par passer par des pipes nommés (que je préfère aussi et quand c'est possible de les créer dans la share memory).

Citation:

Envoyé par Chico008

je comprend pas trop ta ligne SRVLST=${SRVLST:+$SRVLST:}$(echo $linb | awk '{print $(NF-1)","$NF}')...
ce serait equivalent à SRVLST=$SRVLST":"$(echo $linb | awk '{print $(NF-1)","$NF}') ?

C'est équivalent uniquement lorsque $SRVLST est non nul et non vide, c'est-à-dire après la première itération de la boucle.

Ce serait plutôt quasiment équivalent à quelque chose comme:
Code:

1 2 3 4 if test -z "${SRVLST}" then SRVLST=$(echo $linb | awk '{print $(NF-1)","$NF}') else SRVLST=${SRVLST}:$(echo $linb | awk '{print $(NF-1)","$NF}') fi
Ça permet d'avoir exactement un ":" entre chaque paire de valeurs.

Plus précisément, c'est équivalent à:
Code:

1 2 3 4 if test -z "${SRVLST:-}" # Pour éviter les erreurs provoquées par un éventuel "set -u" then SRVLST=$(echo $linb | awk '{print $(NF-1)","$NF}') else SRVLST=${SRVLST}:$(echo $linb | awk '{print $(NF-1)","$NF}') fi
Pour tester:
Code:

1 2 3 4 5 6 7 8 A='' # ou bien: unset A A=${A:+$A:}B echo $A => B A=${A:+$A:}C echo $A => B:C etc.
Juste par souci de précision, ceci marche aussi:
Code:

1 2 3 4 5 6 7 8 unset A A=${A+$A:}B echo $A => B A=${A+$A:}C echo $A => B:C etc.
mais pas ceci:
Code:

1 2 3 4 5 6 7 8 A='' A=${A+$A:}B echo $A => :B A=${A+$A:}C echo $A => :B:C etc.

12/10/2016, 07h38
Chico008

@Dise : merci pour tes explications
par contre, peut tu m'expliquer le print final ? (printf Y X;Y=":") je ne le comprend pas. (sauf le X, mais d'ou vient le Y)

@jack : merci, c'est plus clair, je connaissait pas ces syntaxes :)
12/10/2016, 09h46
jack-ft

Citation:

Envoyé par Chico008

@Dise : merci pour tes explications
par contre, peut tu m'expliquer le print final ? (printf Y X;Y=":") je ne le comprend pas. (sauf le X, mais d'ou vient le Y)

Il vient du vide...

Avant la première itération, Y est non valuée donc considéré comme vide et printf Y X imprime juste la valeur de X,
puis Y=":" affecte ":" à Y.
Donc, à la seconde itération et suivantes, Y est valuée et printf Y X imprime donc le ":" contenu dans Y suivi de la valeur de X.
13/10/2016, 06h46
Chico008
Ok, je comprend mieux.

Du coup je peut meme concaténer vos solutions, à savoir faire directement :
Code:

1 2 SRVLST=${SRVLST:+$SRVLST:}$(echo $linb | awk 'NF==4 || NF==5 {NF==5 ? X=$(NF-2)","$(NF-1)","$NF : X=$(NF-1)","$NF ; printf X}')
Merci à vous tous pour votre aide, et votre patiente :)