memory.h

Include dependency graph for memory.h:

This graph shows which files directly or indirectly include memory.h:

Defines

HEAP_NEED_GC_SHRINK_THRESHOLD_COEFF 64

MIN_FREE_SPACE_SIZE 16

TYPEDEF_CONTEXT

TYPEDEF_GLOBALCONTEXT

TYPEDEF_HEAP

BEGIN_WITH_STACK_HEAP(size, name)

struct                                \

{                                     \

HeapFragment

*next;               \

union                             \

{                                 \

term mso_list;                \             term

*heap_end;               \

};                                \

term

storage[size];               \

} name##__root__;                     \

Heap name;                            \     memory_init_heap_root_fragment(&name, (HeapFragment *) &(name##__root__), size);

END_WITH_STACK_HEAP(name, global) memory_sweep_mso_list

(name.root->mso_list, global, true); \

if (name.root->next) {                                    \

memory_destroy_heap_fragment

(name.root->next);        \

}

STORAGE_MSO_LIST_INDEX 0

STORAGE_HEAP_START_INDEX 1

Typedefs

typedef struct Context Context

typedef struct GlobalContext GlobalContext

typedef struct HeapFragment HeapFragment

typedef struct Heap Heap

Enums

enum MemoryGCResult

Values:

enumerator MEMORY_GC_OK = 0

enumerator MEMORY_GC_ERROR_FAILED_ALLOCATION = 1

enumerator MEMORY_GC_DENIED_ALLOCATION = 2

enum MemoryAllocMode

Values:

enumerator MEMORY_NO_SHRINK = 0

enumerator MEMORY_CAN_SHRINK = 1

enumerator MEMORY_FORCE_SHRINK = 2

enumerator MEMORY_NO_GC = 3

Functions

void memory_init_heap_root_fragment(Heap *heap, HeapFragment *root, size_t size)

Setup heap from its root. Set the mso_list to NIL and initialize heap_ptr.

Parameters:

• heap – heap to initialize.

• root – fragment root.

• size – capacity of the heap to create, not including the mso_list.

enum MemoryGCResult memory_init_heap(Heap *heap, size_t size)

Initialize a root heap.

This function should be balanced with memory_destroy_heap or memory_destroy_heap_from_task if the heap is created by a driver task.

Parameters:

• heap – heap to initialize.

• size – capacity of the heap to create, not including the mso_list.

Returns:

MEMORY_GC_OK or MEMORY_GC_ERROR_FAILED_ALLOCATION depending on the outcome.

static inline size_t memory_heap_fragment_memory_size(const HeapFragment *fragment)

return the total memory size of a heap fragment and its children.

Parameters:

• fragment – the root fragment to get the size of

Returns:

the size in terms

static inline size_t memory_heap_youngest_size(const Heap *heap)

return the size of the youngest generation of the heap.

in some condition, this function returns the size of a fragment where the stack is not.

Parameters:

• heap – the heap to get the youngest size of

Returns:

the size in terms

static inline size_t memory_heap_memory_size(const Heap *heap)

return the total memory size of a heap, including fragments.

Parameters:

• heap – the heap to get the size of

Returns:

the size in terms

static inline term *memory_heap_alloc(Heap *heap, size_t size)

allocates space for a certain amount of terms on the heap

allocates space for a certain amount of terms on the heap, GC will be performed when needed, any existing term might be invalid after this call.

Parameters:

• heap – heap to initialize.

• size – the amount of terms that will be allocated.

Returns:

a pointer to the newly allocated memory block.

static inline void memory_heap_trim(Heap *heap, size_t size)

shrinks the heap by size units

this function is used when resizing the last item allocated on the heap.

Parameters:

• heap – the heap that will be shrinked

• size – the number of terms that will be removed

term memory_copy_term_tree(Heap *new_heap, term t)

copies a term to a destination heap

deep copies a term to a destination heap, once finished old memory can be freed.

Parameters:

• new_heap – the destination heap where terms will be copied.

• t – term to copy

Returns:

a new term that is stored on the new heap.

enum MemoryGCResult memory_ensure_free_with_roots(Context *ctx, size_t size, size_t num_roots, term *roots, enum MemoryAllocMode alloc_mode)

makes sure that the given context has given free memory.

this function makes sure at least size terms are available. Optionally, it can allocate a fragment or shrink the heap to the specified size, depending on allocation strategy. The function can also be passed roots to update during any garbage collection.

Parameters:

• ctx – the target context.

• size – needed available memory.

• num_roots – number of roots

• roots – roots to preserve

• alloc_mode – constraint on allocation of additional memory

static inline enum MemoryGCResult memory_ensure_free_opt(Context *ctx, size_t size, enum MemoryAllocMode alloc_mode)

makes sure that the given context has given free memory.

this function makes sure at least size terms are available. Optionally, it can shrink the heap to the specified size, depending on allocation strategy.

Parameters:

• ctx – the target context.

• size – needed available memory.

• alloc_mode – constraint on allocation of additional memory

static inline enum MemoryGCResult memory_ensure_free(Context *ctx, size_t size)

makes sure that the given context has given free memory

this function makes sure that at least size terms are available, when not available gc will be performed, any existing term might be invalid after this call. It does not shrink the heap, so if this function is called with a given value N and it is later called with a smaller value n, the actual amount of available free memory is N.

Parameters:

• ctx – the target context.

• size – needed available memory.

enum MemoryGCResult memory_erl_nif_env_ensure_free(ErlNifEnv *env, size_t size)

makes sure that the given nif environment has given free memory

this function makes sure that at least size terms are available. When not available, a new fragment will be allocated.

Parameters:

• env – the target environment.

• size – needed available memory.

term memory_copy_term_tree_to_storage(term *storage, term **heap_end, term t)

copies a term to a storage, typically for mailbox messages

deep copies a term to a destination heap, once finished old memory can be freed.

Parameters:

• storage – storage for the copied data, should be large enough

• heap_end – on output, pointer to the end of the term.

• t – term to copy

Returns:

a boxed term pointer to the new term content that is stored in the storage.

unsigned long memory_estimate_usage(term t)

calculates term memory usage

perform an used memory calculation using given term as root, shared memory (that is not part of the memory block) is not accounted.

Parameters:

• t – root term on which used memory calculation will be performed.

Returns:

used memory terms count in term units output parameter.

void memory_heap_append_fragment(Heap *heap, HeapFragment *fragment, term mso_list)

append a fragment to a heap. The MSO list is merged. The fragment will then be owned by the heap.

Parameters:

• heap – the heap to append the fragment to

• fragment – the fragment to add

• mso_list – associated mso list or nil

static inline void memory_heap_append_heap(Heap *target, Heap *source)

append a heap to another heap. The MSO list is merged. The fragments of the source heap will be owned by the target heap.

Parameters:

• target – the heap to append the heap’s fragments to

• source – the heap to add

void memory_sweep_mso_list(term mso_list, GlobalContext *global, bool from_task)

Sweep any unreferenced binaries in the “Mark Sweep Object” (MSO) list.

The MSO list is a list of term (references) in a heap. Currently, the elements of this list are referenced to reference-counted binaries or match binaries that themselves reference reference counted binaries. This function will iterate over the binaries in this list, and decrement the reference count of any elements that have not been marked for move (e.g., into a new heap). If the reference count reaches 0, then memory associated with the referenced binary will be freed.In a typical GC event, the terms in this list are within in the old heap or potentially in a heap fragment. However, this function may be called in a copy even, such as in a process spawn, or in the copy of a term to or from a process mailbox.

Parameters:

• mso_list – the list of mark-sweep object in a heap “space”

• global – the global context

• from_task – boolean, true if called from a task, false otherwise

static inline void memory_destroy_heap_fragment(HeapFragment *fragment)

Destroy a chain of heap fragments.

Parameters:

• fragment – fragment to destroy.

static inline void memory_destroy_heap(Heap *heap, GlobalContext *global)

Destroy a root heap. First sweep its mso list.

This function shall only be called from a scheduler thread (native handler or listener) because it decrements the reference count of refc binaries and may call resource destructors.

Parameters:

• heap – the heap to destroy

• global – the global context

static inline void memory_destroy_heap_from_task(Heap *heap, GlobalContext *global)

Destroy a root heap. First sweep its mso list.

This variant is safer and is meant for driver tasks.

Parameters:

• heap – the heap to destroy

• global – the global context

struct HeapFragment

#include <memory.h>

Collaboration diagram for HeapFragment:

Public Members

HeapFragment *next

term mso_list

term *heap_end

union HeapFragment.[anonymous] [anonymous]

term storage[]

struct Heap

#include <memory.h>

Collaboration diagram for Heap:

Public Members

HeapFragment *root

term *heap_start

term *heap_ptr

term *heap_end