
  -spec erlang:system_flag(time_offset, finalize) -> OldState
                              when
                                  OldState ::
                                      preliminary | final | volatile.

Since:
  OTP 18.0

  -spec erlang:system_flag(multi_scheduling, BlockState) -> OldBlockState
                              when
                                  BlockState ::
                                      block | unblock | block_normal |
                                      unblock_normal,
                                  OldBlockState ::
                                      blocked | disabled | enabled.

  -spec erlang:system_flag(fullsweep_after, Number) -> OldNumber
                              when
                                  Number :: non_neg_integer(),
                                  OldNumber :: non_neg_integer().

  -spec erlang:system_flag(erts_alloc, {Alloc, F, V}) -> ok | notsup
                              when
                                  Alloc :: atom(),
                                  F :: atom(),
                                  V :: integer().

Since:
  OTP 20.2.3

  -spec erlang:system_flag(min_bin_vheap_size, MinBinVHeapSize) ->
                              OldMinBinVHeapSize
                              when
                                  MinBinVHeapSize :: non_neg_integer(),
                                  OldMinBinVHeapSize :: non_neg_integer().

Since:
  OTP R13B04

  -spec erlang:system_flag(min_heap_size, MinHeapSize) -> OldMinHeapSize
                              when
                                  MinHeapSize :: non_neg_integer(),
                                  OldMinHeapSize :: non_neg_integer().

  -spec erlang:system_flag(backtrace_depth, Depth) -> OldDepth
                              when
                                  Depth :: non_neg_integer(),
                                  OldDepth :: non_neg_integer().

  -spec erlang:system_flag(dirty_cpu_schedulers_online,
                           DirtyCPUSchedulersOnline) ->
                              OldDirtyCPUSchedulersOnline
                              when
                                  DirtyCPUSchedulersOnline ::
                                      pos_integer(),
                                  OldDirtyCPUSchedulersOnline ::
                                      pos_integer().

Since:
  OTP 17.0

  -spec erlang:system_flag(schedulers_online, SchedulersOnline) ->
                              OldSchedulersOnline
                              when
                                  SchedulersOnline :: pos_integer(),
                                  OldSchedulersOnline :: pos_integer().

  -spec erlang:system_flag(system_logger, Logger) -> PrevLogger
                              when
                                  Logger :: logger | undefined | pid(),
                                  PrevLogger :: logger | undefined | pid().

Since:
  OTP 21.3

  -spec erlang:system_flag(trace_control_word, TCW) -> OldTCW
                              when
                                  TCW :: non_neg_integer(),
                                  OldTCW :: non_neg_integer().

  -spec erlang:system_flag(scheduler_wall_time, Boolean) -> OldBoolean
                              when
                                  Boolean :: boolean(),
                                  OldBoolean :: boolean().

Since:
  OTP R15B01

  -spec erlang:system_flag(microstate_accounting, Action) -> OldState
                              when
                                  Action :: true | false | reset,
                                  OldState :: true | false.

Since:
  OTP 19.0

  -spec erlang:system_flag(cpu_topology, CpuTopology) -> OldCpuTopology
                              when
                                  CpuTopology :: cpu_topology(),
                                  OldCpuTopology :: cpu_topology().

  -spec erlang:system_flag(max_heap_size, MaxHeapSize) -> OldMaxHeapSize
                              when
                                  MaxHeapSize :: max_heap_size(),
                                  OldMaxHeapSize :: max_heap_size().

Since:
  OTP 19.0

  -spec erlang:system_flag(scheduler_bind_type, How) -> OldBindType
                              when
                                  How ::
                                      scheduler_bind_type() | default_bind,
                                  OldBindType :: scheduler_bind_type().

  Types:
    -type scheduler_bind_type() ::
          no_node_processor_spread | no_node_thread_spread | no_spread |
          processor_spread | spread | thread_spread |
          thread_no_node_processor_spread | unbound.

  Warning:
    This argument is deprecated. Instead of using this argument,
    use command-line argument +sbt in erl(1). When this
    argument is removed, a final scheduler bind type to use is
    determined at emulator boot time.

  Controls if and how schedulers are bound to logical processors.

  When erlang:system_flag(scheduler_bind_type, How) is called, an
  asynchronous signal is sent to all schedulers online, causing them
  to try to bind or unbind as requested.

  Note:
    If a scheduler fails to bind, this is often silently ignored,
    as it is not always possible to verify valid logical processor
    identifiers. If an error is reported, an error event is
    logged. To verify that the schedulers have bound as requested,
    call erlang:system_info(scheduler_bindings).

  Schedulers can be bound on newer Linux, Solaris, FreeBSD, and
  Windows systems, but more systems will be supported in future
  releases.

  In order for the runtime system to be able to bind schedulers, the
  CPU topology must be known. If the runtime system fails to detect
  the CPU topology automatically, it can be defined. For more
  information on how to define the CPU topology, see command-line
  flag +sct in erl(1).

  The runtime system does by default not bind schedulers to
  logical processors.

  Note:
    If the Erlang runtime system is the only OS process binding
    threads to logical processors, this improves the performance
    of the runtime system. However, if other OS processes (for
    example, another Erlang runtime system) also bind threads to
    logical processors, there can be a performance penalty
    instead. Sometimes this performance penalty can be severe. If
    so, it is recommended to not bind the schedulers.

  Schedulers can be bound in different ways. Argument How
  determines how schedulers are bound and can be any of the
  following:

  unbound:
    Same as command-line argument +sbt u in erl(1).

  no_spread:
    Same as command-line argument +sbt ns in erl(1).

  thread_spread:
    Same as command-line argument +sbt ts in erl(1).

  processor_spread:
    Same as command-line argument +sbt ps in erl(1).

  spread:
    Same as command-line argument +sbt s in erl(1).

  no_node_thread_spread:
    Same as command-line argument +sbt nnts in erl(1).

  no_node_processor_spread:
    Same as command-line argument +sbt nnps in erl(1).

  thread_no_node_processor_spread:
    Same as command-line argument +sbt tnnps in erl(1).

  default_bind:
    Same as command-line argument +sbt db in erl(1).

  The returned value equals How before flag scheduler_bind_type
  was changed.

  Failures:

  notsup:
    If binding of schedulers is not supported.

  badarg:
    If How is not one of the documented alternatives.

  badarg:
    If CPU topology information is unavailable.

  The scheduler bind type can also be set by passing command-line
  argument +sbt to erl(1).

  For more information, see erlang:system_info(scheduler_bind_type), 
  erlang:system_info(scheduler_bindings), as well as command-line
  flags +sbt and +sct in erl(1).
