anchor.diff:  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),
  +        suspend(self(), get_overflow_suspend_period(State)),
       ok;
   handle_data_from_net(_State, _BadOrUnknownPacket) ->
       %% ignore
  
positive.code: %% @doc Check the size of process message queue.
  -spec check_message_queue_len(#state{}) -> ok | stop.
  check_message_queue_len(State) ->
      MMQL = State#state.max_message_queue_len,
      MaxMessageQueueLen =
          if is_integer(MMQL) ->
                  MMQL;
             is_function(MMQL, 0) ->
                  MMQL()
          end,
      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
              QOSP = State#state.queue_overflow_suspend_period,
              Millis =
                  if is_integer(QOSP) ->
                          QOSP;
                     is_function(QOSP) ->
                          QOSP()
                  end,
              case gen_tcp:send(
                     State#state.socket,
                     ?PACKET_FLOW_CONTROL_SUSPEND(Millis)) of
  
negative.code: %% is less than count of actually running workers.
  -spec is_overloaded(#state{}) -> boolean().
  is_overloaded(State) ->
      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).
  