
  -spec erlang:system_info(allocated_areas) -> [tuple()];
                          (allocator) ->
                              {Allocator, Version, Features, Settings}
                              when
                                  Allocator :: undefined | glibc,
                                  Version :: [non_neg_integer()],
                                  Features :: [atom()],
                                  Settings ::
                                      [{Subsystem :: atom(),
                                        [{Parameter :: atom(),
                                          Value :: term()}]}];
                          ({allocator, Alloc}) -> [_] when Alloc :: atom();
                          (alloc_util_allocators) -> [Alloc]
                              when Alloc :: atom();
                          ({allocator_sizes, Alloc}) -> [_]
                              when Alloc :: atom().

  -spec erlang:system_info(creation) -> integer();
                          (delayed_node_table_gc) ->
                              infinity | non_neg_integer();
                          (dist) -> binary();
                          (dist_buf_busy_limit) -> non_neg_integer();
                          (dist_ctrl) ->
                              {Node :: node(),
                               ControllingEntity :: port() | pid()}.

Since:
  OTP 18.0,OTP R14B01

  -spec erlang:system_info(atom_count) -> pos_integer();
                          (atom_limit) -> pos_integer();
                          (ets_count) -> pos_integer();
                          (ets_limit) -> pos_integer();
                          (port_count) -> non_neg_integer();
                          (port_limit) -> pos_integer();
                          (process_count) -> pos_integer();
                          (process_limit) -> pos_integer().

Since:
  OTP 20.0,OTP 21.1,OTP R16B,OTP R16B03

  -spec erlang:system_info(c_compiler_used) -> {atom(), term()};
                          (check_io) -> [_];
                          (compat_rel) -> integer();
                          (debug_compiled) -> boolean();
                          (driver_version) -> string();
                          (dynamic_trace) -> none | dtrace | systemtap;
                          (dynamic_trace_probes) -> boolean();
                          (emu_flavor) -> emu | jit;
                          (emu_type) ->
                              opt | debug | gcov | valgrind | gprof |
                              lcnt | frmptr;
                          (info) -> binary();
                          (kernel_poll) -> boolean();
                          (loaded) -> binary();
                          (machine) -> string();
                          (modified_timing_level) -> integer() | undefined;
                          (nif_version) -> string();
                          (otp_release) -> string();
                          (port_parallelism) -> boolean();
                          (system_architecture) -> string();
                          (system_logger) -> logger | undefined | pid();
                          (system_version) -> string();
                          (trace_control_word) -> non_neg_integer();
                          (version) -> string();
                          (wordsize |
                           {wordsize, internal} |
                           {wordsize, external}) ->
                              4 | 8.

Since:
  OTP 17.4,OTP 21.3,OTP 24.0,OTP R15B01,OTP R16B

  -spec erlang:system_info(dirty_cpu_schedulers) -> non_neg_integer();
                          (dirty_cpu_schedulers_online) ->
                              non_neg_integer();
                          (dirty_io_schedulers) -> non_neg_integer();
                          (multi_scheduling) ->
                              disabled | blocked | blocked_normal |
                              enabled;
                          (multi_scheduling_blockers) -> [Pid :: pid()];
                          (normal_multi_scheduling_blockers) ->
                              [Pid :: pid()];
                          (scheduler_bind_type) ->
                              spread | processor_spread | thread_spread |
                              thread_no_node_processor_spread |
                              no_node_processor_spread |
                              no_node_thread_spread | no_spread | unbound;
                          (scheduler_bindings) -> tuple();
                          (scheduler_id) -> SchedulerId :: pos_integer();
                          (schedulers | schedulers_online) ->
                              pos_integer();
                          (smp_support) -> boolean();
                          (threads) -> boolean();
                          (thread_pool_size) -> non_neg_integer().

