Définition du nombre de tâches de carte et réduction des tâches
Je travaille actuellement sur un travail. J'ai fixé le nombre de tâches de carte à 20, mais j'ai obtenu un nombre plus élevé. J'ai également mis la tâche de réduction à zéro mais je reçois toujours un nombre autre que zéro. La durée totale d'exécution du travail MapReduce ne s'affiche pas non plus. Quelqu'un peut-il me dire ce que je fais mal . J'utilise cette commande
hadoop jar Test_Parallel_for.jar Test_Parallel_for Matrix/test4.txt Result 3 \ -D mapred.map.tasks = 20 \ -D mapred.reduce.tasks =0
Sortie:
11/07/30 19:48:56 INFO mapred.JobClient: Job complete: job_201107291018_0164
11/07/30 19:48:56 INFO mapred.JobClient: Counters: 18
11/07/30 19:48:56 INFO mapred.JobClient: Job Counters
11/07/30 19:48:56 INFO mapred.JobClient: Launched reduce tasks=13
11/07/30 19:48:56 INFO mapred.JobClient: Rack-local map tasks=12
11/07/30 19:48:56 INFO mapred.JobClient: Launched map tasks=24
11/07/30 19:48:56 INFO mapred.JobClient: Data-local map tasks=12
11/07/30 19:48:56 INFO mapred.JobClient: FileSystemCounters
11/07/30 19:48:56 INFO mapred.JobClient: FILE_BYTES_READ=4020792636
11/07/30 19:48:56 INFO mapred.JobClient: HDFS_BYTES_READ=1556534680
11/07/30 19:48:56 INFO mapred.JobClient: FILE_BYTES_WRITTEN=6026699058
11/07/30 19:48:56 INFO mapred.JobClient: HDFS_BYTES_WRITTEN=1928893942
11/07/30 19:48:56 INFO mapred.JobClient: Map-Reduce Framework
11/07/30 19:48:56 INFO mapred.JobClient: Reduce input groups=40000000
11/07/30 19:48:56 INFO mapred.JobClient: Combine output records=0
11/07/30 19:48:56 INFO mapred.JobClient: Map input records=40000000
11/07/30 19:48:56 INFO mapred.JobClient: Reduce shuffle bytes=1974162269
11/07/30 19:48:56 INFO mapred.JobClient: Reduce output records=40000000
11/07/30 19:48:56 INFO mapred.JobClient: Spilled Records=120000000
11/07/30 19:48:56 INFO mapred.JobClient: Map output bytes=1928893942
11/07/30 19:48:56 INFO mapred.JobClient: Combine input records=0
11/07/30 19:48:56 INFO mapred.JobClient: Map output records=40000000
11/07/30 19:48:56 INFO mapred.JobClient: Reduce input records=40000000
[hcrc1425n30]s0907855:
Le nombre de tâches de mappage pour un travail donné dépend du nombre de divisions d’entrée et non du paramètre mapred.map.tasks. Pour chaque fractionnement d'entrée, une tâche de carte est générée. Ainsi, au cours de la durée de vie d’une tâche mapreduce, le nombre de tâches de mappage est égal au nombre de fractionnements d’entrée. mapred.map.tasks n'est qu'un indice pour le nombre de cartes dans le format InputFormat.
Dans votre exemple, Hadoop a déterminé qu'il y avait 24 divisions d'entrée et générerait 24 tâches de carte au total. Cependant, vous pouvez contrôler le nombre de tâches de carte pouvant être exécutées en parallèle par chacun des suivis de tâches.
En outre, la suppression d'un espace après -D peut résoudre le problème de réduction.
Pour plus d'informations sur le nombre de cartes et de tâches réduites, veuillez consulter l'URL ci-dessous.
Comme Praveen le mentionne ci-dessus, lorsque vous utilisez les classes de base FileInputFormat, vous indiquez uniquement le nombre de fractionnements d'entrée constituant les données. Le nombre de réducteurs est contrôlé par mapred.reduce.tasks spécifié de la façon dont vous l'avez: -D mapred.reduce.tasks=10 spécifierait 10 réducteurs. Notez que l'espace après -D est requis; Si vous omettez l'espace, la propriété de configuration est transmise à la machine virtuelle Java concernée, et non à Hadoop.
Etes-vous en train de spécifier 0 parce qu'il n'y a pas de travail de réduction à effectuer? Dans ce cas, si vous rencontrez des problèmes avec le paramètre d'exécution, vous pouvez également définir la valeur directement dans le code. Étant donné une instance JobConfjob, appelez
job.setNumReduceTasks(0);
à l'intérieur, disons, de votre implémentation de Tool.run. Cela devrait produire une sortie directement à partir des mappeurs. Si votre travail ne produit réellement aucune sortie (parce que vous utilisez la structure uniquement pour les effets secondaires tels que les appels réseau ou le traitement des images, ou si les résultats sont entièrement pris en compte dans les valeurs du compteur), vous pouvez également désactiver la sortie
job.setOutputFormat(NullOutputFormat.class);
Il est important de garder à l’esprit que le framework MapReduce de Hadoop ne nous permet que de
suggère le nombre de tâches de carte pour un travail
qui, comme Praveen l’a fait remarquer plus haut, correspondra au nombre de fractionnements d’entrée pour la tâche. Contrairement à son comportement pour le nombre de réducteurs (qui est directement lié au nombre de fichiers générés par le travail MapReduce), nous pouvons
demande qu'il fournisse n réducteurs.
Pour l'expliquer avec un exemple:
Supposons que votre taille de fichier d'entrée hadoop est de 2 Go et que vous définissez une taille de bloc de 64 Mo. Ainsi, 32 tâches de mappeur sont configurées pour s'exécuter pendant que chaque mappeur traite un bloc de 64 Mo pour terminer le travail de mappage de votre travail Hadoop.
==> Le nombre de mappeurs à exécuter dépend entièrement de 1) Taille du fichier et 2) Taille du bloc
Supposons que vous ayez exécuté hadoop sur une taille de cluster de 4: Supposons que vous définissiez les paramètres mapred.map.tasks et mapred.reduce.tasks dans votre fichier conf vers les nœuds comme suit:
Node 1: mapred.map.tasks = 4 and mapred.reduce.tasks = 4
Node 2: mapred.map.tasks = 2 and mapred.reduce.tasks = 2
Node 3: mapred.map.tasks = 4 and mapred.reduce.tasks = 4
Node 4: mapred.map.tasks = 1 and mapred.reduce.tasks = 1
Supposons que vous définissiez les paramètres ci-dessus pour 4 de vos nœuds de ce cluster. Si vous remarquez que le nœud 2 n'a défini que 2 et 2 respectivement parce que les ressources de traitement du nœud 2 pourraient être inférieures, par exemple (2 processeurs, 2 cœurs) et que le nœud 4 est même défini à un niveau inférieur, à 1 et 1 respectivement, en raison des ressources de traitement. sur ce nœud, il y a 1 processeur, 2 cœurs et ne peuvent donc exécuter plus de 1 tâche de mappeur et 1 tâche de réduction.
Ainsi, lorsque vous exécutez le travail Noeud 1, Noeud 2, Noeud 3, Noeud 4, vous êtes configuré pour exécuter un nombre max. total de (4 + 2 + 4 + 1) 11 tâches de mappeur simultanément sur les 42 tâches de mappeur devant être effectuées par le travail. Une fois que chaque nœud a terminé ses tâches de mappage, il prend les tâches de mappeur restantes dans 42 tâches de mappeur.
En ce qui concerne les réducteurs, lorsque vous définissez mapred.reduce.tasks = 0, nous n'obtenons que la sortie du mappeur dans 42 fichiers (1 fichier pour chaque tâche du mappeur) et aucune sortie du réducteur.
Dans la nouvelle version de Hadoop, il existe des codes mapreduce.job.running.map.limit et mapreduce.job.running.reduce.limit beaucoup plus précis qui vous permettent de définir le nombre de mappeurs et de réducteurs indépendamment de la taille de division du fichier hdfs. Ceci est utile si vous êtes contraint de ne pas utiliser de grandes ressources du cluster.
D'après votre journal, j'ai compris que vous avez 12 fichiers d'entrée, car 12 cartes locales sont générées. Les cartes Rack Local sont créées pour le même fichier si certains blocs de ce fichier se trouvent dans un autre nœud de données. Combien de nœuds de données avez-vous?
Le nombre de tâches de la carte est directement défini par le nombre de morceaux de votre entrée est divisée. La taille du bloc de données (c'est-à-dire la taille de bloc HDFS) est contrôlable et peut être définie pour un fichier individuel, un ensemble de fichiers, un répertoire (-s). Il est donc possible de définir un nombre spécifique de tâches de mappage dans une tâche, mais implique de définir une taille de bloc HDFS correspondante pour les données d'entrée de la tâche. mapred.map.tasks peut être utilisé pour cela aussi, mais seulement si sa valeur fournie est supérieure au nombre de divisions pour les données d'entrée du travail.
Contrôler le nombre de réducteurs via mapred.reduce.tasks est correct. Cependant, le mettre à zéro est un cas assez particulier: la sortie du travail est une concaténation des sorties des mappeurs (non triés). Dans la réponse de Matt, on peut voir plus de façons de définir le nombre de réducteurs.
Dans votre exemple, les pièces -D ne sont pas récupérées:
hadoop jar Test_Parallel_for.jar Test_Parallel_for Matrix/test4.txt Result 3 \ -D mapred.map.tasks = 20 \ -D mapred.reduce.tasks =0
Ils devraient venir après la partie classname comme ceci:
hadoop jar Test_Parallel_for.jar Test_Parallel_for -Dmapred.map.tasks=20 -Dmapred.reduce.tasks=0 Matrix/test4.txt Result 3
Un espace après -D est cependant autorisé.
Notez également que modifier le nombre de mappeurs est probablement une mauvaise idée, comme d'autres personnes l'ont mentionné ici.
La première partie a déjà été répondue, "juste une suggestion" La deuxième partie a également été répondue, "supprimer les espaces supplémentaires autour de =" Si ces deux ne fonctionnent pas, êtes-vous sûr que vous avez mis en œuvre ToolRunner ?
Le nombre de tâches de carte dépend de la taille du fichier. Si vous voulez un nombre n de cartes, divisez la taille du fichier par n comme suit:
conf.set("mapred.max.split.size", "41943040"); // maximum split file size in bytes
conf.set("mapred.min.split.size", "20971520"); // minimum split file size in bytes
Je conviens que la tâche de mappage des nombres dépend de la séparation des entrées, mais dans certains des scénarios, je pouvais voir sa différence
case-1 J'ai créé une tâche de mapp simple, mais elle crée 2 fichiers de sortie dupliqués (données identiques) commande que j'ai donné ci-dessous
bin/hadoop jar contrib/streaming/hadoop-streaming-1.2.1.jar -D mapred.reduce.tasks = 0 -input /home/sample.csv -output /home/sample_csv112.txt -mapper/home/amitav/workpython /readcsv.py
Case-2 J'ai donc assigné la tâche de mapp à 1, la sortie est arrivée correctement avec un fichier de sortie, mais un réducteur a également mangé dans l'écran de l'interface utilisateur, bien que j'aie restreint le travail de réducteur. La commande est donnée ci-dessous.
bin/hadoop jar contrib/streaming/hadoop-streaming-1.2.1.jar -D mapred.map.tasks = 1 mapred.reduce.tasks = 0 -input /home/sample.csv -output /home/sample_csv115.txt - mappeur /home/amitav/workpython/readcsv.py
Une des façons d’augmenter le nombre de mappeurs est de donner votre entrée sous la forme de fichiers divisés [vous pouvez utiliser la commande linux split]. La diffusion en continu Hadoop affecte généralement autant de mappeurs qu’il existe des fichiers d’entrée [s’il existe un grand nombre de fichiers], sinon, il essaiera de scinder l’entrée en parties de taille égale.
Utilisez -D propriété = valeur plutôt que -D propriété = valeur (éliminez Espaces blancs supplémentaires). Ainsi, -D mapred.reduce.tasks = value fonctionnerait correctement.
La définition du nombre de tâches de carte ne reflète pas toujours la valeur que vous avez définie, car elle dépend de la taille de la division et du format utilisé.
La définition du nombre de réductions remplacera définitivement le nombre de Défini dans la configuration en cluster/côté client.