Go to main content

man pages section 3: Extended Library Functions, Volume 1

Exit Print View

Updated: Wednesday, July 27, 2022
 
 

memsup (3erl)

Name

memsup - A Memory Supervisor Process

Synopsis

Please see following description for synopsis

Description

memsup(3)                  Erlang Module Definition                  memsup(3)



NAME
       memsup - A Memory Supervisor Process

DESCRIPTION
       memsup  is  a  process which supervises the memory usage for the system
       and for individual processes. It is part of the OS_Mon application, see
       os_mon(6). Available for Unix and Windows.

       Periodically performs a memory check:

         * If  more  than a certain amount of available system memory is allo-
           cated, as reported by the underlying operating  system,  the  alarm
           {system_memory_high_watermark, []} is set.

         * If  any  Erlang process Pid in the system has allocated more than a
           certain amount of total  system  memory,  the  alarm  {process_mem-
           ory_high_watermark, Pid} is set.

       Alarms are reported to the SASL alarm handler, see alarm_handler(3). To
       set an alarm, alarm_handler:set_alarm(Alarm) is called where  Alarm  is
       either of the alarms specified above.

       The  alarms are cleared automatically when the alarm cause is no longer
       valid.

       The function get_memory_data() can be used to retrieve  the  result  of
       the latest periodic memory check.

       There  is  also  a  interface to system dependent memory data, get_sys-
       tem_memory_data(). The result is highly  dependent  on  the  underlying
       operating  system  and  the interface is targeted primarily for systems
       without virtual memory. However, the output on other systems  is  still
       valid, although sparse.

       A  call  to  get_system_memory_data/0  is  more  costly  than a call to
       get_memory_data/0 as data is collected synchronously when this function
       is called.

       The  total  system memory reported under UNIX is the number of physical
       pages of memory times the page size, and the available  memory  is  the
       number  of available physical pages times the page size. This is a rea-
       sonable measure as swapping should be avoided anyway, but the  task  of
       defining total memory and available memory is difficult because of vir-
       tual memory and swapping.

CONFIGURATION
       The following configuration  parameters  can  be  used  to  change  the
       default values for time intervals and thresholds:

         memory_check_interval = int()>0:
           The  time  interval, in minutes, for the periodic memory check. The
           default is one minute.

         system_memory_high_watermark = float():
           The threshold, as percentage of system memory, for how much  system
           memory  can be allocated before the corresponding alarm is set. The
           default is 0.80 (80%).

         process_memory_high_watermark = float():
           The threshold, as percentage of system memory, for how much  system
           memory  can  be  allocated  by one Erlang process before the corre-
           sponding alarm is set. The default is 0.05 (5%).

         memsup_helper_timeout = int()>0:
           A timeout, in seconds, for how long the memsup process should  wait
           for a result from a memory check. If the timeout expires, a warning
           message "OS_MON (memsup) timeout" is issued  via  error_logger  and
           any  pending,  synchronous  client calls will return a dummy value.
           Normally, this situation should not occur. There have been cases on
           Linux,  however,  where  the  pseudo file from which system data is
           read is temporarily unavailable when the system is heavily loaded.

           The default is 30 seconds.

         memsup_system_only = bool():
           Specifies whether the memsup process should only check system  mem-
           ory  usage (true) or not. The default is false, meaning that infor-
           mation regarding both system memory usage and Erlang process memory
           usage is collected.

           It  is  recommended  to set this parameter to false on systems with
           many concurrent processes, as each process  memory  check  makes  a
           traversal of the entire list of processes.

       See config(4) for information about how to change the value of configu-
       ration parameters.

