Parallelisation - Githubissues

ronan-cariou commented 6 months ago

Mettre en place la parallélisation. Il s'agit de détecter le nombre de cœurs et de lancer en parallèle ce qu'il est possible de paralléliser.

Commencer par la déconvolution des chaque datafile.
Si ok, voire ensuite pour msConvert.

Est-ce applicable à la création des fichiers d'export, voire à l'affichage des graphiques ? Si oui, on en discute avant une nouvelle issue.

DamienCode404 commented 5 months ago

Test parallélisation du code de déconvolution.

parallelisation

Le problème étant que le code que j'ai utilisé est censé ne pas prendre toute la puissance du processeur. Je prends le nombre de cœurs du processeur moins 2, mais quand je regarde dans le gestionnaire des tâches, le processeur passe en pic constant à 100%.

Peut-être faire un test sur une autre machine ?

Code utilisé pour le test : ncores <- detectCores() - 2L cl <- makeCluster(ncores)

DamienCode404 commented 5 months ago

Test du temps d'exécution sur le même échantillon : jeu de données 20220611_072

Avant parallélisation : CP-Seeker_2 1 1

Après parallélisation : CP-Seeker_2 1 2

Gain moyen d'environ 35% mais le temps reste assez conséquent.

jsaintvanne commented 5 months ago

Hello ! On y pensait hier avec Ronan aussi : attention à l'écriture dans la DB lors de la parallèlisation ! On pense que cela peut potentiellement poser problème d'avoir l'écriture de la déconvolution qui se fait en même temps... Cela est-il gérer par les packages de parallèlisation ? Toutes les données sont-elles bien sauvegardées ?

DamienCode404 commented 5 months ago

Je suis en train de tester CP-Seeker 2.0.0 (sans parallélisation) sur la machine PC retraitement 2. Le test s'effectue sur le jeu de 100 fichiers raw. Le but étant d'avoir un référentiel pour les prochains tests avec l'ajout de la parallélisation.

Actuellement l'import des 100 fichiers a mis 1 h 30. Je suis en train de voir au niveau de l'import pour ajouter de la parallélisation.

En même temps, j'ai lancé l'étape de déconvolution avec Family = PCA / Adduct(s) = M+Cl.

Chronomètre	Pourcentage	Durée	Approximation du temps final
2h23	0%	0 min
2h48	10%	25 min	250 min
3h16	20%	53 min	265 min
3h28	25%	1h05	260 min
4h47	50%	2h24	288 min

(Je vais éditer ce message lorsque le temps réel sera récupéré)

Demain, je vais voir le temps d'exécution de l'étape d'exportation en csv et xlsx.

Une fois que ce premier test sera fini, je vais pouvoir comparer avec le nouveau code pour essayer de voir si on constate une réelle amélioration.

ronan-cariou commented 5 months ago

Parfait. Juste une question sur la version. Pourquoi 2.0.0 alors que la version actuelle est 2.1.2 ?

DamienCode404 commented 5 months ago

Simplement parce que la version 2.0.0 était déjà installée sur la machine PC retraitement 2. Donc plus simple pour commencer les tests. J'ai regardé le code et les fonctions m'ont l'air presque identiques pour la déconvolution, l'importation et l'exportation.

ronan-cariou commented 5 months ago

Ok alors on repart de zéro avec la version 2.1.2 stp. C'est la version à partir de laquelle tu travailles. Ronan.

DamienCode404 commented 5 months ago

Ok pas de problèmes ! Je vais installer la version 2.1.2 de la branche main sur la machine PC retraitement 2. Je mets de côté ce que j'ai pour mon rapport, ça peut toujours être intéressant d'avoir une traçabilité de l'évolution des performances en fonction des versions du logiciel. Pour pouvoir argumenter la partie sur l'optimisation des performances.

ronan-cariou commented 5 months ago

