anchor.diff:  -spec fold_keys(index(), pid(), partition(), boolean()) -> ok.
   fold_keys(Partition, HashtreePid, Index, HasIndexTree) ->
       FoldFun = fold_fun(HashtreePid, HasIndexTree),
  +    {Limit, Wait} = get_build_throttle(),
       Req = riak_core_util:make_fold_req(FoldFun,
  -                                       0, false,
  +                                       {0, {Limit, Wait}}, false,
                                          [aae_reconstruction,
                                           {iterator_refresh, true}]),
       Result = riak_core_vnode_master:sync_command({Partition, node()},
  
positive.code: -spec fold_fun(pid(), boolean()) -> fun().
  fold_fun(HashtreePid, _HasIndexTree = false) ->
      ObjectFoldFun = object_fold_fun(HashtreePid),
      {Limit, Wait} = get_build_throttle(),
      fun(BKey, RObj, Acc) ->
              BinBKey = term_to_binary(BKey),
              ObjectFoldFun(BKey, RObj, BinBKey),
              Acc2 = maybe_throttle_build(RObj, Limit, Wait, Acc),
  
negative.code: 
  %% The accumulator in the fold is the number of bytes hashed
  %% modulo the "build limit" size. If we get an int back, everything is ok
  handle_fold_keys_result({Result, {_Limit, _Delay}}, HashtreePid, Index) when is_integer(Result) ->
      lager:info("Finished AAE tree build: ~p", [Index]),
      gen_server:cast(HashtreePid, build_finished);
  handle_fold_keys_result(Result, HashtreePid, Index) ->
      lager:error("Failed to build hashtree for index ~p. Result was: ~p", [Index, Result]),
      gen_server:cast(HashtreePid, build_failed).
  
  