Quand les tâches de réduction commencent-elles dans Hadoop?

Dans Hadoop, quand les tâches de réduction commencent-elles? Est-ce qu’ils commencent après qu’un certain pourcentage (seuil) de mappeurs se soit terminé? Si oui, ce seuil est-il fixé? Quel type de seuil est généralement utilisé?

La phase de réduction comporte 3 étapes: mélange, sorting, réduction. Shuffle est l’endroit où les données sont collectées par le réducteur de chaque mappeur. Cela peut arriver lorsque les mappeurs génèrent des données, car il ne s’agit que d’un transfert de données. Par contre, le sorting et la réduction ne peuvent commencer que lorsque tous les mappeurs sont terminés. Vous pouvez dire quel MapReduce est en train de faire en examinant le pourcentage d’achèvement du réducteur: 0-33% signifie qu’il est mélangé, 34-66% est sortingé, 67% -100% est réduit. C’est pourquoi vos réducteurs semblent parfois “bloqués” à 33% – ils attendent la fin des mappeurs.

Les réducteurs commencent à mélanger en fonction du seuil de pourcentage de mappeurs terminés. Vous pouvez modifier le paramètre pour que les réducteurs démarrent tôt ou tard.

Pourquoi commencer les réducteurs tôt est-il une bonne chose? Parce qu’il répartit le transfert de données des mappeurs vers les réducteurs au fil du temps, ce qui est une bonne chose si votre réseau est le goulot d’étranglement.

Pourquoi le démarrage des réducteurs est-il une mauvaise chose? Parce qu’ils “se bloquent”, réduisez les créneaux tout en ne copiant que les données et en attendant que les mappeurs se terminent. Un autre travail qui démarre plus tard et qui utilisera les emplacements de réduction ne peut plus les utiliser.

Vous pouvez personnaliser le démarrage des réducteurs en modifiant la valeur par défaut de mapred.reduce.slowstart.completed.maps dans mapred-site.xml . Une valeur de 1.00 attendra que tous les mappeurs se terminent avant de démarrer les réducteurs. Une valeur de 0.0 lancera les réducteurs immédiatement. Une valeur de 0.5 démarrera les réducteurs lorsque la moitié des mappeurs sont terminés. Vous pouvez également modifier mapred.reduce.slowstart.completed.maps en fonction du travail. Dans les nouvelles versions de Hadoop (au moins 2.4.1), le paramètre est appelé mapreduce.job.reduce.slowstart.completedmaps (merci à l’utilisateur yegor256).

En règle générale, j’aime garder mapred.reduce.slowstart.completed.maps au-dessus de 0.9 si le système a plusieurs jobs exécutés mapred.reduce.slowstart.completed.maps . De cette façon, le travail ne ralentit pas les réducteurs quand ils ne font rien d’autre que de copier des données. Si vous n’avez qu’un seul travail à la fois, faire 0.1 serait probablement approprié.

La phase de réduction peut commencer longtemps avant l’appel d’un réducteur. Dès que “a” le mappeur termine le travail, les données générées subissent un sorting et un armsage (qui incluent l’appel au combineur et au partitionneur). La “phase” du réducteur intervient au moment où le traitement des données post-mappeur est démarré. Au fur et à mesure que ce traitement est terminé, vous verrez des progrès dans le pourcentage des réducteurs. Cependant, aucun des réducteurs n’a encore été appelé. En fonction du nombre de processeurs disponibles / utilisés, de la nature des données et du nombre de réducteurs attendus, vous pouvez modifier le paramètre comme décrit par @ Donald-miner ci-dessus.

Autant que je sache, réduire la phase commencer par la phase de carte et continuer à consumr le dossier des cartes. Cependant, comme il y a une phase de sorting et de lecture aléatoire après la phase de la carte, toutes les sorties doivent être sortingées et envoyées au réducteur. Donc, logiquement, vous pouvez imaginer que la réduction de phase ne commence qu’après la phase de la carte, mais en réalité, pour des raisons de performances, les réducteurs sont également initialisés avec les mappeurs.

Le pourcentage indiqué pour la phase de réduction correspond en fait à la quantité de données copiées depuis la sortie des cartes vers les répertoires d’entrée des réducteurs. Pour savoir quand cette copie commence? C’est une configuration que vous pouvez définir comme Donald l’a montré ci-dessus. Une fois que toutes les données sont copiées dans les réducteurs (c.-à-d. 100% de réduction), les réducteurs commencent à fonctionner et peuvent donc “réduire à 100%” si le code de vos réducteurs est gourmand en E / S ou en CPU.

Considérons un exemple WordCount afin de mieux comprendre comment la carte réduit la tâche. Supposons que nous ayons un fichier volumineux, disons un roman, et que notre tâche consiste à trouver le nombre de fois que chaque mot apparaît dans le fichier. Comme le fichier est volumineux, il peut être divisé en différents blocs et répliqué dans différents noeuds de travail. Le travail de comptage de mots est composé de cartes et de tâches réduites. La tâche de carte prend en entrée chaque bloc et produit une paire clé-valeur intermédiaire. Dans cet exemple, comme nous comptons le nombre d’occurrences de mots, le mappeur lors du traitement d’un bloc produirait des résultats intermédiaires de la forme (word1, count1), (word2, count2), etc. Les résultats intermédiaires de tous les mappeurs sont: passé par une phase de mélange qui réorganisera le résultat intermédiaire.

Supposons que la sortie de notre carte à partir de différents mappeurs se présente sous la forme suivante:

Carte 1: – (est, 24) (était, 32) (et 12)

Map2: – (mon, 12) (est, 23) (était, 30)

Les sorties de la carte sont sortingées de manière à ce que les mêmes valeurs de clé soient données au même réducteur. Ici, cela signifierait que les touches correspondant à est, est-ce que etc va le même réducteur. C’est le réducteur qui produit le résultat final, qui dans ce cas serait: – (et, 12) (est, 47) (mon, 12 ) (était, 62)

Réduire ne démarre qu’une fois que le mappeur a effectué la tâche, Reducer doit communiquer avec tous les mappeurs pour attendre que le dernier mappeur ait terminé sa tâche. Cependant, le mappeur commence à transférer les données au moment où il a terminé sa tâche.

Lorsque Mapper a terminé sa tâche, Reducer commence alors à réduire les données. Il s’agit du travail Mapreduce.

Les tâches de réduction ne commencent qu’après l’ completion de tous les mappeurs.

Mais le transfert de données se produit après each carte. En fait, c’est une opération de traction.

Cela signifie que chaque réducteur demandera à chaque maptask s’il dispose de données à récupérer depuis Map. S’ils trouvent qu’un mappeur a terminé sa tâche, Reducer récupère les données intermédiaires.

Les données intermédiaires de Mapper sont stockées sur le disk . Et le transfert de données de Mapper vers Reduce se fait via le réseau ( Data Locality n’est pas conservée dans la phase Réduire)