Best practices for processing RDF data using MapReduce (via Hadoop)?

From my experience within the Sindice project, you should definitely use n-triples or n-quad for many reasons:

1. much easier to manipulate: you are dealing with a set of lines (triples or quads) which can be more efficiently distributed by hadoop since hadoop will distribute the data on a quad/statement level, and not on a document level. You are moving the data granularity to a statement instead of a document. Document can be big and therefore some hadoop job will require more resources/time to finish. By working with statements, the data is more equitably distributed over the nodes.
2. you don't have the overhead of parsing xml or turtle for manipulating the data (parsing a triple or quad is simple and therefore very efficient)
3. even if n-triple / n-quad format have size overhead compared to rdf/xml or turtle, you don't really care since hadoop/hdfs will compressed the data for you transparently (so the size overhead becomes very small)
4. you can easily sort, group, extract the triples / quads using map and reduce functions. With just basic (few lines of code) map/reduce functions, you can create an hadoop job that will sort your data first by context, and subject and extract single entity description (the set of quads having the same context and subject). This is the basic mechanism behind the Sindice/SIREn indexing pipeline.
5. more easy to debug (it is the only format that is easily readable by human imho).

I've not done MapReduce specifically, but have done other parallel RDF work (on clusters and supercomputers), so not sure if this will apply to you directly (but hopefully it does). I can say yes, definitely use N-Triples or N-Quads. It takes all the complexity out of thinking about parsing and serializing, and you can split and concatenate the files without worrying about namespace declarations or splitting right in the middle of a complex structure (as you might find in RDF/XML or Turtle).

Using N-Triples or N-Quads will work and there are a lot of benefits, as the original answer listed. Problem though is that the meaning of the data is not really at the granularity of a statement. For example, let's say that we want to state that ball #1 has a color with rgb value of 255,0,0:

@prefix rel: <urn:myont:rel:> .
@prefix class: <urn:myont:class:> .
@prefix ball: <urn:myont:class:Ball:> .

ball:1
      a class:Ball;
      rel:hasColor [
           a class:Color;
           rel:hasRedComponent "255"^^xsd:integer;                            
           rel:hasGreenComponent "0"^^xsd:integer;
           rel:hasBlueComponent "0"^^xsd:integer
           ].

How would you meaningfully distribute the statements in the above while staying with granularity at the statement level?

I'd recommend using the concept of RDF Molecules. An RDF molecule is the minimal RDF graph you can create such that you do not lose information when distributing it (my summary, not a formal definition).

Some links on RDF molecules:

ftp://ksl.stanford.edu/pub/KSL_Reports/KSL-05-06.pdf

http://www.w3c.rl.ac.uk/SWAD/papers/RDFMolecules_final.doc

http://www.itee.uq.edu.au/~eresearch/presentations/Hunter_BioMANTA_UK_eScience.pdf

http://jrdf.sourceforge.net/status.html

http://morenews.blogspot.com/2008/07/yads-and-rdf-molecules.html