CHAPITRE IV : MAPREDUCE

I. Généralités
En 2004, Google a développé un paradigme appelé MapReduce, et en 2005, Yahoo! a
mis en place Hadoop comme implémentation de MapReduce et a fini par le lancer en
tant que projet open source en 2007.
À l’instar des autres systèmes opérationnels, Hadoop possède les structures de base
nécessaires à effectuer des calculs: un système de fichiers, un langage de
programmation, une méthode pour distribuer les programmes ainsi générés à un cluster,
un mode pour obtenir les résultats et arriver à une consolidation unique de ces derniers, ce
qui est le but.
II. Exemple introductif
Supposons qu’une entreprise possède plusieurs magasins qu’elle gère à travers le
monde. Pour cela, elle a un très grand livre de comptes qui contient TOUTES les ventes.

Objectif : Calculer le total des ventes par magasin pour l’année en cours
Supposons que les lignes du livre aient la forme suivante: Jour Ville produit Prix

Possibilité́ :

• Pour chaque entrée, saisir la ville et le prix de vente

• Si on trouve une entrée avec une ville déjà saisie, on les regroupe en faisant la somme des
vente
Dans un environnement traditionnel, on fera des Hash table sous la forme <clé-valeur>
• Dans ce cas, la clé sera l’adresse du magasin et la valeur le total de ventes
Bien qu’il est fort possible de rencontrer des problèmes de taille mémoire, et que le traitement
séquentiel s’avère long en plus du problème classique de l’ajout de nouveaux magasins, le
résultat peut s’avérer correct.

Le Map-Reduce est un moyen plus efficace et plus rapide de traiter ces données, le principe
consiste en :
• Au lieu d’avoir une seule personne qui parcourt le livre, on recruterait plusieurs.
• Appeler un premier groupe les Mappers et un autre les Reducers
• Diviser le livre en plusieurs parties, et en donner une à chaque Mapper
Les Mappers peuvent travailler en même temps, chacun sur une partie des données :
Mappers
• Pour chaque entrée, saisir la ville et le total de ventes dans une fiche
• Rassembler les fiches d’un même magasin dans une pile
III- Le modèle de programmation MapReduce

Dans le modèle de programmation MapReduce, le développeur implémente 2 fonctions : la

fonction Map et la fonction Reduce
Fonction Map : prend en entrée un ensemble de « Clé, Valeurs » et retourne une liste intermédiaire
de «Clé1, Valeur1» :
Map(key,value) -> list(key1,value1)
Fonction Reduce : prend en entrée une liste intermédiaire de « Clé1, Valeur1 » et fournit en
sortie une ensemble de « Clé1, Valeur2 » :
 Reduce(key1,list(value1)) -> value2

L’algorithme MapReduce s’exécute en 5 phases :

1. La phase Initialisation
2. La phase Map
3. La phase regroupement (Shuffle)
4. La phase de Tri
5. La phase Reduce
IV. Fonctionnement de MapReduce

Lorsque l’application MapReduce est lancée, elle crée un composant « Master » responsable de
la distribution des données et de la coordination de l’exécution de différentes unités de travail ou
« Workers ». Le Master attribue aux Workers les tâches Map et Reduce
Un Worker possède 3 états:
• idle : il est disponible pour un nouveau traitement
• in-progress : un traitement est en cours d’exécution
• completed : il a fini un traitement, il en informe alors le Master de la taille, de la
localisation de ses fichiers intermédiaires
Le Master gère la synchronisation, la réorganisation, le tri et le regroupement des données
lorsqu’un Worker de type Map a fini son traitement, le Master regroupe, trie et renvoie le résultat
à un Worker de type Reduce.

V. Exemples illustratifs

1. Le comptage de mots
Imaginons qu'on nous donne un texte écrit en langue Française. On souhaite déterminer
pour un travail de recherche quels sont les mots les plus utilisés au sein de ce texte. Les données
d'entrée sont constituées du contenu du texte.
Première étape: déterminer une manière de découper (split) les données d'entrée pour que
chacune des machines puisse travailler sur une partie du texte. On décide de découper les
données d'entrée ligne par ligne. Chacune des lignes du texte sera un fragment de nos
données d'entrée.

Celui qui croyait au ciel

Celui qui n’y croyait pas
Fou qui fait le délicat
Fou qui songe à ses querelles

Il est de coutume de simplifier le travail en enlevant la ponctuation et les caractères accentués

ainsi que les majuscules. On obtient les quatre fragments suivants :

celui qui croyait au ciel

celui qui ny croyait pas
fou qui fait le délicat
fou qui songe a ses querelles

D’abord, on détermine la clé à utiliser pour l’opération MAP, et écrire son code. Comme on
s'intéresse aux occurrences des mots dans le texte, la clef qu’on choisit est le mot.
L’opération MAP consiste à parcourir le fragment considéré et, pour chacun des mots, émettre le
couple clef/valeur: (MOT ; 1). Cela signifie que nous avons rencontré une fois le mot. Le pseudo
code de la fonction Map peut être :

Pour chaque mot de la ligne

emettre (mot ; 1)

Pour nos fragments, les couples (clé,valeur) ainsi générés sont :

celui qui croyait au ciel (celui ;1) (qui ;1) (croyait ;1) (au ;1) (ciel ;1)
celui qui ny croyait pas (celui ;1) (qui ;1) (ny ;1) (croyait ;1) (pas ;1)
fou qui fait le délicat (fou ;1) (qui ;1) (fait ;1) (le ;1) (délicat ;1)
fou qui songe a ses querelles (fou ;1) (qui ;1) (songe ;1) (a ;1) (ses ;1) (querelles ;1)

Une fois l’opération « Map » achevée, un mécanisme intermédiaire permet de regrouper les
couples par clé commune ; on obtient :
(celui ;1) (celui ;1)
(qui ;1) (qui ;1) (qui ;1) (qui ;1)
(croyait ;1) (croyait ;1)
(fou ;1) (fou ;1)
(au ;1)
(ciel ;1)
etc.
La fonction « Reduce » considère chacun des groupements de clés où elle va opérer à une somme.
Le pseudo code peut être :
Total=0
Pour chaque Couple dans Groupe
Total=Total+1
emettre(mot ; total)
A la fin de l’opération, on obtient pour chaque mot son nombre d’apparition dans le texte.
(celui ;2)
(qui ;4)
(croyait ;2)
(au ;1)
(ciel ;1)
etc.

Fig. 2. Flux de données MapReduce avec 1 seule tâche Reduce

2. Longueur moyenne des mots

On s’intéresse maintenant à calculer la longueur moyenne des mots dans un texte. On procède
alors au découpage comme précédemment au texte d’entrée en lignes. Pour chaque ligne, on
calcule le nombre de mots et la longueur de la ligne (ie le nombre de caractères). La longueur
moyenne se fait selon la formule :
L'entrée de Map est un ensemble de mots {w} d'un fragment du texte, la fonction « Map » calcule
le nombre de mots dans le fragment et la longueur totale des mots. La sortie de la fonction
« Map » contient deux couples : <“count”, #mots> et <“length”, longueur totale>.
L'entrée de Reduce est un ensemble {<clé, {valeur}>}, où clé = “count” ou “length” et valeur est
un entier. La fonction « Reduce » calcule le nombre total de mots : N = somme de toutes les
valeurs “count” et la longueur totale des mots : L = somme de toutes les valeurs “length”
La sortie « Reduce » est <“count”, N> et <“length”, L>, Le résultat est obtenu en faisant la
division μ=L/N.

Fig.3. Flux de données MapReduce avec 2 tâches Reduce

V-Mise en œuvre de MapReduce sous Hadoop

1. Architecture MapReduce de Hadoop

Comme pour HDFS, la gestion des tâches de Hadoop se base sur deux serveurs (des
daemons):
• Le JobTracker, qui va directement recevoir la tâche à exécuter (un .jar Java), ainsi
que les données d'entrées (nom des fichiers stockés sur HDFS) et le répertoire où stocker
les données de sortie (toujours sur HDFS). Il y a un seul JobTracker sur une seule
machine du cluster Hadoop. Le JobTracker est en communication avec le
NameNode de HDFS et sait donc où sont les données.
• Le TaskTracker, qui est en communication constante avec le JobTracker et va recevoir les
opérations simples à effectuer (MAP/REDUCE) ainsi que les blocs de données
correspondants (stockés sur HDFS). Il y a un TaskTracker sur chaque machine du
cluster.
Comme le JobTracker est conscient de la position des données (grâce au
NameNode), il peut facilement déterminer les meilleures machines auxquelles attribuer
les sous-tâches (celles où les blocs de données correspondants sont stockés).
Pour effectuer un traitement Hadoop, on va donc stocker nos données
d'entrée sur HDFS, créer un répertoire où Hadoop stockera les résultats
sur HDFS, et compiler nos programmes MAP et REDUCE au sein d'un
.jar Java.

Fig 1. Architecture logicielle MapReduce de Hadoop

On soumettra alors le nom des fichiers d'entrée, le nom du répertoire des résultats, et le .jar lui-
même au JobTracker: il s'occupera du reste (et notamment de transmettre les programmes
MAP et REDUCE aux serveurs TaskTracker des machines du cluster).
L'entrée de MapReduce doit être fait à partir de fichiers dans HDFS où Chaque bloc contient une
liste de pairs clé-valeur.

1) Le JobTracker
Le déroulement de l'exécution d'une tâche Hadoop suit les étapes suivantes du point de vue
du JobTracker :
1. Le client (un outil Hadoop console) va soumettre le travail à effectuer au JobTracker : une
archive java .jar implémentant les opérations Map et Reduce. Il va également
soumettre le nom des fichiers d'entrée et l'endroit où stocker les résultats.
2. Le JobTracker communique avec le NameNode HDFS pour savoir où se trouvent les
blocs correspondant aux noms de fichiers donnés par le client.
3. Le JobTracker, à partir de ces informations, détermine quels sont les nœuds
TaskTracker les plus appropriés, c'est à dire ceux qui contiennent les données sur
lesquelles travailler sur la même machine, ou le plus proche possible (même rack/rack
proche).
4. Pour chaque « morceau » des données d'entrée, le JobTracker envoie au TaskTracker
sélectionné le travail à effectuer (MAP/REDUCE, code Java) et les blocs de données
correspondants.
 5. Le JobTracker communique avec les noeuds TaskTracker en train d'exécuter les
