rate of acceptance of sockets when using gen_tcp

Question

I found an interesting problem when using gen_tcp behavior. I have a server and a client. The server accepts connections and the client creates many processes that all try to connect to the listening server.

If I try to start the client which spawns many processes that all try to connect to the socket at the same time then many fail. However if I put timer:sleep(x) then every socket is being accepted.

Does this mean that gen_tcp:accept() has a limit where it can accept some connection request?

Code for the server and the client follows:

 accept(State = #state{lsocket = LSocket, num = Num}) ->
   case gen_tcp:accept(LSocket) of
     {ok, Socket} ->
       io:format("Accepted ~p ~n", [Num]),
       {sockets, List} = hd(ets:lookup(csockets, sockets)),
       NewList = [Socket | List],
       ets:insert(csockets, {sockets, NewList}),
       Pid = spawn(fun() -> loop(Socket) end),
       gen_tcp:controlling_process(Socket, Pid),
       accept(State#state{num = Num + 1});
     {error, closed} -> State
   end.

 loop(Socket) ->
   case gen_tcp:recv(Socket, 0) of
     {ok, Data} ->
       gen_tcp:send(Socket, Data),
       loop(Socket);
     {error, closed} ->
       io:format(" CLOSED ~n"),
       ok
   end.

Client:

send(State = #state{low = Low, high = Low}) ->
  State;
send(State = #state{low = Low}) ->
  N = Low rem 10,
  Dest = lists:nth(N + 1, State#state.dest),
  spawn(?MODULE, loop, [Dest, Low]),
  %%timer:sleep(1),
  NewState = State#state{low = Low + 1},
  send(NewState).

loop({IP, Port}, Low) ->
  case gen_tcp:connect(IP, Port, [binary]) of
    {ok, Socket} ->
      io:format("~p Connected ~n", [Low]),
      gen_tcp:send(Socket, "Hi"),
      receive
        {tcp, RecPort, Data} ->
          io:format("I have received ~p on port ~p  ~p ~n", [Data, RecPort, Low])
      end;
    _Else ->
      io:format("The connection failed ~n"),
      loop({IP, Port}, Low)
  end.

You could print the _Else result in the client to get the reason of failure to connect to the server. I have reformatted your post to read it more easily. It appears that when the client succeed to connect, the client doesn't loop and the process terminates immediately, closing the socket. — Pascal, Apr 08 '16 at 22:47
You need to check your TCP listen backlog, as the default is 5. You can set it in your listen call via the `{backlog, B}` option, where `B` is an integer. Oh, and also, `gen_tcp` is not a behavior, it's just a module. — Steve Vinoski, Apr 09 '16 at 01:22

score 1 · Answer 1 · answered Apr 10 '16 at 11:43

It is true that a single process can only gen_tcp:accept/1 so fast, though I'm not sure that that's the bottleneck you're running in to.

You might be interested in Ranch, the TCP library for the Cowboy webserver. The manual includes a section on internal features that talks about using multiple acceptors.

In your case, you should try to produce more debugging output for yourself. Printing the error when the client fails to connect would be a good start -- there are lots reasons why a TCP client might fail to connect.

rate of acceptance of sockets when using gen_tcp

1 Answers1