Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

Parallélisation d'un programme


Sujet :

C#

  1. #1
    Membre à l'essai
    Parallélisation d'un programme
    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 :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
    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

  2. #2
    Expert éminent sénior
    tu peux utiliser le threadpool pour exécuter le traitement sur le mot
    Cours complets, tutos et autres FAQ ici : C# - VB.NET

  3. #3
    Membre expérimenté
    Bonjour,

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

    J@ck.
    Pas de réponse par MP, merci.

    Penser au ça fait plaisir

  4. #4
    Membre à l'essai
    Merci bien, je vais jeter un coup d'œil et si j'ai besoin d'aide je reviens vous embêter.

  5. #5
    Expert confirmé
    Une autre idée, pourquoi ne pas rendre ta classe mot de type "IEnumerable" avec "yield", puis un simple "Parallel.ForEach".

  6. #6
    Membre à l'essai
    ah oui c'est une idée intéressante aussi. Merci je vais aussi étudier cela.

  7. #7
    Membre chevronné
    Une idée, qui vaut ce qu'elle vaut :

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

###raw>template_hook.ano_emploi###