Hadoop I/O

Why Not Use Java Object Serialization? p. 101 Serialization with Thrift:

There is limited support for these as MapReduce  formats (p.  102): 

SequenceFile can use 'any' serialization framework In contrast, MapFile can only use Writables

I heard Hbase used to use MapFile. Does it mean we  can't use it outside Java?

NO! Thrift or Stargate REST Connector(ALPHA)

MapFile is as an indexed and sorted SequenceFile.

Map & Reduce: other languages

Unix standard streams as the interface between Hadoop and your program  (p.32) The Java API is geared toward processing your map function one record at  a time

Records are ”pushed” but it’s still possible to consider multiple lines at a time by  accumulating previous lines in an instance variable in the  Mapper Or use the new ”pull style” (p.25)

Whereas with Streaming the map program can decide how to process the  input What's the penalty for that? Data is copied over from the Java proccess  space to other proccess space[1]. Is Remote Debugging (p. 144)  possible? Don't think so.
[1]: http://www.cloudera.com/hadoop­training­programming­with­hadoop 49'50”    

Map & Reduce: C++

Hadoop Pipes Uses sockets as the channel over which the tasktracker communicates with the  process running the C++ map or reduce function Implement 

HadoopPipes::Mapper HadoopPipes::Reducer Main: int main(int argc, char *argv[]) {   return  HadoopPipes::runTask(HadoopPipes::TemplateFactory<MaxTemperat ureMapper, MapTemperatureReducer>()); }

% hadoop pipes ­D hadoop.pipes.java.recordreader=true  ­D  hadoop.pipes.java.recordwriter=true  ­input sample.txt  ­output output   ­program bin/max_temperature

HDFS concepts

A file in HDFS that is smaller than a single block does not occupy a full block’s  worth of un­derlying storage A file can be larger than any single disk in the network. The file will be spread to  more than 1 node A block is typically replicated to 3 other physical machines

Some applications may choose to set a high replication factor for the  blocks in a popular file to spread the read load on the cluster.

File permissions in HDFS (p. 47) Interfaces:

FUSE, Thrift, C The FUSE interface allows any HDFS to be mounted in the standard FS.  It makes it possible to use any Unix utility like ls, cat... However it doesn't mean you should use it as a general purpose FS.

HDFS Concepts

HDFS stores small files inefficiently [1]

Eats up a lot of Namenode's memory However it won't take up any more space than is  required to store the raw contents of a file

HDFS allows only sequential writes to an open file,  or appends to an already written file.

[1]: http://www.cloudera.com/blog/2009/02/02/the-small-files-problem/

HDFS: client read
The Namenode gives back the closest (p. 64) nodes with these block location.



HDFS coherency model
Path p = new Path("p"); FSDataOutputStream out = fs.create(p); out.write("content".getBytes("UTF-8")); out.flush(); out.sync(); assertThat(fs.getFileStatus(p).getLen(), is(((long) "content".length())));

When you sync, you are guaranteed to see the  changes to the FS With no calls to sync(), you should be prepared to  lose up to a block of data in the event of client or  system failure Trade­off between data robustness and throughput


What happens if the Namenode dies? [1] What if a Datanode fails during a write? (p.67) In a Job if 1 task keeps failing Hadoop will give up  and by default say that the Job failed. However you can specify a Quality Factor and  specify that ”if only 99% of my input is mapped  it's good enough for me”. [3] Since everything is stored as String, how much  space are we loosing when storing binary data as  base64?


<property>   <name>size­weight</name>   <value>${size},${weight}</value>   <description>Size and weight</description> </property> Tool interface MiniDFSCluster and MiniMRCluster: a programmatic way of  creating in­process clusters. Unlike the local job runner, these  allow testing against the full HDFS and MapReducemachinery.  Bear in mind too that task­trackers in a mini­cluster launch  separate JVMs to run tasks in, which can make debugging more  difficult.

System.err.println("Temperature over 100 degrees for input: " + value); reporter.setStatus("Detected possibly corrupt record: see logs."); reporter.incrCounter(Temperature.OVER_100, 1);





System daemons (p. 256) HDFS audit  (p. 280) MapReduce job history (p. 135) MapReduce task (p. 143)




distcp Balancer Metrics: jmx/ganglia



Fault Tolerance: when a Task fails
When the jobtracker is notified of a task attempt that has failed (by the tasktracker’s heartbeat call) it will reschedule execution of the task. The jobtracker will try to avoid rescheduling the task on a tasktracker where it has previously failed. Furthermore, if a task fails more than four times, it will not be retried further. This value is configurable: the maximum number of attempts to run a task is controlled by the mapred.map.max.attempts property for map tasks, and mapred.reduce.max.attempts for reduce tasks. By default, if any task fails more than four times (or whatever the maximum number of attempts is configured to), the whole job fails. (p. 160) If a Streaming process hangs, the tasktracker does not try to kill it (although the JVM that launched it will be killed), so you should take precautions to monitor for this scenario, and kill orphaned processes by some other means Currently, Hadoop has no mechanism for dealing with failure of the jobtracker—it is a single point of failure (p. 161)



Fault tolerance: bad data

When you have a bad record these are the options:

You can detect the bad record and ignore it. Additionally you can  use a custom counter. You can abort the job by throwing an exception Automatic mechanism for skiping bad records (you can’t handle the  problem because there is a bug in a 3rd­party library that you  can’t work around in your mapper or reducer): 1. Task fails. 2. Task fails. 3. Skipping mode is enabled. Task fails but failed record is  stored by the tasktracker. 4. Skipping mode is still enabled. Task succeeds by  skipping the bad record that failec  in the previous  attempt.

It is often a good idea to compress the map output  as it is written to disk, since doing so makes it  faster to write to disk, saves disk space, and  reduces the amount of data to transfer to the  reducer The amount of memory given to the JVMs in which  the map and reduce tasks run is set by the  mapred.child.java.opts property. You should try  to make this as large as possible for the amount of  memory on you task nodes; the discussion in  “Memory” on page 254 goes through the  constraints to consider.


Incomplete presentation d:~(

Sorry, this was a presentation that I was making but  did not have the time to finish. Nevertheless, I felt  like sharing it... Based on the OReilly ­ Hadoop The Definitive  Guide (06­2009) book.



Sign up to vote on this title
UsefulNot useful

Master Your Semester with Scribd & The New York Times

Special offer for students: Only $4.99/month.

Master Your Semester with a Special Offer from Scribd & The New York Times

Cancel anytime.