Exécution de tâches en temps masqué

Version imprimable

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:

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:

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

Voici des exemples que j'ai testé :

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
 
        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.

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:

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.

08/09/2016, 10h12
Dudule70

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

Citation:

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.
08/09/2016, 10h16
François DORIN

Citation:

Envoyé par Dudule70

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

Désolé pour mon cafouillage!

Code:

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?

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

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
 
        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é.

Citation:

Envoyé par Dudule70

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:

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" :D 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]