Package org.apache.hadoop.mapred

A software framework for easily writing applications which process vast amounts of data (multi-terabyte data-sets) parallelly on large clusters (thousands of nodes) built of commodity hardware in a reliable, fault-tolerant manner.

See:
Description

Interface Summary

InputFormat<K,V>	InputFormat describes the input-specification for a Map-Reduce job.
InputSplit	InputSplit represents the data to be processed by an individual Mapper.
JobConfigurable	That what may be configured.
JobHistory.Listener	Callback interface for reading back log events from JobHistory.
Mapper<K1,V1,K2,V2>	Maps input key/value pairs to a set of intermediate key/value pairs.
MapRunnable<K1,V1,K2,V2>	Expert: Generic interface for Mappers.
OutputCollector<K,V>	Collects the <key, value> pairs output by Mappers and Reducers.
OutputFormat<K,V>	OutputFormat describes the output-specification for a Map-Reduce job.
Partitioner<K2,V2>	Partitions the key space.
RecordReader<K,V>	RecordReader reads <key, value> pairs from an InputSplit.
RecordWriter<K,V>	RecordWriter writes the output <key, value> pairs to an output file.
Reducer<K2,V2,K3,V3>	Reduces a set of intermediate values which share a key to a smaller set of values.
Reporter	A facility for Map-Reduce applications to report progress and update counters, status information etc.
RunningJob	RunningJob is the user-interface to query for details on a running Map-Reduce job.
SequenceFileInputFilter.Filter	filter interface

Class Summary

ClusterStatus	Status information on the current state of the Map-Reduce cluster.
Counters	A set of named counters.
Counters.Counter	A counter record, comprising its name and value.
Counters.Group	Group of counters, comprising of counters from a particular counter Enum class.
DefaultJobHistoryParser	Default parser for job history files.
FileInputFormat<K,V>	A base class for file-based InputFormat.
FileOutputFormat<K,V>	A base class for OutputFormat.
FileSplit	A section of an input file.
ID	A general identifier, which internally stores the id as an integer.
IsolationRunner
JobClient	JobClient is the primary interface for the user-job to interact with the JobTracker.
JobConf	A map/reduce job configuration.
JobEndNotifier
JobHistory	Provides methods for writing to and reading from job history.
JobHistory.HistoryCleaner	Delete history files older than one month.
JobHistory.JobInfo	Helper class for logging or reading back events related to job start, finish or failure.
JobHistory.MapAttempt	Helper class for logging or reading back events related to start, finish or failure of a Map Attempt on a node.
JobHistory.ReduceAttempt	Helper class for logging or reading back events related to start, finish or failure of a Map Attempt on a node.
JobHistory.Task	Helper class for logging or reading back events related to Task's start, finish or failure.
JobHistory.TaskAttempt	Base class for Map and Reduce TaskAttempts.
JobID	JobID represents the immutable and unique identifier for the job.
JobProfile	A JobProfile is a MapReduce primitive.
JobShell	Provide command line parsing for JobSubmission job submission looks like hadoop jar -libjars -archives -files inputjar args
JobStatus	Describes the current status of a job.
JobTracker	JobTracker is the central location for submitting and tracking MR jobs in a network environment.
KeyValueLineRecordReader	This class treats a line in the input as a key/value pair separated by a separator character.
KeyValueTextInputFormat	An InputFormat for plain text files.
LineRecordReader	Treats keys as offset in file and value as line.
LineRecordReader.LineReader	A class that provides a line reader from an input stream.
MapFileOutputFormat	An OutputFormat that writes MapFiles.
MapReduceBase	Base class for Mapper and Reducer implementations.
MapRunner<K1,V1,K2,V2>	Default MapRunnable implementation.
MultiFileInputFormat<K,V>	An abstract InputFormat that returns MultiFileSplit's in MultiFileInputFormat.getSplits(JobConf, int) method.
MultiFileSplit	A sub-collection of input files.
OutputFormatBase<K,V>	Deprecated. Use FileOutputFormat
OutputLogFilter	This class filters log files from directory given It doesnt accept paths having _logs.
SequenceFileAsBinaryInputFormat	InputFormat reading keys, values from SequenceFiles in binary (raw) format.
SequenceFileAsBinaryInputFormat.SequenceFileAsBinaryRecordReader	Read records from a SequenceFile as binary (raw) bytes.
SequenceFileAsBinaryOutputFormat	An OutputFormat that writes keys, values to SequenceFiles in binary(raw) format
SequenceFileAsBinaryOutputFormat.WritableValueBytes	Inner class used for appendRaw
SequenceFileAsTextInputFormat	This class is similar to SequenceFileInputFormat, except it generates SequenceFileAsTextRecordReader which converts the input keys and values to their String forms by calling toString() method.
SequenceFileAsTextRecordReader	This class converts the input keys and values to their String forms by calling toString() method.
SequenceFileInputFilter<K,V>	A class that allows a map/red job to work on a sample of sequence files.
SequenceFileInputFilter.FilterBase	base class for Filters
SequenceFileInputFilter.MD5Filter	This class returns a set of records by examing the MD5 digest of its key against a filtering frequency f.
SequenceFileInputFilter.PercentFilter	This class returns a percentage of records The percentage is determined by a filtering frequency f using the criteria record# % f == 0.
SequenceFileInputFilter.RegexFilter	Records filter by matching key to regex
SequenceFileInputFormat<K,V>	An InputFormat for SequenceFiles.
SequenceFileOutputFormat<K,V>	An OutputFormat that writes SequenceFiles.
SequenceFileRecordReader<K,V>	An RecordReader for SequenceFiles.
StatusHttpServer	Create a Jetty embedded server to answer http requests.
StatusHttpServer.StackServlet	A very simple servlet to serve up a text representation of the current stack traces.
StatusHttpServer.TaskGraphServlet	The servlet that outputs svg graphics for map / reduce task statuses
TaskAttemptID	TaskAttemptID represents the immutable and unique identifier for a task attempt.
TaskCompletionEvent	This is used to track task completion events on job tracker.
TaskID	TaskID represents the immutable and unique identifier for a Map or Reduce Task.
TaskLog	A simple logger to handle the task-specific user logs.
TaskLogAppender	A simple log4j-appender for the task child's map-reduce system logs.
TaskLogServlet	A servlet that is run by the TaskTrackers to provide the task logs via http.
TaskReport	A report on the state of a task.
TaskTracker	TaskTracker is a process that starts and tracks MR Tasks in a networked environment.
TaskTracker.Child	The main() for child processes.
TaskTracker.MapOutputServlet	This class is used in TaskTracker's Jetty to serve the map outputs to other nodes.
TextInputFormat	An InputFormat for plain text files.
TextOutputFormat<K,V>	An OutputFormat that writes plain text files.
TextOutputFormat.LineRecordWriter<K,V>

