-compile( [ native, { hipe, o3 } ] ).
-compile( [ inline, { inline_size, 100 } ] ).

Ulf Wiger

It was mentioned in another post that pattern-matching is atomic in the VM. That's correct — the VM will not schedule another process while inside a pattern match (except, of course, in the SMP version, where other schedulers might).

В другом сообщении было отмечено, что сопоставление с образцом является атомарной операцией в VM. Так и есть — VM не будет планировать выполнение других процессов, пока производится выполнение сопоставления(за исключением версии SMP, в которой другие планировщики могут продолжать работу)

К>А теперь отвечаем: откуда в эрланге ссылки?

using System;
using System.Console;
using Nemerle.Utility;

module Program
{
    variant Tree
    {
        | Nil
        | Node { l : Tree; r : Tree; }
        public Size : int
        {
            get
            {
                match (this)
                {
                | Nil => 1;
                | Node(l, r) => 1 + l.Size + r.Size;
                }
            }
        }
    }
    Main() : void
    {
        def next(t : Tree) : Tree
        {
            WriteLine(t.Size);
            Tree.Node(t, t);
        }
        def t : Tree = Tree.Nil();
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        def t = next(t);
        _ = ReadKey();
    }
}

WH>Там не 50К списков из 50К элементов, а 50К ссылок на один список из 50К элементов

Eshell V5.5.2  (abort with ^G)
1> lists:duplicate(5,lists:seq(1,5)).
[[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5],[1,2,3,4,5]]

$ erl
Erlang (BEAM) emulator version 5.5.2 [source] [async-threads:0] [kernel-poll:false]

Eshell V5.5.2  (abort with ^G)
1> N=50000, A=lists:duplicate(N,lists:seq(1,N)).

Crash dump was written to: erl_crash.dump
eheap_alloc: Cannot reallocate 2501920024 bytes of memory (of type "heap").
Aborted

1> N=5000, A=lists:duplicate(N,lists:seq(1,N)), L=lists:last(lists:last(A)). 
5000

1> N=50000, A=lists:duplicate(N,lists:seq(1,N)), L=lists:last(lists:last(A)).

Crash dump was written to: erl_crash.dump
eheap_alloc: Cannot reallocate 3480006320 bytes of memory (of type "heap").


Abnormal termination

1>> N=5000, A=lists:duplicate(N,lists:seq(1,N)), L=lists:last(lists:last(A)). 
G>5000
G>

-module(test).
-export([chk/1]).
chk(N)-> A=lists:duplicate(N,lists:seq(1,N)), lists:last(lists:last(A)).

1>> N=5000, A=lists:duplicate(N,lists:seq(1,N)), L=lists:last(lists:last(A)). 
G>5000
G>

A good start when programming efficiently is to have knowledge about how much memory different data types and operations require. It is implementation-dependent how much memory the Erlang data types and other items consume, but here are some figures for erts-5.2 system (OTP release R9B). (There have been no significant changes in R12B.)

The unit of measurement is memory words. There exists both a 32-bit and a 64-bit implementation, and a word is therefore, 4 bytes or 8 bytes, respectively.

Memory size of different data types
Data type Memory size
Integer (-16#7FFFFFF < i <16#7FFFFFF) 1 word
Integer (big numbers) 3..N words
Atom 1 word. Note: an atom refers into an atom table which also consumes memory. The atom text is stored once for each unique atom in this table. The atom table is not garbage-collected.
Float On 32-bit architectures: 4 words
On 64-bit architectures: 3 words
Binary 3..6 + data (can be shared)
List 1 word per element + the size of each element
String (is the same as a list of integers) 2 words per character
Tuple 2 words + the size of each element
Pid 1 word for a process identifier from the current local node, and 5 words for a process identifier from another node. Note: a process identifier refers into a process table and a node table which also consumes memory.
Port 1 word for a port identifier from the current local node, and 5 words for a port identifier from another node. Note: a port identifier refers into a port table and a node table which also consumes memory.
Reference On 32-bit architectures: 5 words for a reference from the current local node, and 7 words for a reference from another node.
On 64-bit architectures: 4 words for a reference from the current local node, and 6 words for a reference from another node. Note: a reference refers into a node table which also consumes memory.
Fun 9..13 words + size of environment. Note: a fun refers into a fun table which also consumes memory.
Ets table Initially 768 words + the size of each element (6 words + size of Erlang data). The table will grow when necessary.
Erlang process 327 words when spawned including a heap of 233 words.