Retour sur la 9ème soirée du PSUG

Il y avait du monde dans les locaux de Xebia en cette dernière soirée de janvier 2011. Comme nous vous l’avions annoncé, le Paris Scala User Group accueillait le créateur de Scala, Martin Ordersky, pour une soirée consacrée aux collections parallèles et au futur de Scala.

Martin a commencé sa présentation par les enjeux de la programmation parallèle, et plus particulièrement le Popular Parallel Programming qui est actuellement un sujet de grande importance. En effet, les multiples cœurs de nos processeurs et la puissance fournie par les GPGPU ne demandent qu’à être exploités. Mais les difficultés inhérentes à la programmation concurrente rendent cette tâche complexe et favorable à l’apparition de bugs difficiles à identifier et à corriger.

Il n’en reste pas moins que le nombre de cœurs doublent régulièrement dans nos CPU, et que des architectures telles que Fermi de NVIDIA réclament un gros paquet de threads pour alimenter les quelques 512 cœurs CUDA du processeur. La course aux GHz étant maintenant terminée au profit de l’augmentation du nombre de cœurs, si nous souhaitons disposer de plus de puissance de calcul, le parallélisme est actuellement la voie à emprunter.

Le but du Popular Parallel Programming est de rendre transparent pour le développeur l’utilisation parallèle des processeurs multi-cœurs. En implémentant le parallélisme au cœur du langage, son utilisation se fait à moindre coût.

En programmation parallèle, les problèmes commencent à survenir lorsque que l’on se retrouve dans des conditions de course (race-condition) et que des états sont partagés entre plusieurs unités d’exécution :

parallel programming + shared state => unpredictable state

La solution la plus efficace pour remédier à ce problème est de ne pas partager d’état et de travailler avec des objets immuables. Comme tout langage fonctionnel, Scala encourage l’utilisation d’objets immuables. Combiné avec la richesse de l’API Collections et Acteurs, cela fait de Scala (Scalable Language) un langage parfaitement taillé pour exploiter toute la puissance de nos processeurs. Le laboratoire Programming Methods Laboratory de l’EPFL, à l’origine de Scala, a d’ailleurs obtenu un financement sur cinq ans de l’union Européenne afin de soutenir le développement de Scala et notamment son utilisation dans la programmation parallèle.

Après la présentation des enjeux de la programmation parallèle et de la réponse apportée par Scala, Martin est revenu sur le travail effectué sur l’API Collections de Scala et qui a mené à une version 2.8. Ce refactoring a grandement facilité l’apparition des Parallel Collections sur lesquelles nous reviendrons plus tard.
Le but de ce chantier était de rendre l’API Collection plus homogène et de simplifier le code en supprimant un grand nombre de duplications. De nouvelles méthodes ont donc fait leur apparition sur les collections comme partition() :

	val (minors, adults) = people partition (_.age < 18)

Outre l’ajout de nouvelles méthodes, celles-ci assurent une cohérence du type d’arrivée avec le type de départ :

scala> List(1,2,3) map (_ * 2)
res0: List[Int] = List(2, 4, 6)

scala> Array(1,2,3) map (_ * 2)
res3: Array[Int] = Array(2, 4, 6)

Martin nous a ensuite présenté le travail effectué sur les Parallel collections qui sera intégrée dans la version 2.9, dont la première Release Candidate est prévue courant Mars. Cette fonctionnalité permet l’exploitation des multiples cœurs de nos processeurs pour effectuer certaines opérations sur des collections. La plupart des opérations sur les collections comme les fonctions map(), reduce(), filter() … obtiendront un gain sensible de performance sur des architectures parallèles (Martin évoque un facteur 2,5x pour 4 cœurs et 4,5x sur 8 cœurs). La bonne nouvelle pour les développeurs est que ceci vient quasiment gratuitement. Il suffit en effet d’utiliser le bon type de collection ou d’utiliser la méthode par() retournant la collection parallèle équivalente pour en profiter. On aime !!!
Les Parallel Collections devraient donc nous permettre d’exploiter un peu mieux la puissance de nos processeurs sans entrer dans le casse-tête favorable aux erreurs qu’est la programmation parallèle.

Voici un exemple dans lequel on pourrait trouver un intérêt à utiliser les Parallel Collections. Nous allons chercher à compter le nombre de personnes par tranche d’âge. On commence par générer aléatoirement une liste d’années de naissance :

scala> val birthYears = for ( x <- 1 to 100000 ) yield 2011 - (Math.random * 77).round
birthYears: scala.collection.immutable.IndexedSeq[Long] = Vector(1951, 1991, ...)

Nous utilisons ensuite l’API Collections afin de regrouper les personnes (ce code est non optimisé afin d’améliorer sa lisibilité) :

scala> birthYears map (2011 - _) groupBy {
       case i if(i < 10) => "child"
       case i if (i < 20) => "teenager"
       case i if(i < 60) => "adult"
       case _ => "senior"} map { case (category, ages) => (category, ages.size) }
res0: scala.collection.immutable.Map[java.lang.String,Int] = Map((child,12452), (senior,22917), (adult,51827), (teenager,12804))

Le traitement ici est assez simple. Il s’agit d’obtenir la répartition d’une population en fonction de son âge en quatre catégories : « child », « teenager », « adult » et « senior ». On peut imaginer que le traitement soit plus complexe et que l’on travaille sur un plus gros jeu de données. L’utilisation des Parallel Collections nous permettra un gain de performance sur une machine équipée de plusieurs cœurs :

scala> birthYears.par map (2011 - _) groupBy {
       case i if(i < 10) => "child"
       case i if (i < 20) => "teenager"
       case i if(i < 60) => "adult"
       case _ => "senior"} map { case (category, ages) => (category, ages.size) }
res1: ...

La méthode par sur birthYears retourne une version « parallèle » de la collection d’origine ce qui permet l’utilisation de l’implémentation parallèle des fonctions map et groupBy.

La soirée s’est ensuite poursuivie par une petite séance de questions réponses. Martin nous a indiqué souhaiter une plus grande régularité dans la livraison des nouvelles versions de Scala et nous a aussi rassuré quand à la pérennité du langage dans l’avenir. Comme indiqué plus haut, le projet a en effet obtenu un financement de la part de l’union européenne et il est aussi soutenu par la société Scala Solutions dont Martin est co-fondateur.
D’autres sujets ont été évoqués comme le changement de licence de Scala au profit d’un licence plus libre comme Apache par exemple. Sur ce point Martin est plutôt ouvert mais ce genre de démarche est généralement chronophage et ne figure actuellement pas dans le haut des priorités.

Un grand merci à Martin Odersky pour le temps qu’il a bien voulu nous accorder, pour la qualité de sa présentation et bien entendu, pour le langage Scala !
Si Scala vous intéresse, Xebia Training organise deux autres sessions de formation cette année, l’une aura lieu fin mars et l’autre en décembre.