anchor.diff:                     remaining=LimitPerInterval,
                      interval=IntervalInMillis,
                      name=Name,
  -                   pending=queue:new()},
  +                   pending=queue:new(),
  +                   members=sets:new(),
  +                   len=0},
   
       alive(Name),
       {ok, schedule_refill(State)}.
  
positive.code:     To ! Reply,
      State#state{remaining=Rem-1};
  
  drain(#state{name=Name} = State, Reply, To) ->
      Item = {Reply, To},
  
      % XXX: not sure about this one yet - it has O(n) complexity
      case queue:member(Item, State#state.pending) of
          true ->
              State;
          _ ->
              statser_instrumentation:increment(<<Name/binary, "-dropped">>),
  
              Pending = queue:in(Item, State#state.pending),
              State#state{pending=Pending}
      end.
  
  
  drain_queue(Queue, 0) -> {Queue, 0};
  drain_queue(Queue, Remaining) ->
      case queue:out(Queue) of
          {empty, _Q} -> {Queue, Remaining};
          {{value, {Reply, To}}, Q} ->
              To ! Reply,
              drain_queue(Q, Remaining-1)
      end.
  
negative.code: %% @end
  %%--------------------------------------------------------------------
  handle_info(refill, #state{limit=Limit, name=Name} = State) ->
      statser_instrumentation:record(<<Name/binary, "-cache-size">>, State#state.len),
  
      Members = State#state.members,
      {Pending, Members0, Remaining} = drain_queue(State#state.pending, Members, Limit),
      Drained = Limit - Remaining,
      NewLen = State#state.len - Drained,
  
      NewState = State#state{remaining=Remaining,
                             pending=Pending,
                             members=Members0,
                             len=NewLen},
  
      {noreply, schedule_refill(NewState)};
  
  handle_info({drain, Reply, To}, State) ->
  