anchor.diff:  %% is less than count of actually running workers.
   -spec is_overloaded(#state{}) -> boolean().
   is_overloaded(State) ->
  -    MPR = State#state.max_parallel_requests,
  -    if is_integer(MPR) ->
  -            MPR =< workers_count(State);
  -       is_function(MPR, 0) ->
  -            MPR() =< workers_count(State)
  -    end.
  +    get_max_parallel_requests(State) =< workers_count(State).
   
   %% @doc Return total count of running workers. This include
   %% workers for sync requests and workers for casts (async requests).
  
positive.code: handle_data_from_net(State, ?PACKET_CAST(_SeqNum, Request)) ->
      %% relay the cast to the receiver process
      ok = deliver_cast(State#state.receiver, Request),
      OSP = State#state.overflow_suspend_period,
      is_overloaded(State) andalso
          suspend(
            self(),
            if is_integer(OSP) ->
                    OSP;
               is_function(OSP, 0) ->
                    OSP()
            end),
      ok;
  handle_data_from_net(_State, _BadOrUnknownPacket) ->
      %% ignore
  
negative.code: %% @doc Check the size of process message queue.
  -spec check_message_queue_len(#state{}) -> ok | stop.
  check_message_queue_len(State) ->
      MaxMessageQueueLen = get_max_message_queue_len(State),
      case process_info(self(), message_queue_len) of
          {message_queue_len, Len} when Len < MaxMessageQueueLen ->
              %% message queue length is of normal size
              ok;
          _Overload ->
              %% ask clients for suspend
              Millis = get_queue_overflow_suspend_period(State),
              case gen_tcp:send(
                     State#state.socket,
                     ?PACKET_FLOW_CONTROL_SUSPEND(Millis)) of
  