Enum Summary

JobClient.TaskStatusFilter
JobHistory.Keys	Job history files contain key="value" pairs, where keys belong to this enum.
JobHistory.RecordTypes	Record types are identifiers for each line of log in history files.
JobHistory.Values	This enum contains some of the values commonly used by history log events.
JobPriority	Used to describe the priority of the running job.
JobTracker.State
TaskCompletionEvent.Status
TaskLog.LogName	The filter for userlogs.

Exception Summary

FileAlreadyExistsException	Used when target file already exists for any operation and is not configured to be overwritten.
InvalidFileTypeException	Used when file type differs from the desired file type.
InvalidInputException	This class wraps a list of problems with the input, so that the user can get a list of problems together instead of finding and fixing them one by one.
InvalidJobConfException	This exception is thrown when jobconf misses some mendatory attributes or value of some attributes is invalid.
JobTracker.IllegalStateException	A client tried to submit a job before the Job Tracker was ready.

Package org.apache.hadoop.mapred Description

A software framework for easily writing applications which process vast amounts of data (multi-terabyte data-sets) parallelly on large clusters (thousands of nodes) built of commodity hardware in a reliable, fault-tolerant manner.

A Map-Reduce job usually splits the input data-set into independent chunks which processed by map tasks in completely parallel manner, followed by reduce tasks which aggregating their output. Typically both the input and the output of the job are stored in a FileSystem. The framework takes care of monitoring tasks and re-executing failed ones. Since, usually, the compute nodes and the storage nodes are the same i.e. Hadoop's Map-Reduce framework and Distributed FileSystem are running on the same set of nodes, tasks are effectively scheduled on the nodes where data is already present, resulting in very high aggregate bandwidth across the cluster.

The Map-Reduce framework operates exclusively on <key, value> pairs i.e. the input to the job is viewed as a set of <key, value> pairs and the output as another, possibly different, set of <key, value> pairs. The keys and values have to be serializable as Writables and additionally the keys have to be WritableComparables in order to facilitate grouping by the framework.

