anchor.diff:  . `MapReduce.MapEmitter`: The system that collects key/value pairs being emitted by the MapReduce applications map-phase.
   . `MapReduce.ReduceEmitter`: The system that collects key/value pairs being emitted by the MapReduce applications combine- and reduce-phases.
   
  -NOTE: The interfaces VertexProgram and MapReduce in the `process/computer/` package are not required by the vendor to implement. Instead, these are interfaces to be implemented by application developers writing VertexPrograms and MapReduce jobs.
  -
  -IMPORTANT: TinkerPop3 provides two OLAP implementations: <<tinkergraph-gremlin,TinkerGraphComputer>> and <<hadoop-gremlin,HadoopGraphComputer>>. It is a good idea to study these implementations to understand the nuances of the implementation requirements.
  +NOTE: The VertexProgram and MapReduce interfaces in the `process/computer/` package are not required by the vendor to implement. Instead, these are interfaces to be implemented by application developers writing VertexPrograms and MapReduce jobs.
  +
  +IMPORTANT: TinkerPop3 provides three OLAP implementations: <<tinkergraph-gremlin,TinkerGraphComputer>> (TinkerGraph), <<giraphgraphcomputer,GiraphGraphComputer>> (HadoopGraph), and <<sparkgraphcomputer,`SparkGraphComputer`>> (Hadoop). Given the complexity of the OLAP system, it is good to study and copy many of the patterns used in these reference implementations.
   
   Implementing GraphComputer
   ++++++++++++++++++++++++++
  
positive.code: The method `MapReduce.reduce()` is defined as:
  
  [source,java]
  public void reduce(final MK key, final Iterator<MV> values, final ReduceEmitter<RK, RV> emitter) { ... }
  
  In other words, for the TinkerGraph implementation, iterate through the entrySet of the `reduceMap` and call the `reduce()` method on each entry. The `reduce()` method can emit key/value pairs which are simply aggregated into a `Queue<Pair<OK,OV>>` in an analogous fashion to `TinkerMapEmitter` when no reduce is to follow. These two emitters are tied together in `TinkerGraphComputer.submit()`.
  
  [source,java]
  ...
  for (final MapReduce mapReduce : this.mapReduces) {
      if (mapReduce.doStage(MapReduce.Stage.MAP)) {
          final TinkerMapEmitter<?, ?> mapEmitter = new TinkerMapEmitter<>(mapReduce.doStage(MapReduce.Stage.REDUCE));
          TinkerHelper.getVertices(this.graph).parallelStream().forEach(vertex -> mapReduce.map(vertex, mapEmitter));
          // no need to run combiners as this is single machine
          if (mapReduce.doStage(MapReduce.Stage.REDUCE)) {
              final TinkerReduceEmitter<?, ?> reduceEmitter = new TinkerReduceEmitter<>();
              mapEmitter.reduceMap.entrySet().parallelStream().forEach(entry -> mapReduce.reduce(entry.getKey(), entry.getValue().iterator(), reduceEmitter));
              mapReduce.addSideEffectToMemory(this.memory, reduceEmitter.resultList.iterator()); <1>
          } else {
              mapReduce.addSideEffectToMemory(this.memory, mapEmitter.mapQueue.iterator()); <2>
          }
      }
  }
  ...
  
  <1> Note that the final results of the reducer are provided to the Memory as specified by the application developer's `MapReduce.addSideEffectToMemory()` implementation.
  <2> If there is no reduce stage, the the map-stage results are inserted into Memory as specified by the application developer's `MapReduce.addSideEffectToMemory()` implementation.
  
  [[io-implementations]]
  IO Implementations
  
negative.code: @Graph.OptIn(Graph.OptIn.SUITE_PROCESS_STANDARD)
  @Graph.OptIn(Graph.OptIn.SUITE_PROCESS_COMPUTER)
  @Graph.OptOut(
          test = "org.apache.tinkerpop.gremlin.process.graph.step.map.MatchTest$Traversals",
          method = "g_V_matchXa_hasXname_GarciaX__a_inXwrittenByX_b__a_inXsungByX_bX",
          reason = "Hadoop-Gremlin is OLAP-oriented and for OLTP operations, linear-scan joins are required. This particular tests takes many minutes to execute.")
  @Graph.OptOut(
          test = "org.apache.tinkerpop.gremlin.process.graph.step.map.MatchTest$Traversals",
          method = "g_V_matchXa_inXsungByX_b__a_inXsungByX_c__b_outXwrittenByX_d__c_outXwrittenByX_e__d_hasXname_George_HarisonX__e_hasXname_Bob_MarleyXX",
          reason = "Hadoop-Gremlin is OLAP-oriented and for OLTP operations, linear-scan joins are required. This particular tests takes many minutes to execute.")
  @Graph.OptOut(
          test = "org.apache.tinkerpop.gremlin.process.computer.GraphComputerTest",
          method = "shouldNotAllowBadMemoryKeys",
          reason = "Hadoop does a hard kill on failure and stops threads which stops test cases. Exception handling semantics are correct though.")
  @Graph.OptOut(
          test = "org.apache.tinkerpop.gremlin.process.computer.GraphComputerTest",
          method = "shouldRequireRegisteringMemoryKeys",
          reason = "Hadoop does a hard kill on failure and stops threads which stops test cases. Exception handling semantics are correct though.")
  public class HadoopGraph implements Graph {
  