Récursivité et exécution d'un programme externe en parallèle (ExecutorService, ProcessBuilder)

Version imprimable

Bonjour,

1) J'ai un exécutable externe à JAVA qui prend en entrée un fichier et m'en ressort un autre après traitement

2) J'ai besoins de faire varier des valeurs dans le fichier d'entrée et de lire le fichier de résultat pour trouver les meilleurs valeurs.

3) Les valeurs en entrée sont généré par une fonction récursive qui incrémente chaque paramètre pour obtenir toute les combinaisons possible.

4) Lorsque j’exécute le programme externe dans la méthode récursive cela fonctionne très bien mais je suis obliger de laisser tourner toute une nuit pour obtenir des valeurs vu que la consommation CPU n’excède pas les 10%

5) J'essais maintenant de lancer plusieurs programme en parallèle en utilisant ExecutorService pour gérer le nombre et le programme externe est exécuté via un ProcessBuilder

666) C'est là que ça ce gâte.
Dans une simple boucle FOR j'ai bien le nombre d’exécutable défini par l'ExecutorService lancé en même temps mais lorsque je place l’exécution dans ma fonction récursive je n'ai aucune variation des données. En fait si, j'ai une variation au tout début mais après plus rien.

L'utilisation du ExecutorService

Code:

ExecutorService exec = Executors.newFixedThreadPool(8);

La génération des combinaisons avec Nom, borne basse, borne haute et incrément:
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 public static void combinaison() { List<Param> listeParam = Arrays.asList( new Param("PARAM_ID", 2, 15, 1), new Param("PARAM_RA", 0, 25, 5), new Param("PARAM_RB", 0, 100, 10), new Param("PARAM_RC", 40, 500, 20), new Param("PARAM_RD", 20, 300, 20) ); long nbrCombinaison = 1; for (Param param : listeParam) { long diff = (param.max - param.min); long inc = diff / param.inc + 1; nbrCombinaison = nbrCombinaison * inc; } System.out.println("Nombre de combinaison : "+nbrCombinaison); recur(listeParam, 0); } private static void recur(List<Param> listeParam, int index) { Param param = listeParam.get(index); while (param.value <= param.max) { if (index < listeParam.size() - 1) { recur(listeParam, index + 1); param.value = param.value + param.inc; } else { exec.execute(new ProcessRunnable(nbr,listeParam)); nbr++; param.value = param.value + param.inc; } } param.value = param.min; }
Comme vous pouvez le voir j'ai un Runnable qui est placé dans la fonction récursive qui va lire la combinaison courante. (L28)

Le programme est exécuté comme ceci dans le Runnable :

Code:

new ProcessBuilder(".exe" ,"-b", file).start().waitFor();

Pouvez vous m'aider ?

Si vous avez besoins d'autre bout de code ...

Merci

Un exemple de combinaison si je remplace l’exécution du Runnable par cette fonction traitement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
    private static void traitement(List<Param> listeParam) {
        String combinaison = "";
        for (int i = 0; i < listeParam.size(); i++) {
            Param param = listeParam.get(i);
            combinaison = combinaison + param.value;
            if (i < listeParam.size() - 1) {
                combinaison = combinaison + ";";
            }
 
        }
        System.out.println(combinaison);
    }

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
Nombre de combinaison : 332640
2;0;0;40;20
2;0;0;40;40
2;0;0;40;60
2;0;0;40;80
2;0;0;40;100
2;0;0;40;120
2;0;0;40;140
2;0;0;40;160
2;0;0;40;180
2;0;0;40;200
2;0;0;40;220
2;0;0;40;240
2;0;0;40;260
2;0;0;40;280
2;0;0;40;300
2;0;0;60;20
2;0;0;60;40
2;0;0;60;60
2;0;0;60;80
2;0;0;60;100
2;0;0;60;120
2;0;0;60;140
2;0;0;60;160
2;0;0;60;180
2;0;0;60;200
2;0;0;60;220
2;0;0;60;240
2;0;0;60;260
2;0;0;60;280
2;0;0;60;300
2;0;0;80;20
2;0;0;80;40
2;0;0;80;60
2;0;0;80;80
2;0;0;80;100
2;0;0;80;120
2;0;0;80;140
2;0;0;80;160
2;0;0;80;180
2;0;0;80;200

15/09/2014, 03h08
thelvin

Mais... Tu dis que tes données d'entrées viennent d'un fichier lu par ton programme externe (et les données de sorties dans un fichier écrit par ce programme.)