Dans la mesure su temps de process, assures-toi que personne d'autre ne sollicite le PC2, pour ne pas biaiser. Repères qui a une session ouverte et va poser la question dans le bocal. Nicolas a réservé la machine pour demain. Alternativement, je peux te laisser la place sur PC3.

DamienCode404 commented 5 months ago

Comment vérifier si une autre personne utilise sa session en même temps que moi ? Je ne pensais pas que l'on pouvait être à plusieurs sur un même PC retraitement. Le problème étant que si je me connecte à un autre PC, je vais devoir à nouveau tout télécharger (version de CP-Seeker 2.1.2 et ma version). Je peux laisser la machine à Nicolas demain, je vais la réserver (PC2) pour un autre jour. Comment faire pour la réserver ? Demain, je vais continuer d'ajouter de la parallélisation à l'import et à l'export et faire des tests moins longs en local.

DamienCode404 commented 5 months ago

Process cluster creation

detectCores va récupérer le nombre de processeurs logiques detectCores <- detectCores()

ncores est le nombre de processeurs que nous allons utiliser ncores <- detectCores/2

cl est le cluster de processeur logique qui va être appliqué pour le calcul cl <- makeCluster(ncores)

Sur ma machine en local, j'ai 4 cœurs et 8 threads (processeurs logiques). Chaque cœur à deux processeurs logiques. Le programme va donc détecter un nombre de 8 threads pour les calculs. Je vais les diviser par 2 donc on va se retrouver avec seulement 4 pour les calculs (création du cluster pour le calcul qui va être détruit à la fin de la parallélisation).

Donc, je vais bien avoir en théorie la moitié des cœurs qui vont fonctionner, mais je ne choisis pas comment ils vont tourner. Je m'explique :

4 cœurs peuvent tourner à moitié (1 processeur sur les deux)
2 cœurs peuvent tourner à fond (2 processeurs par cœur)

Également, si je rentre en dur le nombre de processeurs (ici 4), il faut que je vérifie s'ils sont réellement disponibles. La fonction detectCores() a l'air de récupérer le nombre de processeurs logiques disponibles en instantané, il est possible que le programme renvoie NA (non available). Il faut que je rajoute une condition avec un nombre de cœurs minimal par défaut de 2 qui fonctionnerait sur n'importe quelle machine.

Le code qui va être utilisé pour la parallélisation :

detectCores <- detectCores()
if (!is.na(detectCores)) {
  ncores <- round(detectCores() / 2L)
} else {
  ncores <- 2L
}
cl <- makeCluster(ncores)

Avec la librairie parallel il est possible d'utiliser ces fonctions :

clusterApply() : Applique une fonction à chaque élément d'une liste sur un cluster de nœuds de manière séquentielle.
parSapply() : parralélisation de sapply (renvoie une liste, mais tente de simplifier lorsque c'est possible)
parLapply() : parallélisation de lapply (renvoie toujours une liste)
clusterApplyLB(), parSapplyLB(), parLapplyLB() : Ajoute un mécanisme de répartition de charge (Load Balancing) pour équilibrer la charge de travail entre les nœuds du cluster. Cela garantit que chaque nœud traite une quantité similaire de travail, optimisant ainsi l'utilisation des ressources et améliorant les performances globales de la parallélisation.

Dans les tests que j'ai effectués, le mieux serait d'utiliser le plus possible parLapplyLB(). Le plus efficient quelque soit le nombre de processeurs de la machine utilisée. Les méthodes "Load Balancing" sont toujours meilleures.

ronan-cariou commented 5 months ago

Ok pour l'approche. A terme, j'imagine que tu vas prendre plus que la moitié, mais pour les tests, ça me va.

DamienCode404 commented 5 months ago

Je suis sur la machine PC retraitement 2 et j'ai trouvé le moyen de voir l'utilisation des processeurs logiques individuellement. Il faut faire un clic droit dans le Task Manager > Change graph to > Logical processors

yguitton / CP-Seeker

Parallelisation #45