1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
.. index::
   single: malloc; implementing
   single: free; implementing

.. _guide-malloc:

Implementing malloc and free
============================

The MPS function :c:func:`mps_free` is unlike the Standard C Library
function :c:func:`free` in that it takes a :c:data:`size` argument.
That's because it's nearly always the case that either the size of a
block is known statically based on its type (for example, a
structure), or else the size of the block is easily computed from
information that needs to be stored anyway (for example, a vector),
and so memory can be saved by not storing the size separately. It's
also better for virtual memory performance, as a block does not have
to be touched in order to free it.

But sometimes you need to interact with :term:`foreign code` which
requires :c:func:`malloc` and :c:func:`free` (or a pair of functions
with the same interface). In this situation you can implement this
interface using a global pool variable, and putting the size of each
block into its header, like this::

    #include "mps.h"

    static mps_pool_t malloc_pool;

    typedef union {
        size_t size;
        char alignment[MPS_PF_ALIGN]; /* see note below */
    } header_u;

    void *malloc(size_t size) {
        mps_res_t res;
        mps_addr_t p;
        header_u *header;
        size += sizeof *header;
        res = mps_alloc(&p, malloc_pool, size);
        if (res != MPS_RES_OK)
            return NULL;
        header = p;
        header->size = size;
        return header + 1;
    }

    void free(void *p) {
        if (p) {
            header_u *header = ((header_u *)p) - 1;
            mps_free(malloc_pool, header, header->size);
        }
    }

The :c:member:`alignment` member of the :c:type:`header_u` union
ensures that allocations are aligned to the platform's :term:`natural
alignment` (see :ref:`guide-lang-alignment`).

The pool needs to belong to a :term:`manually managed <manual memory
management>` pool class, for example :ref:`pool-mvff` (or its
:ref:`debugging counterpart <topic-debugging>`)::

    #include "mpscmvff.h"

    void malloc_pool_init(mps_arena_t arena) {
        mps_res_t res;
        res = mps_pool_create_k(&malloc_pool, arena, mps_class_mvff(), mps_args_none);
        if (res != RES_OK)
            abort();
    }