Discussion :

[Dudule70]

Bonjour à tous,

Sur une production, je dois exécuter un traitement de données très lourd (env. 20 million de données) pour extraire des résultats statistiques.

Ces traitements s’effectuent en quatre étapes et sont indépendants.

Les méthodes :

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
29
30
31
 
private void Etape1() //Traitement 1
        {
            machines = new List<Machines>();
            paarung = new List<string>();
            paarung = AnalyserMachinesPako.Analyser("Paarung", typeSelection, gl.ListeAppairer, ref machines);
        }
 
        private void Etape2() //Traitement 2
        {
            machines = new List<Machines>();
            noPaarung = new List<string>();
            noPaarung = AnalyserMachinesPako.Analyser("NoPaarung", typeSelection, gl.ListeNonAppairer, ref machines);
        }
 
        private void Etape3() //Traitement 3
        {
            machines = new List<Machines>();
            klassierung1 = new List<string>();
            klassierung1 = AnalyserMachinesPako.Analyser("Klassierung1", typeSelection, gl.ListeClasseAiguilles1, ref machines);
        }
 
        private void Etape4()
        {
            machines = new List<Machines>();
            klassierung2 = new List<string>();
            klassierung2 = AnalyserMachinesPako.Analyser("Klassierung2", typeSelection, gl.ListeClasseAiguilles2, ref machines);
 
 
        }
       //........

Mon objectif est de gagner du temps sur ces traitements en lançant toutes ces méthodes en même temps. La plus lente serait le pacemaker.
Pour l’instant toutes mes solutions Thread, Parallel, PoolThread, Task ne me font rien gagner comme temps,
ce qui revient à faire ceci :

Code :

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

1
2
3
4
5
6
7
8
9
 
        private void Traitement()
        {
 
            Etape1();
            Etape2();
            Etape3();
            Etape4();
        }

Voici des exemples que j'ai testé :

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
 
        private void Traitement()
        {
            var t1 = Task.Factory.StartNew(() => { Etape1(); Etape2(); Etape3(); tape4(); });
            t1.Wait();
        }
// Et
         private void Traitement()
        {          
            ManualResetEvent mre = new ManualResetEvent(false);
            Thread t = new Thread(
                () =>
                {
                    Etape1();
                    Etape2();
                    Etape3();
                    Etape4();
                    mre.Set();
                });
            t.Priority = ThreadPriority.Highest;
            t.Start();
            Thread.Sleep(1);
            mre.WaitOne();
}
 
//............

Le Wait et WaitOne attendent que chacune des étapes soient exécutées pour passer à la suivante donc je ne gagne rien.
En résumé, j’aimerais que l’exécution la plus lente masque les autres.

En vous remerciant pour votre aide !
Cordialement.

[François DORIN]

Bonjour,

Tu ne gagnes rien car tu lances toutes tes opérations dans la même tâche !

Il faut que tu fasses une tâche = une opération.

Code C# :

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

1
2
3
4
5
6
7
8
private void Traitement()
{
   Task taskEtape1 = Task.Run(() => { Etape1(); });
   Task taskEtape2 = Task.Run(() => { Etape2(); });
   Task taskEtape3 = Task.Run(() => { Etape3(); });
   Task taskEtape4 = Task.Run(() => { Etape4(); });
   Task.WaitAll(taskEtape1, taskEtape2, taskEtape3, taskEtape4);
}

Task.Factory.StartNew et Task.Run sont équivalents dans ton cas. La seule différence c'est que Task.Run n'apparait qu'avec la version 4.5 du framework .Net.

[Dudule70]

Bonjour Dorinf et merci beaucoup pour votre réactivité !

Task.Factory.StartNew et Task.Run sont équivalents dans ton cas. La seule différence c'est que Task.Run n'apparait qu'avec la version 4.5 du framework .Net.

Task.Run, je l'avais abandonné justement à cause du framework 4.5 (et c'est un problème usine) ce soft devra être déployé sur des machines avec un framework 4.

J'ai essayé beaucoup de chose, donc ce n'est pas faisable sans TaskRun ?
Cordialement.

[François DORIN]

J'ai essayé beaucoup de chose, donc ce n'est pas faisable sans TaskRun ?