tâches. Ils envoient régulièrement un « heartbeat », un message signalant qu'ils
travaillent toujours sur la sous-tâche reçue. Si aucun heartbeat n'est reçu dans une
période donnée, le JobTracker considère la tâche comme ayant échouée et donne le
même travail à effectuer à un autre TaskTracker.
6. Si par hasard une tâche échoue (erreur java, données incorrectes, etc.), le TaskTracker va
signaler au JobTracker que la tâche n'a pas pu être exécutée.
7. Le JobTracker va alors décider de la conduite à adopter :
• Demander au même TaskTracker de ré-essayer.
• Redonner la sous-tâche à un autre TaskTracker.
• Marquer les données concernées comme invalides, etc.
• Il pourra même blacklister le TaskTracker concerné comme non-fiable dans certains
cas.
8. Une fois que toutes les opérations envoyées aux TaskTracker (MAP + REDUCE) ont été
effectuées et confirmées comme effectuées par tous les noeuds, le JobTracker
marque la tâche comme « effectuée ». Des informations détaillées sont disponibles
(statistiques, TaskTracker ayant posé problème, etc.).

Remarques:
Par ailleurs, on peut également obtenir à tout moment de la part du JobTracker des informations
sur les tâches en train d'être effectuées: étape actuelle (MAP, SHUFFLE, REDUCE), pourcentage
de complétion, etc.
2. Le TaskTracker
Le TaskTracker dispose d'un nombre de « slots » d'exécution. A chaque « slot »
correspond une tâche exécutable (configurable). Ainsi, une machine ayant par
exemple un
processeur à 8 cœurs pourrait avoir 16 slots d'opérations configurées.
Lorsqu'il reçoit une nouvelle tâche à effectuer (MAP, REDUCE, SHUFFLE) depuis
le JobTracker, le TaskTracker va démarrer une nouvelle instance de Java avec le
fichier .jar fourni par le JobTracker, en appelant l'opération correspondante.
Une fois la tâche démarrée, il enverra régulièrement au JobTracker ses messages
heartbeats. En dehors d'informer le JobTracker qu'il est toujours fonctionnels, ces
messages
indiquent également le nombre de slots disponibles sur le TaskTracker concerné.
Lorsqu'une sous-tâche est terminée, le TaskTracker envoie un message au
JobTracker pour l'en informer, que la tâche se soit bien déroulée ou non (il indique
évidemment le résultat au JobTracker)
Un modèle de programmation

MapReduce est un modèle de programmation popularisé par Google. Il est principalement utilisé
pour la manipulation et le traitement d’un nombre important de données au sein d’un cluster de
nœuds.

MapReduce consiste en deux fonctions map() et reduce().

• Dans l'étape Map, le nœud analyse un problème, le découpe en sous-problèmes, et le délègue

à d'autres nœuds (qui peuvent en faire de même récursivement). Les sous-problèmes sont
ensuite traités par les différents nœuds à l'aide de la fonction Map qui à un couple (clé,
valeur) associe un ensemble de nouveaux couples (clé, valeur) : map(clé1,valeur1) →
list(clé2,valeur2)
• // En pseudo code cela donnerait
• Map(void * document) {
• int cles = 1;
• foreach mot in document
• calculIntermediaire(mot, cles);
• }
• Vient ensuite l'étape Reduce, où les nœuds les plus bas font remonter leurs résultats au nœud
parent qui les avait sollicités. Celui-ci calcule un résultat partiel à l'aide de la fonction Reduce
(réduction) qui associe toutes les valeurs correspondantes à la même clé à une unique paire
(clé, valeur). Puis il remonte l'information à son tour.
À la fin du processus, le nœud d'origine peut recomposer une réponse au problème qui lui
avait été soumis : reduce(key2,list(valeur2))→ valeur22
• // En pseudo code cela donnerait
• Reduce(int cles, Iterator values) {
• int result = 0;
• foreach v in values
• result += v;
• }

Un cluster MapReduce utilise une architecture de type Maître-esclave où un nœud maître dirige tous
les nœuds esclaves.

MapReduce possède quelques caractéristiques3 :

• Le modèle de programmation du MapReduce est simple mais très expressif. Bien qu’il ne
possède que deux fonctions, map() et reduce(), elles peuvent être utilisées pour de nombreux
types de traitement des données, les fouilles de données, les graphes… Il est indépendant du
système de stockage et peut manipuler de nombreux types de variable.
• Le système découpe automatiquement les données en entrée en bloc de données de même
taille. Puis, il planifie l’exécution des tâches sur les nœuds disponibles.
• Il fournit une tolérance aux fautes à grain fin grâce à laquelle il peut redémarrer les nœuds
ayant rencontré une erreur ou affecter la tâche à un autre nœud.
• La parallélisation est invisible à l'utilisateur afin de lui permettre de se concentrer sur le
traitement des données4