Hi all,

I’m just learning elixir for fun , and I would love to understand a little bit more about the memory allocations that are made during the following code snippet taken from the Mix OTP tutorial:

defp loop_acceptor(socket) do
  {:ok, client} = :gen_tcp.accept(socket)
  {:ok, pid} = Task.Supervisor.start_child(KVServer.TaskSupervisor, fn -> serve(client) end)
  :ok = :gen_tcp.controlling_process(client, pid)
  loop_acceptor(socket)
end

Heres what I am thinking so far:

1. loop_acceptor function is called and socket is placed onto the stack for this function call
2. :gen_tcp.accept(socket) is called which creates a socket resource called client, this is currently owned by the process that called loop_acceptor
3. Task.Supervisor.start_child is called, the anon function creates a closure which captures the serve function and the client.

Thats where I get stuck.

1. Does this closure which runs in a new process result in the variables it captures being “copied” into the new process heap/stack?
2. If so.. how is it possible to “copy” a resource like a socket without creating multiple OS sockets for the same connection?
3. As the serve function belongs to the surrounding KVServer module does this mean that the supervised task gets a copy of the KVServer module too?

If anyone has any good documentation to learn more about BEAM memory, or perhaps some tips on how I can debug these allocations myself.

I’m very green with BEAM

Any help is greatly appreciated, thanks!