scala collections parallèles degré de parallélisme

Question

Existe-t-il un équivalent en scala des collections parallèles à LINQ ? withDegreeOfParallelism qui définit le nombre de threads qui exécuteront une requête ? Je veux exécuter une opération en parallèle qui nécessite un nombre déterminé de fils d'exécution.

Answer 1

Avec le tronc le plus récent, en utilisant la JVM 1.6 ou plus récente, utilisez l'option :

collection.parallel.ForkJoinTasks.defaultForkJoinPool.setParallelism(parlevel: Int)

Cela peut toutefois faire l'objet de modifications à l'avenir. Une approche plus unifiée de la configuration de toutes les API parallèles de Scala est prévue pour les prochaines versions.

Notez cependant que si cela détermine le nombre de processeurs utilisés par la requête, ce n'est pas forcément le nombre réel de threads impliqués dans l'exécution d'une requête. Étant donné que les collections parallèles prennent en charge le parallélisme imbriqué, l'implémentation réelle du pool de threads peut allouer plus de threads pour exécuter la requête si elle détecte que cela est nécessaire.

EDIT :

À partir de Scala 2.10, la manière préférée de définir le niveau de parallélisme est de définir l'attribut tasksupport à un nouveau champ TaskSupport comme dans l'exemple suivant :

scala> import scala.collection.parallel._
import scala.collection.parallel._

scala> val pc = mutable.ParArray(1, 2, 3)
pc: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3)

scala> pc.tasksupport = new ForkJoinTaskSupport(new scala.concurrent.forkjoin.ForkJoinPool(2))
pc.tasksupport: scala.collection.parallel.TaskSupport = scala.collection.parallel.ForkJoinTaskSupport@4a5d484a

scala> pc map { _ + 1 }
res0: scala.collection.parallel.mutable.ParArray[Int] = ParArray(2, 3, 4)

Pendant l'instanciation de la ForkJoinTaskSupport avec un fork join pool, le niveau de parallélisme du fork join pool doit être défini à la valeur souhaitée ( 2 dans l'exemple).

Answer 2

Indépendamment de la version de la JVM, avec Scala 2.9+ (qui a introduit les collections parallèles), vous pouvez également utiliser une combinaison de la fonction grouped(Int) y par pour exécuter des tâches parallèles sur de petits morceaux, comme ceci :

scala> val c = 1 to 5
c: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)

scala> c.grouped(2).seq.flatMap(_.par.map(_ * 2)).toList
res11: List[Int] = List(2, 4, 6, 8, 10)

grouped(2) crée des morceaux de longueur égale ou inférieure à 2, seq s'assure que la collection de chunks n'est pas parallèle (inutile dans cet exemple), puis la fonction _ * 2 est exécutée sur les petits morceaux parallèles (créés avec la fonction par ), assurant ainsi qu'au plus 2 threads sont exécutés en parallèle.

Il se peut toutefois que cette méthode soit légèrement moins efficace que le paramétrage du pool de travailleurs, mais je n'en suis pas sûr.