To let a callback module decide whether or to receive another message
from the peer, so that backpressure can be applied when it's
inappropriate. This is to let a callback protect against reading more
than can be processed, which is otherwise possible since diameter_tcp
otherwise always asks for more.

A callback is made after each message, and can answer to continue
reading or to ask again after a timeout. It's each message instead of
each packet partly for simplicity, but also since this should be
sufficiently fine-grained. Per packet would require some interaction
with the fragment timer that flushes partial messages that haven't been
completely received.

The callback is now applied to the atom 'false' when asking if another
message should be received on the socket, and to a received binary
message after reception. Throttling on received messages makes it
possible to distinguish between requests and answers.

There is no callback on outgoing messages since these don't have to go
through the transport process, even if they currently do.

In addition to returning ok or {timeout, Tmo}, let a throttling callback
for message reception return a pid(), which is then notified if the
message in question is either discarded or results in a request process.
Notification is by way of messages of the form

  {diameter, discard | {request, pid()}}

where the pid is that of a request process resulting from the received
message. This allows the notification process to keep track of the
maximum number of request processes a peer connection can have given
rise to.

This can be used as a simple form of overload protection, discarding the
message before it's passed into diameter to become one more request
process in a flood. Replying with 3004 would be more appropriate when
the request has been directed at a specific server (the RFC's
requirement) however, and possibly it should be possible for a callback
to do this as well.

As discussed in the parent commit. This is easier said than done in
practice, but there's no harm in allowing it.

TCP packets can contain more than one message, so only ask to receive
another message if it hasn't already been received.

In particular, let a callback decide when to receive the initial
message.

By sending {diameter, {answer, pid()}} when an incoming answer is sent
to the specified pid, instead of a discard message as previously. The
latter now literally means that the message has been discarded.

That is, don't assume that it's only diameter_tcp doing so: allow it to
be received when not throttling. This lets a callback module trigger a
new throttling callback itself, but it's not clear if this will be
useful in practice.

called 'literal_mmap' and 'exec_mmap'.

Also moved existing erts_mmap info from 'mseg_alloc'
to its own system_info({allocator, erts_mmap})

with "allocators" default_mmap, literal_mmap and exec_mmap.

from {allocator,mseg_alloc} to {allocator,erts_mmap}

erlang:system_info(allocator) ->
  {Allocator, Version, Features, Settings}

Features includes 'literal_mmap' and/or 'exec_mmap'
if they exist.

to the Settings list

{Allocator, Version, Features, Settings}

will now return

[{instance,0,[{segments_size,9961472,9961472,11010048}]},
 {instance,1,[{segments_size,6291456,6291456,6815744}]},
 {instance,2,[{segments_size,524288,524288,786432}]},
 {instance,3,[{segments_size,1048576,1048576,1835008}]},
 {instance,4,[{segments_size,0,0,262144}]}]

and not just empty lists.

Orphaned in commit 9298872.

by (only) moving around stuff in the file.

in order to make it easier to ifdef away
all erts_mmap_* if not supported.

and make erts_mmap unavailable at compile time
if not supported.

This one:

    diameter_tcp.erl:928: (call)
    The call diameter_tcp:throttle({'timeout',_},#transport{socket::port() | {'sslsocket',_,_},parent::pid(),module::atom(),frag::binary() | {non_neg_integer(),non_neg_integer(),binary(),[binary()]},ssl::boolean() | [any()],timeout::'infinity' | non_neg_integer(),tref::'false' | reference(),flush::boolean(),throttle_cb::'false' | fun() | maybe_improper_list(fun() | maybe_improper_list(any(),[any()]) | {atom(),atom(),[any()]},[any()]) | {atom(),atom(),[any()]},throttled::'true' | binary()})
    will never return since it differs in the 1st argument from the
success typing arguments:

    ('discard' | 'ok' | binary() | pid() | {'discard' | 'ok' | binary() | pid(),'false' | fun() | [fun() | [any()] | {atom(),atom(),[any()]}] | {atom(),atom(),[any()]}},#transport{socket::port() | {'sslsocket',_,_},parent::pid(),module::atom(),frag::binary() | {non_neg_integer(),non_neg_integer(),binary(),[binary()]},ssl::boolean() | [any()],timeout::'infinity' | non_neg_integer(),tref::'false' | reference(),flush::boolean(),throttle_cb::'false' | fun() | [fun() | [any()] | {atom(),atom(),[any()]}] | {atom(),atom(),[any()]},throttled::binary()})

It's true that the clause doesn't return, because of the throw, and
that's the intention.

as is trips up my editor symbol tagging.

with uppercase for constants
and why not call them 'RESTART' and 'PAUSE' as the API.

for enable_trace and disable_trace operations.

Instead seize needed locks while updating trace flags.

and non-call-trace.

This is the easy way out to avoid difficult locking
scenarios when accessing tracing flags on another process.

All 'EXIT' and monitor messages are sent from 'system'

Timeouts are "sent" from 'clock_service'

also simplified the interface to to run PAM from trace

'on_load' is a call trace.

to obtain match specs

To set/clear match specs for send and receive trace.

'e' for Event as we might want to add match specs
for other trace events (proc exit,link,ulink,...).

i.e enable all send/receive trace.

To return information about a single peer_ref(), to avoid having to
retrieve more than is needed with service_info/2.

To return a peer_fsm/transport pair given one of them.

…into raimo/polish-gen_statem/OTP-13065

Conflicts:
	lib/stdlib/doc/src/gen_statem.xml

* raimo/polish-gen_statem/OTP-13065:
  Fix all seealso and other minor changes
  Editorial update

new protocol version to handle new schema fields

Should maybe be moved to mnesia.erl and inlined??
Or is it used elsewhere?

Add ext to table/system information
Add add_backend_type

Make ram_copies index always use ordered_set

And use index type as prefered type not a implementation requirement,
the standard implmentation will currently ignore the prefered type.

…orary processes

Tables or data containers should be owned and monitored by mnesia_monitor and
should thus be created by that process.

Always create_table before loading it

We need to create tables for ram_copies at least before loading
them as they are intermittent. It is also needed to get mnesia
monitor as the parent and supervisor of the data storage.

Minimal impact when talking to older nodes.

* dgud/mnesia/ext-backend/PR-858/OTP-13058:
  mnesia_ext: Add basic backend extension tests
  mnesia_ext: reuse snmp field for ext updates
  mnesia_ext: Create table/data containers from mnesia monitor not temporary processes
  mnesia_ext: Implement ext copies index
  mnesia_ext: Load table ext
  mnesia_ext: Dumper and schema changes
  mnesia_ext: Refactor mnesia_schema.erl
  mnesia_ext: Ext support in fragmented tables
  mnesia_ext: Backup handling
  mnesia_ext: Create schema functionality
  mnesia_ext: Add ext copies and db_fold to low level api
  mnesia_ext: Refactor record_validation code
  mnesia_ext: Add create_external and increase protocol version to monitor
  mnesia_ext: Add ext copies to records
  mnesia_ext: Add supervisor and behaviour modules

* anders/diameter/test/OTP-13438:
  Don't assume list comprehension evaluation order

* anders/diameter/overload/OTP-13330:
  Suppress dialyzer warning
  Remove dead case clause
  Let throttling callback send a throttle message
  Acknowledge answers to notification pids when throttling
  Throttle properly with TLS
  Don't ask throttling callback to receive more unless needed
  Let a throttling callback answer a received message
  Let a throttling callback discard a received message
  Let throttling callback return a notification pid
  Make throttling callbacks on message reception
  Add diameter_tcp option throttle_cb

* anders/diameter/info/OTP-13508:
  Add diameter:peer_find/1
  Add diameter:peer_info/1

d5f8d55

The max_heap_size process flag can be used to limit the
growth of a process heap by killing it before it becomes
too large to handle. It is possible to set the maximum
using the `erl +hmax` option, `system_flag(max_heap_size, ...)`,
`spawn_opt(Fun, [{max_heap_size, ...}])` and
`process_flag(max_heap_size, ...)`.

It is possible to configure the behaviour of the process
when the maximum heap size is reached. The process may be
sent an untrappable exit signal with reason kill and/or
send an error_logger message with details on the process
state. A new trace event called gc_max_heap_size is
also triggered for the garbage_collection trace flag
when the heap grows larger than the configured size.

If kill and error_logger are disabled, it is still
possible to see that the maximum has been reached by
doing garbage collection tracing on the process.

The heap size is defined as the sum of the heap memory
that the process is currently using. This includes
all generational heaps, the stack, any messages that
are considered to be part of the heap and any extra
memory the garbage collector may need during collection.

In the current implementation this means that when a process
is set using on_heap message queue data mode, the messages
that are in the internal message queue are counted towards
this value. For off_heap, only matched messages count towards
the size of the heap. For mixed, it depends on race conditions
within the VM whether a message is part of the heap or not.

Below is an example run of the new behaviour:

Eshell V8.0  (abort with ^G)
1> f(P),P = spawn_opt(fun() -> receive ok -> ok end end, [{max_heap_size, 512}]).
<0.60.0>
2> erlang:trace(P, true, [garbage_collection, procs]).
1
3> [P ! lists:duplicate(M,M) || M <- lists:seq(1,15)],ok.
ok
4>
=ERROR REPORT==== 26-Apr-2016::16:25:10 ===
     Process:          <0.60.0>
     Context:          maximum heap size reached
     Max heap size:    512
     Total heap size:  723
     Kill:             true
     Error Logger:     true
     GC Info:          [{old_heap_block_size,0},
                        {heap_block_size,609},
                        {mbuf_size,145},
                        {recent_size,0},
                        {stack_size,9},
                        {old_heap_size,0},
                        {heap_size,211},
                        {bin_vheap_size,0},
                        {bin_vheap_block_size,46422},
                        {bin_old_vheap_size,0},
                        {bin_old_vheap_block_size,46422}]
flush().
Shell got {trace,<0.60.0>,gc_start,
                 [{old_heap_block_size,0},
                  {heap_block_size,233},
                  {mbuf_size,145},
                  {recent_size,0},
                  {stack_size,9},
                  {old_heap_size,0},
                  {heap_size,211},
                  {bin_vheap_size,0},
                  {bin_vheap_block_size,46422},
                  {bin_old_vheap_size,0},
                  {bin_old_vheap_block_size,46422}]}
Shell got {trace,<0.60.0>,gc_max_heap_size,
                 [{old_heap_block_size,0},
                  {heap_block_size,609},
                  {mbuf_size,145},
                  {recent_size,0},
                  {stack_size,9},
                  {old_heap_size,0},
                  {heap_size,211},
                  {bin_vheap_size,0},
                  {bin_vheap_block_size,46422},
                  {bin_old_vheap_size,0},
                  {bin_old_vheap_block_size,46422}]}
Shell got {trace,<0.60.0>,exit,killed}