Discussion :

[azrop]

Bonjour,

Je dispose d'une boucle de comparaison assez longue (5000 à 25000 éléments cela varie) entre des éléments qui sont des fonctions mathématiques. Pour comparer 2 fonctions je calcule leur distance à un histogramme par la méthode des moindres carrés (je ne rentre pas dans les détails mais cela fait pas mal de calcul) et donc ma boucle peut prendre jusque 2sec de temps à autre, ce n'est pas beaucoup mais quand il faut 50 itérations (50 boucles de comparaisons) cela commence à faire un peu beaucoup.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
for( FctPoly functionLoop : pop) {                                  // on itère sur toutes les fonctions de ma liste
	if (  this.moindreCarre(functionLoop) < val ) {             // on calcul la valeur MoindreCarrée de la fonction et si elle est inférieur au minimum actuel on entre dans le 'if'
		f_parents =  this.insert(f_parents, functionLoop) ; // on l'ajoute à la liste des bonnes fonctions
		val = this.moindreCarre( f_parents.get(f_parents.size()-1) ) ;      // on met à jour notre minimum
	}
}
//des changements sont apportés au fonction ici

Et tout cela est dans un while(val>precision) on va donc répéter la boucle jusqu'à valider la condition et cela peut prendre du temps

Mon idée vient de ce que j'ai vu en cours avec OpenMP (et langage C) où on peut diviser une boucle en différents morceaux et dire à plusieurs Threads de s'occuper d'un bout de la boucle, après mon algo doit pouvoir tourner sur différentes machines, donc pas besoin de monter à plus de 4 Threads car si la machine à moins de coeurs cela sera inutile, mais au moins diviser par 2 si possible

Autre point : avant toute cette manip, je trie ma liste de fonction (taille 5000 à 25000) avec une implémentation du QuickSort adapté bien sur à mon cas et choisissant comme critère le calcul MoindreCarré, mais je me demande en même temps si implémenter un Comparator et faire un sort(liste,MyComparator) ne serait pas plus rapide ? Mais je n'en ai aucune idée

[tchize_]

Avec java 8 et les stream ce serait assez simple.

Pour avoir tout ce qui match, avec un stream parallele:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

liste = pop.stream().parallel().filter((i) -> moindreCarre(i) < val).collect(Collectors.asList());

[azrop]

Avec java 8 et les stream ce serait assez simple.
Pour avoir tout ce qui match, avec un stream parallele:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

liste = pop.stream().parallel().filter((i) -> moindreCarre(i) < val).collect(Collectors.asList());

Ow je connaissais les streams mais que les trucs "de base" pas ce genre de fonctionnalités, il faudrait que je lise 2-3 trucs j'y découvrirait surement des outils pas mal !

Le principe est le bon, mais après pour mon cas et bien je n'ai pas réellement besoin de récupérer une liste des éléments qui sont moindreCarré inférieur à val

Mais comme je viens de lire sur la parallélisation (et ce qui me semble logique au final) c'est que c'est rentable sur des calculs indépendants, sinon s'il faut tenir compte de toute les valeurs ça ne sera pas plus performant voir pire
Et comme je cherche au final à trouver les minimums de ma liste, je remarque que paralléliser n'est peut-être pas le mieux

[tchize_]

Et comme je cherche au final à trouver les minimums de ma liste, je remarque que paralléliser n'est peut-être pas le mieux

C'est à voir évidement en fonction de tes algorithmes. Pour prendre un exemple de base, le max de N nombre, ça se paralléliste très bien en cherchant le max de chaque sous set, puis le max des max. Et l'api stream permet de faire ce genre de construction facilement en mettant à disposition du filtrage parallèle, de l'aggrégation supportant le parallélisme, etc.

[azrop]

C'est exactement le genre de choses que j'ai fait en cours mais dans un langage différent c'est donc assez dur de trouver les équivalents, enfin surtout là donc je veux bien quelques pistes j'ai cherché un peu mais je ne trouve comment diviser, trouver les min et re-fusionner

Pour le moment cette ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

f4 = (ArrayList<FctPoly>) f4.stream().sorted((f1,f2)->Double.compare(histo.moindreCarre(f1), histo.moindreCarre(f2))).collect(Collectors.toList());

est plus performante que mon quickSort que j'avais fait ça me fera gagné des lignes de codes au moins (même sur des tailles de 10 c'est mieux)

Sinon pour trouver un groupe de minimum je pensais à trier la liste puis récupérer les 10 premiers par ex, mais côté parallélisation je sais pas trop ce qui est le mieux (j'ai aussi remplacé stream par parallelstream mais c'est moins performant, mais c'est normal car peu de données et le traitement n'est pas indépendant)

[tchize_]

pour la parallélisation, faut tester. Le sorted je pense supporte la parallélisation. Tu va avoir N stream triés puis au moment du collect on comparera les têtes de chaque stream.

Donc 10 streams // pou 10 données ce nr sera pas performant,
10 streams pour 1 million de données, ça risque d'être mieux

[adiGuba]

Salut,

Sinon pour trouver un groupe de minimum je pensais à trier la liste puis récupérer les 10 premiers par ex, mais côté parallélisation je sais pas trop ce qui est le mieux (j'ai aussi remplacé stream par parallelstream mais c'est moins performant, mais c'est normal car peu de données et le traitement n'est pas indépendant)

Attention car si les opérations ne sont pas indépendante cela peut même fausser le résultat du parallelStream...

j'ai cherché un peu mais je ne trouve comment diviser, trouver les min et re-fusionner

C'est à dire ?
Que cherche-tu à récupérer exactement comme résultat ?
Que fait la méthode histo.moindreCarre() ?


a++