Si ! Justement, je disais que dans ce cas Task.Factory.StartNew était équivalent à Task.Run. Il suffit donc d'utiliser Task.Factory.StartNew

[Dudule70]

Désolé pour mon cafouillage!

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
           Task t1 = Task.Factory.StartNew(() => Etape1());
            //t1.Wait();
 
            Task t2 = Task.Factory.StartNew(() => Etape2());
            //t2.Wait();
 
            Task t3 = Task.Factory.StartNew(() => Etape3());
            //t3.Wait();
 
            Task t4 = Task.Factory.StartNew(() => Etape4());
            //t4.Wait();
            Task.WaitAll(t1, t2, t3, t4);

C'est mon problème d'origine le Task.WaitAll bloc l'appli.
Pi:le tx.Wait() passe mais me renvoi à mon pb de départ.

Je ne m'explique pas pourquoi?

[Dudule70]

J'ai trouvé mon Pb C'est de ma faute une blague de débutant.

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
29
30
31
32
33
34
35
36
37
 
        private void Etape1() //private void Premier(object data)
        {
          //machines = new List<Machines>(); C'était la même variable  ce qui bloquait tout au Waitall
 
            List<Machines> machines1 = new List<Machines>(); //beaucoup  mieux 
            paarung = new List<string>();
            paarung = AnalyserMachinesPako.Analyser("Paarung", typeSelection, gl.ListeAppairer, ref machines1);
        }
 
        private void Etape2()
        {
            List<Machines> machines2 = new List<Machines>();
            noPaarung = new List<string>();
            noPaarung = AnalyserMachinesPako.Analyser("NoPaarung", typeSelection, gl.ListeNonAppairer, ref machines2);
        }
 
        private void Etape3()
        {
            List<Machines> machines3 = new List<Machines>();
            klassierung1 = new List<string>();
            klassierung1 = AnalyserMachinesPako.Analyser("Klassierung1", typeSelection, gl.ListeClasseAiguilles1, ref machines3);
        }
 
        private void Etape4()
        {
            List<Machines> machines4 = new List<Machines>();
            klassierung2 = new List<string>();
            klassierung2 = AnalyserMachinesPako.Analyser("Klassierung2", typeSelection, gl.ListeClasseAiguilles2, ref machines4);
        }
 
 
            Task t1 = Task.Factory.StartNew(() => Etape1());
            Task t2 = Task.Factory.StartNew(() => Etape2());
            Task t3 = Task.Factory.StartNew(() => Etape3());
            Task t4 = Task.Factory.StartNew(() => Etape4());
            Task.WaitAll(t1, t2, t3, t4);

Merci beaucoup Dorinf, c'est un super coup de main qui m'a ouvert les yeux et conforté.

[François DORIN]

C'est mon problème d'origine le Task.WaitAll bloc l'appli.

Il faudrait peut être l'énoncer dans le problème de départ !

Le problème tel que tu l'as exposé consistait à exécuter en parallèle les différentes étapes, afin que l'étape la plus lente soit le "pacemaker".

Si tu souhaites attendre que chacune des étapes soient terminée, pour lancer une action et ceci sans bloquer ton programme, il faut que tu utilises TaskFactory.ContinueWhenAll.

Code C# :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
private void Traitement()
{
   Task taskEtape1 = Task.Run(() => { Etape1(); });
   Task taskEtape2 = Task.Run(() => { Etape2(); });
   Task taskEtape3 = Task.Run(() => { Etape3(); });
   Task taskEtape4 = Task.Run(() => { Etape4(); });
   TaskFactory.ContinueWhentAll(new Task[] {taskEtape1, taskEtape2, taskEtape3, taskEtape4},
                                            () => {... code à exécuter quand toutes les tâches sont terminées...});
 
   // Ici le code n'est pas bloqué et continue son exécution.
}

Pour info, Task.WaitAll bloque ton programme car c'est justement sa fonction ! Attendre que toutes les tâches passées en paramètre ait terminé leur exécution avant de rendre la main...

[edit]
Bon, je n'avais pas vu ton "erreur de débutant" Je laisse malgré tout le message car il apporte des info sur une manière de procéder pour générer une action dès que les tâches ont terminé leur exécution sans avoir à bloquer le programme sur un WaitAll
[/edit]