Data flow:

                                (input)
                                <k1, v1>
       
                                   |
                                   V
       
                                  map
       
                                   |
                                   V

                                <k2, v2>
       
                                   |
                                   V
       
                                combine
       
                                   |
                                   V
       
                                <k2, v2>
       
                                   |
                                   V
       
                                 reduce
       
                                   |
                                   V
       
                                <k3, v3>
                                (output)

Applications typically implement Mapper.map(Object, Object, OutputCollector, Reporter) and Reducer.reduce(Object, Iterator, OutputCollector, Reporter) methods. The application-writer also specifies various facets of the job such as input and output locations, the Partitioner, InputFormat & OutputFormat implementations to be used etc. as a JobConf. The client program, JobClient, then submits the job to the framework and optionally monitors it.

The framework spawns one map task per InputSplit generated by the InputFormat of the job and calls Mapper.map(Object, Object, OutputCollector, Reporter) with each <key, value> pair read by the RecordReader from the InputSplit for the task. The intermediate outputs of the maps are then grouped by keys and optionally aggregated by combiner. The key space of intermediate outputs are paritioned by the Partitioner, where the number of partitions is exactly the number of reduce tasks for the job.

The reduce tasks fetch the sorted intermediate outputs of the maps, via http, merge the <key, value> pairs and call Reducer.reduce(Object, Iterator, OutputCollector, Reporter) for each <key, list of values> pair. The output of the reduce tasks' is stored on the FileSystem by the RecordWriter provided by the OutputFormat of the job.

Map-Reduce application to perform a distributed grep:

public class Grep extends Configured implements Tool {

  // map: Search for the pattern specified by 'grep.mapper.regex' &
  //      'grep.mapper.regex.group'

  class GrepMapper<K, Text> 
  extends MapReduceBase  implements Mapper<K, Text, Text, LongWritable> {

    private Pattern pattern;
    private int group;

    public void configure(JobConf job) {
      pattern = Pattern.compile(job.get("grep.mapper.regex"));
      group = job.getInt("grep.mapper.regex.group", 0);
    }

    public void map(K key, Text value,
                    OutputCollector<Text, LongWritable> output,
                    Reporter reporter)
    throws IOException {
      String text = value.toString();
      Matcher matcher = pattern.matcher(text);
      while (matcher.find()) {
        output.collect(new Text(matcher.group(group)), new LongWritable(1));
      }
    }
  }

  // reduce: Count the number of occurrences of the pattern

  class GrepReducer<K> extends MapReduceBase
  implements Reducer<K, LongWritable, K, LongWritable> {

    public void reduce(K key, Iterator<LongWritable> values,
                       OutputCollector<K, LongWritable> output,
                       Reporter reporter)
    throws IOException {

      // sum all values for this key
      long sum = 0;
      while (values.hasNext()) {
        sum += values.next().get();
      }

      // output sum
      output.collect(key, new LongWritable(sum));
    }
  }
  
  public int run(String[] args) throws Exception {
    if (args.length < 3) {
      System.out.println("Grep <inDir> <outDir> <regex> [<group>]");
      ToolRunner.printGenericCommandUsage(System.out);
      return -1;
    }

    JobConf grepJob = new JobConf(getConf(), Grep.class);
    
    grepJob.setJobName("grep");

    grepJob.setInputPath(new Path(args[0]));
    grepJob.setOutputPath(args[1]);

    grepJob.setMapperClass(GrepMapper.class);
    grepJob.setCombinerClass(GrepReducer.class);
    grepJob.setReducerClass(GrepReducer.class);

    grepJob.set("mapred.mapper.regex", args[2]);
    if (args.length == 4)
      grepJob.set("mapred.mapper.regex.group", args[3]);

    grepJob.setOutputFormat(SequenceFileOutputFormat.class);
    grepJob.setOutputKeyClass(Text.class);
    grepJob.setOutputValueClass(LongWritable.class);

    JobClient.runJob(grepJob);

    return 0;
  }

  public static void main(String[] args) throws Exception {
    int res = ToolRunner.run(new Configuration(), new Grep(), args);
    System.exit(res);
  }

}

Notice how the data-flow of the above grep job is very similar to doing the same via the unix pipeline:

cat input/*   |   grep   |   sort    |   uniq -c   >   out

      input   |    map   |  shuffle  |   reduce    >   out

Hadoop Map-Reduce applications need not be written in Java^TM only. Hadoop Streaming is a utility which allows users to create and run jobs with any executables (e.g. shell utilities) as the mapper and/or the reducer. Hadoop Pipes is a SWIG-compatible C++ API to implement Map-Reduce applications (non JNI^TM based).

See Google's original Map/Reduce paper for background information.

Java and JNI are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries.