Parallélisation d'un programme

Version imprimable

Bonjour à tous

Dans le cadre d'un projet, j'ai créé une classe qui me permet de générer des mots de 8 bits en fonction d'un alphabet déterminé
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 class Mot { ... public byte[] motSuivant { } public byte[] motPrécédent() { } } class Programme { static void Main(string[] args) { byte[] mot = new byte[3]; cMot = new Mot("AB", 2); while() { mot = cMot.motSuivant; //ici on traite le mot } } }
Par exemple je veux des mots de 3 octets avec l'alphabet {A, B}. J'obtiens alors l'ensemble des mots suivants.

{AAA, AAB, ABA, ABB, BAA, BAB, BBA, BBB}

Jusqu'ici pas de problème tout fonctionne parfaitement. Ces mots sont ensuite traités. Le problème c'est qu'en fonction de la taille de l'alphabet et la taille du mot je peux me retrouver avec un nombre de mots très important. J'aimerais donc paralléliser tout cela, pour accélérer mon programme. Pourriez-vous me donner des pistes pour cela.

Merci

21/06/2017, 15h23
Pol63

tu peux utiliser le threadpool pour exécuter le traitement sur le mot
21/06/2017, 15h26
J@ckHerror

Bonjour,

Je dirais que les tuto de Francois Dorin disponible sur le site pourrait être un bon début...
:google: reste ton meilleur ami pour ce genre de requête...

J@ck.
21/06/2017, 15h41
nadjim

Merci bien, je vais jeter un coup d'œil et si j'ai besoin d'aide je reviens vous embêter. :mrgreen:
22/06/2017, 07h51
ericlm128

Une autre idée, pourquoi ne pas rendre ta classe mot de type "IEnumerable" avec "yield", puis un simple "Parallel.ForEach".
22/06/2017, 15h26
nadjim

ah oui c'est une idée intéressante aussi. Merci je vais aussi étudier cela.

Une idée, qui vaut ce qu'elle vaut :

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
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
 
namespace Samples
{
    // Mériterait une implémentation plus conforme au Framework, avec IEnumerable ou avec une méthode pour récupérer le résultat sous forme de collection
    public class Word
    {
        public Word(string alphabet, int size) { }
        public byte[] Next { get; }
        public bool HasNext { get; }
        public byte[] Previous { get; }
        public bool HasPrevious { get; set; }
    }
 
    public static class Parallelize
    {
        public static byte[] Process(byte[] item)
        {
            // Traiter le mot
            return item;
        }
 
        public static void Run()
        {
            var tasks = new List<Task<byte[]>>();
            var word = new Word("AB", 2);
 
            while (word.HasNext)
            {
                var item = word.Next;
                tasks.Add(Task.Run(() => Process(item)));
            }
 
            // On attend la fin des tâches
            Task.WhenAll(tasks).Wait();
 
            var results = tasks.Select(t => t.Result).ToArray();
            // Traitement des résultats
        }
 
        // La même en async
        public static async void RunAsync()
        {
            var tasks = new List<Task<byte[]>>();
            var word = new Word("AB", 2);
 
            while (word.HasNext)
            {
                var item = word.Next;
                tasks.Add(Task.Run(() => Process(item)));
            }
 
            // On sort de la méthode en attendant la fin des tâches
            await Task.WhenAll(tasks);
 
            var results = tasks.Select(t => t.Result).ToArray();
            // Traitement des résultats
        }
    }
}

Il est possible de traiter chaque tâche individuellement à sa complétion avec une boucle utilisant Task.WhenAny(), mais ce n'est pas forcément optimisé pour un grand nombre de tâches. Je suis tombé sur cet article de Stephen Toub sur la msdn en fouillant un peu ; il date un peu (2012) mais il paraît intéressant et présente notamment l'objet TaskCompletionSource.