Si tu fais ces traitements en parallèle... T'as pensé à utiliser des fichiers différents pour chaque traitement parallèle ? Il est où le code qui gère ça, c'est important.

Bonjour,

Oui je génère un fichier par combinaison avec un index dans le nom, donné au programme externe et détruit à la fin.

Les fichiers sont bien généré et la simulation fonctionne mais les valeurs de combinaison ne sont pas incrémenté dans les fichiers.

Vu que c'est juste un outil pour faciliter la vie sur un autre projet j'ai fais ça vite fait ce weekend donc c'est un brouillon

Le code est bien entendu a améliorer :mouarf:

Voilà le tout :

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
package javaapplication2;
 
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
 
public class Param {
 
    public String name;
    public long value;
    public long min;
    public long max;
    public long inc;
 
    public static int nbr = 0;
    public static final String biasFile = ProcessRunnable.getContent(new File("C:/combinaison/schematicBIAS.net"));
    public static final String thdFile = ProcessRunnable.getContent(new File("C:/combinaison/schematicTHD.net"));
    public static ExecutorService exec = Executors.newFixedThreadPool(8);
 
 
    public Param(String name, int min, int max, int inc) {
        this.name = name;
        this.value = min;
        this.min = min;
        this.max = max;
        this.inc = inc;
    }
 
    private static void traitement(List<Param> listeParam) {
        String combinaison = "";
        for (int i = 0; i < listeParam.size(); i++) {
            Param param = listeParam.get(i);
            combinaison = combinaison + param.value;
            if (i < listeParam.size() - 1) {
                combinaison = combinaison + ";";
            }
 
        }
        System.out.println(combinaison);
    }
 
 
    public static void combinaison()  {
        List<Param> listeParam = Arrays.asList(
                new Param("PARAM_ID", 2, 15, 1),
                new Param("PARAM_RA", 0, 25, 5),
                new Param("PARAM_RB", 0, 100, 10),
                new Param("PARAM_RC", 40, 500, 20),
                new Param("PARAM_RD", 20, 300, 20)
        );
 
        long nbrCombinaison = 1;
        for (Param param : listeParam) {
            long diff = (param.max - param.min);
            long inc = diff / param.inc + 1;
            nbrCombinaison = nbrCombinaison * inc;
        }
        System.out.println("Nombre de combinaison : "+nbrCombinaison);
        recur(listeParam, 0);
    }
 
    private static  void recur(List<Param> listeParam, int index) {
        Param param = listeParam.get(index);
        while (param.value <= param.max) {
            if (index < listeParam.size() - 1) {
                recur(listeParam, index + 1);
                param.value = param.value + param.inc;
            } else {
               // traitement(listeParam);
               exec.execute(new ProcessRunnable(nbr,listeParam));
                nbr++;
                param.value = param.value + param.inc;
            }
        }
        param.value = param.min;
    }
}

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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package javaapplication2;
 
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;
import static javaapplication2.Param.nbr;
 
class ProcessRunnable implements Runnable{
 
    private int nbr;
    private List<Param> listeParam;
 
    ProcessRunnable(int nbr,List<Param> listeParam) {
        super();
        this.nbr=nbr;
        this.listeParam  =listeParam;
    }
 
