Discussion :

[sanchou]

Bonjour,

voici la partie de mon script qui pose problème:

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
function buildProject () {
		build PARAM0 &
		PID1=$!
                build PARAM1 &
                PID2=$!
		wait ${PID1}
                wait ${PID2}
		build PARAM2
		return 0
	}
 
function build {
	sh -s 
		#
                # Mes traitements...
                #
        exit 0;
}
 
buildProject;

Comme vous le voyez, il faut que mes taches build PARAM1 et build PARAM0 soient terminées (et exécutées en parallèle) afin que je puisse appeler ma tache build PARAM2.

Le problème, c'est que lorsque mon premier traitement est terminé, mon wait ne se déclenche pas. Le script retourne en console et il faut que je tape explicitement un exit pour que mon wait se déclenche.

Avez-vous une idée pour résoudre mon problème?
J'ai essayé un return à la place du exit, même résultat et même un kill $$ à la fin de mes traitement dans ma deuxième méthode, mais tous les process sont tués.

Merci d'avance

[sanchou]

Bonjour à tous,

j'ai trouvé une solution partielle à mon problème :

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
function buildProject () {
		build PARAM0 &
		build PARAM1 &
                build PARAM2 &
                wait 
		build PARAM3
		return 0
	}
 
function build {
		#
                # Mes traitements...
                #
        exit 0;
}
 
buildProject;

L'appel à wait sans paramètre permet d'attendre que tous les process fils soient terminés.

Pour optimiser tout çà, je vous donne un exemple de cas que je ne gère pas avec ce script.

Si mon but est de construire PARAM3 et que:

- PARAM3 a besoin que PARAM0 et PARAM2 soient construits
- PARAM2 a besoin que PARAM1 soit construit

En définitive, comment faire pour que PARAM0 soit construit en parallèle de PARAM1 et PARAM2 qui eux doivent être construits séquentiellement?

Si vous avez besoin de détails supplémentaires, n'hésitez pas à demander.

Merci d'avance

Nico

[ericduval]

Ne peux tu pas écrire un truc du genre :

build P1 && build P2 && build P0 && build P3

Si ta fonction retourne les une valeur adéquat en cas d'erreur
et de succès ça devrait fonctionner.

[sanchou]

Bonjour,

Le problème avec le &&, c'est que les instructions s'exécutent séquentiellement...
Or j'ai besoin de paralleliser les traitements...

Merci de ta réponse en tout cas.

Other idea?

[ericduval]

J'ai pas essayé et honte sur moi
j'ai même pas vérifié que cela soit possible :

(P0& ; P1 && P2) && P3

[jmelyn]

Bonjour,

J'ai fait un petit programme shell pour déduire automatiquement les dépendances... à partir du moment où elles sont bien décrites dans l'appel, bien sûr. Le voici:

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
#!/bin/bash

function buildProject
{
    argList="$(echo $* | tr ' ' '\n')"
    newArgList="$argList"
    buildingDone="false"
    while [ $buildingDone = "false" ]
    do
        if [ -n "$argList" ]
        then
            for arg in $argList
            do
                if [ $(echo $arg | awk -F ',' '{print NF}') = "1" ]
                then
                    bash -c "echo 'building '$arg'...'; sleep 5" &
                    newArgList="$(echo "$newArgList" | sed -e 's/,*'$arg'//')"
                fi
            done
            wait
            argList="$newArgList"
        else
            buildingDone="true"
        fi
    done
}

buildProject arg0 arg1 arg2,arg1 arg3,arg0,arg2

Plusieurs remarques:
1) La ligne rouge doit être adaptée, je ne sais pas ce que le build fait.
2) La ligne verte donne les dépendances. Ici cela donne: arg0 ne dépend de rien, arg1 non plus, arg2 dépend de arg1 et arg3 dépend de arg0 et arg2. Attention, il n'y a pas d'espace autour des virgules!
3) Je n'ai pas trop testé, c'est juste une base. Notamment, si la description des dépendances est circulaire, le programme risque de boucler!