Since:
  OTP 17.0,OTP 19.0

  -spec erlang:system_info(end_time) -> non_neg_integer();
                          (os_monotonic_time_source) -> [{atom(), term()}];
                          (os_system_time_source) -> [{atom(), term()}];
                          (start_time) -> integer();
                          (time_correction) -> true | false;
                          (time_offset) -> preliminary | final | volatile;
                          (time_warp_mode) ->
                              no_time_warp | single_time_warp |
                              multi_time_warp;
                          (tolerant_timeofday) -> enabled | disabled.

Since:
  OTP 17.1,OTP 18.0

  -spec erlang:system_info(version) -> string().

  -spec erlang:system_info(cpu_topology) -> CpuTopology
                              when CpuTopology :: cpu_topology();
                          ({cpu_topology, defined | detected | used}) ->
                              CpuTopology
                              when CpuTopology :: cpu_topology();
                          (logical_processors |
                           logical_processors_available |
                           logical_processors_online) ->
                              unknown | pos_integer();
                          (update_cpu_info) -> changed | unchanged.

Since:
  OTP R14B

  -spec erlang:system_info(fullsweep_after) ->
                              {fullsweep_after, non_neg_integer()};
                          (garbage_collection) -> [{atom(), integer()}];
                          (heap_sizes) -> [non_neg_integer()];
                          (heap_type) -> private;
                          (max_heap_size) ->
                              {max_heap_size,
                               MaxHeapSize :: max_heap_size()};
                          (message_queue_data) -> message_queue_data();
                          (min_heap_size) ->
                              {min_heap_size,
                               MinHeapSize :: pos_integer()};
                          (min_bin_vheap_size) ->
                              {min_bin_vheap_size,
                               MinBinVHeapSize :: pos_integer()};
                          (procs) -> binary().

Since:
  OTP 19.0,OTP R13B04

  Types:
    -type max_heap_size() ::
          Size ::
              non_neg_integer() |
              #{size => non_neg_integer(),
                kill => boolean(),
                error_logger => boolean()}.
    -type message_queue_data() :: off_heap | on_heap.

  Returns information about the default process heap settings:

  fullsweep_after:
    Returns {fullsweep_after, integer() >= 0}, which is the 
    fullsweep_after garbage collection setting used by default.
    For more information, see garbage_collection described
    below.

  garbage_collection:
    Returns a list describing the default garbage collection
    settings. A process spawned on the local node by a spawn or 
    spawn_link uses these garbage collection settings. The
    default settings can be changed by using erlang:system_flag/2. 
    spawn_opt/2,3,4 can spawn a process that does not use the
    default settings.

  heap_sizes:
    Returns a list of integers representing valid heap sizes in
    words. All Erlang heaps are sized from sizes in this list.

  heap_type:
    Returns the heap type used by the current emulator. One heap
    type exists:

    private:
      Each process has a heap reserved for its use and no
      references between heaps of different processes are
      allowed. Messages passed between processes are copied
      between heaps.

  max_heap_size:
    Returns {max_heap_size, MaxHeapSize}, where MaxHeapSize is
    the current system-wide maximum heap size settings for spawned
    processes. This setting can be set using the command-line
    flags +hmax, +hmaxk and +hmaxel in erl(1). It can also
    be changed at runtime using erlang:system_flag(max_heap_size,
    MaxHeapSize). For more details about the max_heap_size
    process flag, see process_flag(max_heap_size, MaxHeapSize).

  message_queue_data:
    Returns the default value of the message_queue_data process
    flag, which can be either off_heap or on_heap. The default
    value is set by the command-line argument +hmqd in erl(1).
    For more information, see the documentation of 
    process_flag(message_queue_data, MQD).

  min_heap_size:
    Returns {min_heap_size, MinHeapSize}, where MinHeapSize is
    the current system-wide minimum heap size for spawned
    processes.

  min_bin_vheap_size:
    Returns {min_bin_vheap_size, MinBinVHeapSize}, where 
    MinBinVHeapSize is the current system-wide minimum binary
    virtual heap size for spawned processes.

  procs:
    Returns a binary containing a string of process and port
    information formatted as in Erlang crash dumps. For more
    information, see section How to interpret the Erlang crash
    dumps in the User's Guide.
