erl_malloc(3erl) [linux man page]

erl_malloc(3erl)						C Library Functions						  erl_malloc(3erl)

NAME

       erl_malloc - Memory Allocation Functions

DESCRIPTION

       This module provides functions for allocating and deallocating memory.

EXPORTS

       ETERM * erl_alloc_eterm(etype)

	      Types  unsigned char etype;

	      This function allocates an (ETERM) structure. Specify etype as one of the following constants:

		* ERL_INTEGER

		* ERL_U_INTEGER /* unsigned integer */

		* ERL_ATOM

		* ERL_PID /* Erlang process identifier */

		* ERL_PORT

		* ERL_REF /* Erlang reference */

		* ERL_LIST

		* ERL_EMPTY_LIST

		* ERL_TUPLE

		* ERL_BINARY

		* ERL_FLOAT

		* ERL_VARIABLE

		* ERL_SMALL_BIG /* bignum */

		* ERL_U_SMALL_BIG /* bignum */

	      ERL_SMALL_BIG  and  ERL_U_SMALL_BIG  are	for creating Erlang bignums , which can contain integers of arbitrary size. The size of an
	      integer in Erlang is machine dependent, but in general any integer larger than 2^28 requires a bignum.

       void erl_eterm_release(void)

	      Clears the freelist, where blocks are placed when they are released by erl_free_term() and erl_free_compound() .

       void erl_eterm_statistics(allocated, freed)

	      Types  long *allocated;
		     long *freed;

	      allocated and freed are initialized to contain information about the fix-allocator used to allocate ETERM components.  allocated	is
	      the  number  of  blocks currently allocated to ETERM objects. freed is the length of the freelist, where blocks are placed when they
	      are released by erl_free_term() and erl_free_compound() .

       void erl_free_array(array, size)

	      Types  ETERM **array;
		     int size;

	      This function frees an array of Erlang terms.

	      array is an array of ETERM* objects.

	      size is the number of terms in the array.

       void erl_free_term(t)

	      Types  ETERM *t;

	      Use this function to free an Erlang term.

       void erl_free_compound(t)

	      Types  ETERM *t;

	      Normally it is the programmer's responsibility to free each Erlang term that has been returned from any of the  erl_interface  func-
	      tions.  However  since  many of the functions that build new Erlang terms in fact share objects with other existing terms, it may be
	      difficult for the programmer to maintain pointers to all such terms in order to free them individually.

	      erl_free_compound() will recursively free all of the sub-terms associated with a given Erlang term, regardless  of  whether  we  are
	      still holding pointers to the sub-terms.

	      There is an example in the User Manual under "Building Terms and Patterns"

       void erl_malloc(size)

	      Types  long size;

	      This function calls the standard malloc() function.

       void erl_free(ptr)

	      Types  void *ptr;

	      This function calls the standard free() function.

Ericsson AB							erl_interface 3.7.3						  erl_malloc(3erl)

erl_global(3erl)						C Library Functions						  erl_global(3erl)

NAME

       erl_global - Access globally registered names

DESCRIPTION

       This module provides support for registering, looking up and unregistering names in the Erlang Global module. For more information, see the
       description of Global in the reference manual.

       Note that the functions below perform an RPC using an open file descriptor provided by the caller. This file descriptor must  not  be  used
       for other traffic during the global operation or the function may receive unexpected data and fail.

EXPORTS

       char ** erl_global_names(fd,count)

	      Types  int fd;
		     int *count;

	      Retrieve a list of all known global names.

	      fd is an open descriptor to an Erlang connection.

	      count is the address of an integer, or NULL. If count is not NULL, it will be set by the function to the number of names found.

	      On  success,  the  function  returns  an array of strings, each containing a single registered name, and sets count to the number of
	      names found. The array is terminated by a single NULL pointer. On failure, the function returns NULL and count is not modified.

   Note:
       It is the caller's responsibility to free the array afterwards. It has been allocated by the function with a single call to malloc() , so a
       single free() is all that is necessary.

       int erl_global_register(fd,name,pid)

	      Types  int fd;
		     const char *name;
		     ETERM *pid;

	      This function registers a name in Global.

	      fd is an open descriptor to an Erlang connection.

	      name is the name to register in Global.

	      pid  is  the pid that should be associated with name . This is the value that Global will return when processes request the location
	      of name .

	      The function returns 0 on success, or -1 on failure.

       int erl_global_unregister(fd,name)

	      Types  int fd;
		     const char *name;

	      This function unregisters a name from Global.

	      fd is an open descriptor to an Erlang connection.

	      name is the name to unregister from Global.

	      The function returns 0 on success, or -1 on failure.

       ETERM * erl_global_whereis(fd,name,node)

	      Types  int fd;
		     const char *name;
		     char *node;

	      fd is an open descriptor to an Erlang connection.

	      name is the name that is to be looked up in Global.

	      If node is not NULL, it is a pointer to a buffer where the function can fill in the name of the node where name is found.  node  can
	      be passed directly to erl_connect() if necessary.

	      On  success,  the function returns an Erlang Pid containing the address of the given name, and node will be initialized to the node-
	      name where name is found. On failure NULL will be returned and node will not be modified.

Ericsson AB							erl_interface 3.7.3						  erl_global(3erl)