anchor.diff:                   % Update stats.
                    print_gc_stats(all, NewStats),
                    ddfs_master:update_gc_stats(NewStats),
  -                 AvgDiskUsage = avg_disk_usage(NewNodeStats),
  -                 UnderusedNodes = find_unstable_nodes(underused, NewNodeStats,
  -                                                      AvgDiskUsage),
  -                 OverusedNodes = find_unstable_nodes(overused, NewNodeStats,
  -                                                     AvgDiskUsage),
  +                 DiskUsage = avg_disk_usage(NewNS),
  +                 Underused = find_unstable_nodes(underused, NewNS, DiskUsage),
  +                 Overused = find_unstable_nodes(overused, NewNS, DiskUsage),
                    lager:info("GC: average disk utilization: ~p, "
                               "over utilized nodes: ~p, "
                               "under utilized nodes: ~p",
  -                            [AvgDiskUsage, length(OverusedNodes),
  -                            length(UnderusedNodes)]),
  +                            [DiskUsage, length(Overused), length(Underused)]),
  +                 FutureNS = estimate_rr_blobs(S#state{nodestats = NewNS}),
  +                 NewDiskUsage = avg_disk_usage(FutureNS),
  +                 NewUnderused = find_unstable_nodes(underused, FutureNS, NewDiskUsage),
  +                 NewOverused = find_unstable_nodes(overused, FutureNS, NewDiskUsage),
  +                 lager:info("GC: average disk utilization: ~p, "
  +                            "over utilized nodes: ~p, "
  +                            "under utilized nodes: ~p",
  +                            [NewDiskUsage, length(NewOverused), length(NewUnderused)]),
   
                    lager:info("GC: entering rr_blobs phase"),
                    % Start the replicator process which will
  
positive.code:                                                pending_nodes = Pending,
                                                 deleted_ages = DeletedAges,
                                                 rr_reqs = RReqs,
                                                 nodestats = NodeStats,
                                                 tags = Tags} = S) ->
      print_gc_stats(Node, GCNodeStats),
      NewStats = add_gc_stats(Stats, GCNodeStats),
      NewPending = gb_sets:delete(Node, Pending),
      NewNodeStats = update_nodestats(Node, GCNodeStats, NodeStats),
      S1 = case gb_sets:size(NewPending) of
               0 ->
                   % This was the last node we were waiting for to
  
negative.code:                  Reqs = rereplicate_blob(Sr, Start),
                   Sr#state{phase = rr_blobs,
                            rr_reqs = RReqs + Reqs,
                            nodestats = FutureNS,
                            underused_nodes = NewUnderused,
                            overused_nodes = NewOverused};
               Remaining ->
                   lager:info("GC: ~p nodes pending in gc", [Remaining]),
                   S#state{nodestats = NewNS}
           end,
      {noreply, S1#state{pending_nodes = NewPending,
                         gc_stats = NewStats,
                         last_response_time = now()}};
  
  handle_cast({rr_blob, '$end_of_table'},
              #state{phase = rr_blobs, rr_pid = RR, rr_reqs = RReqs} = S) ->
  