A simple server which load balances a request among different process based on round robin algorithm. Written this to understand how could i do load balancing among different processes in Erlang

sieve_server.erl

-module(sieve_server).

-export([sieve/1,start/1,sieve_loop/0,sieve_balancer/1,rpc/2,test/2,test_internal/2]).


test(Pid,Request) ->
  spawn(sieve_server,test_internal,[Pid,Request]).

test_internal(Pid, Request) ->
  receive
  after 500 ->
      Response = rpc(Pid, Request),
      io:format("~p~n", [Response]),
      test(Pid,Request)
  end.

rpc(Pid,Request) ->
  Pid ! {self(),Request},
  receive
    Response ->
      Response
  end.

start(Instances) ->
  Pids = [spawn(sieve_server,sieve_loop,[])||_X<-lists:seq(1,Instances)],
  register(sieve_server,spawn(sieve_server,sieve_balancer,[Pids])),
  sieve_server.

sieve_balancer([Pid|T]) ->
  receive
    {_From,_Cmd}=Msg ->
      Pid ! Msg,
      Pids = lists:reverse([Pid|lists:reverse(T)]),
      sieve_balancer(Pids);
    stop ->
      void
  end.
  
sieve_loop() ->
  receive
    {From,{sieve,N}} ->
      From ! {ok,self(),sieve(N)},
      sieve_loop();
    {From,Other} ->
      From ! {error,Other},
      sieve_loop()
  end.


sieve([]) -> 
  [];

sieve([H|T]) -> 
  List = lists:filter(fun(N) -> N rem H =/= 0 end,T),
  [H|sieve(List)];

sieve(N) ->
      sieve(lists:seq(2,N)).