Imbriquée Parallèle.Les Boucles ForEach sur la même liste?

J'ai besoin de paralléliser une méthode qui ne exhaustive comparaison par paires sur des éléments dans une liste. Le numéro de série de la mise en œuvre est simple:

foreach (var element1 in list)
    foreach (var element2 in list)
        foo(element1, element2);

Dans ce cas, toto ne pas modifier l'état de element1 ou element2. Je sais qu'il n'est pas sûr pour le faire simplement imbriquée Parallèle.ForEach états:

Parallel.ForEach(list, delegate(A element1)
{
    Parallel.ForEach(list, delegate(A element2)
    {
        foo(element1, element2);
    });
});

Quel serait le moyen idéal pour mettre en œuvre cette aide de l'parallèle des tâches de la bibliothèque?

InformationsquelleAutor Wesley Tansey | 2010-07-19
  1. 11

    Ne pouvais pas vous avez juste une Parallèle et une seule boucle? Donc, soit

    Parallèle.ForEach(liste, délégué(Un element1) 
{ 
foreach(Un element2 dans la liste) 
foo(element1, element2) 
});

    ou

    foreach(Un element1 dans la liste) 
{ 
En parallèle.ForEach(liste, délégué(Un element2) 
{ 
foo(element1, element2); 
}); 
}

    Devrait accélérer ainsi. Il n'a jamais été un thread par le cycle de toute façon, ce serait probablement tout aussi rapide ou un peu plus lent que imbriqués les boucles parallèles.

    InformationsquelleAutor Jouke van der Maas
  2. 15

    Au moins si vous êtes l'exécution du code sur une machine où le nombre de cœurs est au moins deux fois le nombre d'éléments dans la liste, je ne suis pas sûr que c'est une bonne idée de faire embedded Parallel.ForEachs.

    En d'autres termes, si vous ciblez un processeur quad-core, et la liste a un millier d'articles, juste paralléliser le parent boucle. La parallélisation de deux boucles ne serait pas rendre le code plus rapide, mais plutôt beaucoup, beaucoup plus lent, depuis les tâches parallèles à la performance de coût.

    le texte d'alt http://www.freeimagehosting.net/uploads/ca97f403f8.png

    À chaque itération, à quelques millisecondes sera perdu par Parallel.ForEach pour déterminer le thread qui doit exécuter la prochaine itération. Disons que vous avez un ensemble de 7 points. Si vous paralléliser le parent boucle, les millisecondes sera perdu 7 fois. Si vous paralléliser les deux boucles, elles seront perdues 7×7=49 fois au lieu. Plus grande est l'ensemble, plus grande est la surchauffe.

    • Ne présumez pas que PFX permettra de créer autant de threads qu'il y a des tâches en parallèle - c'est plus intelligent que cela.
    • Bien sûr que non. Par défaut, il crée autant de threads que de cœurs. Mais le problème est que, après chaque itération, il va passer du temps à essayer de trouver le thread qui doit exécuter la prochaine itération.
    • Je ne pense pas qu'il dit qu'il va être le nombre de threads, c'est juste que enqueueing une tâche pour chaque appel de fonction va avoir beaucoup plus de ressources que simplement en invoquant le PFX moteur pour chaque boucle externe.
    • Grâce MainMa. Il est sans doute intéressant de noter que foo est susceptibles de prendre beaucoup de temps par rapport au coût de la Parallèle.ForEach appel. Je comprends l'argument général que pour la parallélisation d'une boucle.
    InformationsquelleAutor Arseni Mourzenko
  3. 1

    Les deux boucles imbriquées signifie essentiellement que vous voulez foo la cartessian produit de la liste avec lui-même. Vous pouvez paralléliser l'ensemble de l'opération en créant d'abord toutes les paires dans une liste temporaire, puis en itérant sur cette liste, avec en Parallèle.ForEach.

    MODIFIER: au Lieu de créer une liste de toutes les combinaisons, vous pouvez utiliser un itérateur pour revenir à 2-élément d'un tuple avec la combinaison. En parallèle.ForEach va encore paralléliser le traitement de la n-uplets.

    L'exemple suivant affiche le courant de l'itération de l'étape de montrer que les résultats de revient de dehors-de-commande, tel que prévu au cours du traitement en parallèle:

     const int SIZE = 10;
    static void Main(string[] args)
    {
        List<int> list = new List<int>(SIZE);
        for(int i=0;i<SIZE;i++)
        {
            list.Add(i);
        }


        Parallel.ForEach(GetCombinations(list),(t,state,l)=>
            Console.WriteLine("{0},{1},{2}",l,t.Item1,t.Item2));

    }

    static IEnumerable<Tuple<int,int>> GetCombinations(List<int> list)
    {
        for(int i=0;i<list.Count;i++)
            for(int j=0;j<list.Count;j++)
                yield return Tuple.Create(list[i],list[j]);
    }
    • Vous ne savez probablement pas sur Énumérable.Range(). C'est vraiment pratique! Sur le code, même si vous exécutez à travers des 3 boucles (au lieu de 2) ici, dont 2 ne sont pas parallèles à tous. Cela dépend de ce que Foo() n' (Console.WriteLine dans votre réponse), mais cela va probablement être plus lente que ne pas ajouter de tout parallélisme et juste en boucle deux fois normalement.
    InformationsquelleAutor Panagiotis Kanavos