EXPORTS
       get_memory_data() -> {Total,Allocated,Worst}

              Types:

                 Total = Allocated = int()
                 Worst = {Pid, PidAllocated} | undefined
                  Pid = pid()
                  PidAllocated = int()

              Returns the result of the latest memory check,  where  Total  is
              the  total  memory size and Allocated the allocated memory size,
              in bytes.

              Worst is the pid and number of allocated bytes  of  the  largest
              Erlang process on the node. If memsup should not collect process
              data, that is if the configuration parameter  memsup_system_only
              was set to true, Worst is undefined.

              The  function is normally asynchronous in the sense that it does
              not invoke a memory check,  but  returns  the  latest  available
              value.  The  one exception if is the function is called before a
              first memory check is finished, in which case it does not return
              a value until the memory check is finished.

              Returns  {0,0,{pid(),0}}  or  {0,0,undefined}  if  memsup is not
              available, or if all memory checks so far have timed out.

       get_system_memory_data() -> MemDataList

              Types:

                 MemDataList = [{Tag, Size}]
                  Tag = atom()
                  Size = int()

              Invokes a memory check and returns the resulting, system  depen-
              dent,  data  as a list of tagged tuples, where Tag currently can
              be one of the following:

                total_memory:
                  The total amount of memory available to the Erlang emulator,
                  allocated and free. May or may not be equal to the amount of
                  memory configured in the system.

                available_memory:
                  Informs about  the  amount  memory  that  is  available  for
                  increased  usage  if there is an increased memory need. This
                  value is not based on a calculation of  the  other  provided
                  values  and should give a better value of the amount of mem-
                  ory that actually is  available  than  calculating  a  value
                  based  on the other values reported. This value is currently
                  only present on newer Linux kernels. If this  value  is  not
                  available  on  Linux,  you can use the sum of cached_memory,
                  buffered_memory, and free_memory as an approximation.

                free_memory:
                  The amount of free memory available to the  Erlang  emulator
                  for allocation.

                system_total_memory:
                  The  amount  of memory available to the whole operating sys-
                  tem. This may well be equal to total_memory but  not  neces-
                  sarily.

                buffered_memory:
                   The  amount of memory the system uses for temporary storing
                  raw disk blocks.

                cached_memory:
                   The amount of memory the system uses for cached files  read
                  from  disk.  On  Linux, also memory marked as reclaimable in
                  the kernel slab allocator will be added to this value.

                total_swap:
                   The amount of total amount of memory the system has  avail-
                  able for disk swap.

                free_swap:
                   The  amount  of  memory  the  system has available for disk
                  swap.

          Note:
              Note that new tagged tuples may be introduced in the  result  at
              any time without prior notice


              Note that the order of the tuples in the resulting list is unde-
              fined and may change at any time.

              All memory sizes are presented as number of bytes.

              Returns the empty list [] if memsup is not available, or if  the
              memory check times out.

       get_os_wordsize() -> Wordsize

              Types:

                 Wordsize = 32 | 64 | unsupported_os

              Returns the wordsize of the current running operating system.

       get_check_interval() -> MS

              Types:

                 MS = int()

              Returns  the  time  interval,  in milliseconds, for the periodic
              memory check.

       set_check_interval(Minutes) -> ok

              Types:

                 Minutes = int()>0

              Changes the time interval, given in minutes,  for  the  periodic
              memory check.

              The  change  will take effect after the next memory check and is
              non-persistent. That is, in case  of  a  process  restart,  this
              value  is forgotten and the default value will be used. See Con-
              figuration above.

       get_procmem_high_watermark() -> int()

              Returns the threshold, in percent, for  process  memory  alloca-
              tion.

       set_procmem_high_watermark(Float) -> ok

              Changes  the  threshold,  given  as  a float, for process memory
              allocation.

              The change will take effect  during  the  next  periodic  memory
              check  and  is  non-persistent.  That  is,  in case of a process
              restart, this value is forgotten and the default value  will  be
              used. See Configuration above.

       get_sysmem_high_watermark() -> int()

              Returns the threshold, in percent, for system memory allocation.

       set_sysmem_high_watermark(Float) -> ok

              Changes the threshold, given as a float, for system memory allo-
              cation.

              The change will take effect  during  the  next  periodic  memory
              check  and  is  non-persistent.  That  is,  in case of a process
              restart, this value is forgotten and the default value  will  be
              used. See Configuration above.

       get_helper_timeout() -> Seconds

              Types:

                 Seconds = int()

              Returns the timeout value, in seconds, for memory checks.

       set_helper_timeout(Seconds) -> ok

              Types:

                 Seconds = int() (>= 1)

              Changes the timeout value, given in seconds, for memory checks.

              The  change  will  take  effect for the next memory check and is
              non-persistent. That is, in the case of a process restart,  this
              value  is forgotten and the default value will be used. See Con-
              figuration above.

SEE ALSO
       alarm_handler(3), os_mon(3)



Ericsson AB                      os_mon 2.7.1                        memsup(3)