    @Override
    public void run(){
        try {
            String biasFile = Param.biasFile;
            for (Param param : listeParam) {
                String name =param.name;
                String value = "";
                if(param.value==0){
                    value = "0.001";
                }else{
                    value = String.valueOf(param.value);
                }
                System.out.println(name + " / " +value);
                biasFile=  biasFile.replaceAll(name,value);
            }
            File f = new File("C:/combinaison/sim/schematicBIAS"+this.nbr+".net");
            Charset charset = Charset.forName("UTF-8");
            Writer writer = new OutputStreamWriter(new FileOutputStream(f), charset);
            try {
                writer.append(biasFile);
            } finally {
                writer.close();
 
            }
            execCAD("C:/combinaison/sim/schematicBIAS"+this.nbr+".net");
            System.out.println(this.nbr+" / " + bias("C:/combinaison/sim/schematicBIAS"+this.nbr+".log"));
 
            f.delete();
            new File("C:/combinaison/sim/schematicBIAS"+this.nbr+".log").delete();
            new File("C:/combinaison/sim/schematicBIAS"+this.nbr+".raw").delete();
 
 
 
        } catch (IOException ex) {
            Logger.getLogger(ProcessRunnable.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InterruptedException ex) {
            Logger.getLogger(ProcessRunnable.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
 
    private static Float bias(String file) throws FileNotFoundException, IOException {
        BufferedReader buff = new BufferedReader(new FileReader(file));
        String line;
        while ((line = buff.readLine()) != null) {
            if (line.contains("i(v5)")) {
                buff.close();
                String valeur = line.split("-")[2];
                return Float.valueOf(valeur);
            }
        }
        buff.close();
        return null;
    }
 
    private static void execCAD(String file) throws IOException, InterruptedException  {
        new ProcessBuilder("cad.exe" ,"-b", file).start().waitFor();
    }
 
    public static String getContent(File file) {
        String content = null;
        InputStream in = null;
        try {
            in = new BufferedInputStream(new FileInputStream(file));
            byte[] bytes = new byte[in.available()];
            in.read(bytes);
            content = new String(bytes);
 
        } catch (Exception e) {
            e.printStackTrace();
        }
        finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return content;
    }
}

15/09/2014, 10h38
thelvin

D'accord. Effectivement, les fichiers ont l'air d'être bien gérés pour le multithread.

Ta List<Param> par contre... Tu la confies joyeusement aux threads de l'Executor, tout en continuant à la modifier dans ton thread principal.
Ça va pas marcher -_-°. Il faut que tu construises une copie de la List, qui contient une copie de chaque Param, aux ProcessRunnable que tu construis.
15/09/2014, 11h11
6su7

Merci beaucoup,

Tu confirme ce que je me suis dis ce matin, ne plus passer la liste en paramètre mais directement les valeurs sous forme d'une MAP de String ou un autre objet plus simple que Param.

Je vais essayer ça
15/09/2014, 12h40
6su7

Oui ça fonctionne en construisant un autre objet à passer en paramètre.

Encore merci !

Un exemple pour 500 exécutions :

Sur un I5 M540 @ 2.5GHz ( 2 coeurs / 4 threads)

1 thread : 112sec
4 threads : 49sec
12 threads : 26sec ce qui est pas mal même si j'aurais espéré moins, il faut que j'essais avec une autre machine

Salut,

Désolé mais ce bout de code m'a fait hurler :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 private static void traitement(List<Param> listeParam) { String combinaison = ""; for (int i = 0; i < listeParam.size(); i++) { Param param = listeParam.get(i); combinaison = combinaison + param.value; if (i < listeParam.size() - 1) { combinaison = combinaison + ";"; } } System.out.println(combinaison); }
:arrow: Il ne faut jamais utiliser l'opérateur + sur une String dans une boucle, car cela génère un grand nombre d'objet temporaire, ce qui va surcharger le GC inutilement.
De plus le temps d'exécution sera exponentielle : il augmentera très vite avec le nombre d'itération.

Chez moi ca donne à peu près ceci :

2ms pour 100 éléments.
8ms pour 1000 éléments.
300ms pour 10 000 éléments.
31 000ms pour 100 000 éléments.
??? pour 1 000 000 éléments (je n'ai pas eu le courage d'attendre jusqu'à la fin).

Pour construire une chaine de caractère il faut utiliser StringBuilder :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 private static void traitement(List<Param> listeParam) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < listeParam.size(); i++) { Param param = listeParam.get(i); sb.append(param.value); if (i < listeParam.size() - 1) { sb.append(";"); } } String combinaison = sb.toString(); System.out.println(combinaison); }
Ce qui donne des résultats bien plus respectable :

moins d'1ms pour 100 éléments.
moins d'1ms pour 1000 éléments.
moins d'1ms pour 10 000 éléments.
16ms pour 100 000 éléments.
50ms pour 1 000 000 éléments.

Sinon je noterais comme dans beaucoup de code une gestion aléatoire des ressources.
Pour bien faire il faut utiliser soit le try-with-ressource de Java 7, soit un try/finally par ressource, et ce dans tous les cas.

Enfin la gestion des exceptions n'est pas très adéquate (on loggue l'erreur... mais on continue comme si de rien n'était).

a++

15/09/2014, 14h11
6su7

Merci adiGuba, j'appliquerais tes recommandations dans la version suivante.

Je me doute que tout ceci n'est pas bien mais ce n'est qu'un brouillon réalisé entre deux biberons demandés par mon fils de moins de deux mois :)

La fonction traitement n'existe même plus, je ne l'ai faite que pour vérifier que ma génération de combinaisons fonctionnait correctement.

Effectivement j'utilise habituellement StringBuilder, je gère correctement les exceptions, je log correctement avec log4J et je gère correctement mes ressources.

Mon but premier était de vérifier si ce que je viens de faire était possible, je vais maintenant pouvoir réfléchir à une architecture, une structure de données pour la persistance et une interface.