pool(3erl) [linux man page]

pool(3erl)						     Erlang Module Definition							pool(3erl)

NAME

       pool - Load Distribution Facility

DESCRIPTION

       pool  can  be used to run a set of Erlang nodes as a pool of computational processors. It is organized as a master and a set of slave nodes
       and includes the following features:

	 * The slave nodes send regular reports to the master about their current load.

	 * Queries can be sent to the master to determine which node will have the least load.

       The BIF statistics(run_queue) is used for estimating future loads. It returns the length of the queue of ready  to  run	processes  in  the
       Erlang runtime system.

       The slave nodes are started with the slave module. This effects, tty IO, file IO, and code loading.

       If the master node fails, the entire pool will exit.

EXPORTS

       start(Name) ->
       start(Name, Args) -> Nodes

	      Types  Name = atom()
		     Args = string()
		     Nodes = [node()]

	      Starts  a  new pool. The file .hosts.erlang is read to find host names where the pool nodes can be started. See section Files below.
	      The start-up procedure fails if the file is not found.

	      The slave nodes are started with slave:start/2,3 , passing along Name and, if provided, Args . Name is used as the first part of the
	      node names, Args is used to specify command line arguments. See slave(3erl) .

	      Access rights must be set so that all nodes in the pool have the authority to access each other.

	      The function is synchronous and all the nodes, as well as all the system servers, are running when it returns a value.

       attach(Node) -> already_attached | attached

	      Types  Node = node()

	      This function ensures that a pool master is running and includes Node in the pool master's pool of nodes.

       stop() -> stopped

	      Stops the pool and kills all the slave nodes.

       get_nodes() -> Nodes

	      Types  Nodes = [node()]

	      Returns a list of the current member nodes of the pool.

       pspawn(Mod, Fun, Args) -> pid()

	      Types  Mod = Fun = atom()
		     Args = [term()]

	      Spawns a process on the pool node which is expected to have the lowest future load.

       pspawn_link(Mod, Fun, Args) -> pid()

	      Types  Mod = Fun = atom()
		     Args = [term()]

	      Spawn links a process on the pool node which is expected to have the lowest future load.

       get_node() -> node()

	      Returns the node with the expected lowest future load.

FILES

       .hosts.erlang is used to pick hosts where nodes can be started. See net_adm(3erl) for information about format and location of this file.

       $HOME/.erlang.slave.out.HOST  is  used  for  all additional IO that may come from the slave nodes on standard IO. If the start-up procedure
       does not work, this file may indicate the reason.

Ericsson AB							   stdlib 1.17.3							pool(3erl)

net_adm(3erl)						     Erlang Module Definition						     net_adm(3erl)

NAME

       net_adm - Various Erlang Net Administration Routines

DESCRIPTION

       This module contains various network utility functions.

EXPORTS

       dns_hostname(Host) -> {ok, Name} | {error, Host}

	      Types  Host = atom() | string()
		     Name = string()

	      Returns the official name of Host , or {error, Host} if no such name is found. See also inet(3erl) .

       host_file() -> Hosts | {error, Reason}

	      Types  Hosts = [Host]
		     Host = atom()
		     Reason = term()

	      Reads  the  .hosts.erlang file, see the section Files below. Returns the hosts in this file as a list, or returns {error, Reason} if
	      the file could not be read. See file(3erl) for possible values of Reason .

       localhost() -> Name

	      Types  Name = string()

	      Returns the name of the local host. If Erlang was started with the -name command line flag, Name is the fully qualified name.

       names() -> {ok, [{Name, Port}]} | {error, Reason}
       names(Host) -> {ok, [{Name, Port}]} | {error, Reason}

	      Types  Name = string()
		     Port = int()
		     Reason = address | term()

	      Similar to epmd -names , see epmd(1) . Host defaults to the local host. Returns the names and associated port numbers of the  Erlang
	      nodes that epmd at the specified host has registered.

	      Returns {error, address} if epmd is not running. See inet(3erl) for other possible values of Reason .

	      (arne@dunn)1> net_adm:names().
	      {ok,[{"arne",40262}]}

       ping(Node) -> pong | pang

	      Types  Node = node()

	      Tries to set up a connection to Node . Returns pang if it fails, or pong if it is successful.

       world() -> [node()]
       world(Arg) -> [node()]

	      Types  Arg = silent | verbose

	      This  function  calls names(Host) for all hosts which are specified in the Erlang host file .hosts.erlang , collects the replies and
	      then evaluates ping(Node) on all those nodes. Returns the list of all nodes that were, successfully pinged.

	      Arg defaults to silent . If Arg == verbose , the function writes information about which nodes it is pinging to stdout.

	      This function can be useful when a node is started, and the names of the other nodes in the network are not initially known.

	      Failure: {error, Reason} if host_file() returns {error, Reason} .

       world_list(Hosts) -> [node()]
       world_list(Hosts, Arg) -> [node()]

	      Types  Hosts = [Host]
		     Host = atom()
		     Arg = silent | verbose

	      As world/0,1 , but the hosts are given as argument instead of being read from .hosts.erlang .

FILES

       The .hosts.erlang file consists of a number of host names written as Erlang terms. It is looked for in  the  current  work  directory,  the
       user's home directory, and $OTP_ROOT (the root directory of Erlang/OTP), in that order.

       The  format  of the .hosts.erlang file must be one host name per line. The host names must be within quotes as shown in the following exam-
       ple:

       ^ (new line)

Ericsson AB							   kernel 2.14.3						     net_adm(3erl)