### Navigation

- index
- next |
- previous |
- Memory Pool System 1.111.0 documentation »
- Pool reference »

# 11. MVFF (Manual Variable First Fit)

MVFF manually manages variable-sized, unformatted objects. It uses the first fit allocation policy for blocks allocated via `mps_alloc()`.

Johnstone (1997) found that in his test cases:

> No version of best fit had more than 5% actual fragmentation. This is also true for all versions of first fit that used an address-ordered free list, and the two versions of first fit that used a FIFO free list. This strongly suggests that the basic best-fit algorithm and the first-fit algorithm with an address-ordered free list are very robust algorithms.

The MVFF pool class also supports buffered allocation (that is, allocation via allocation points), and in this case, the allocation policy is different: the buffers are filled according to the worst fit policy, and allocation always proceeds upwards from the base.

Buffered and unbuffered allocation can be used at the same time, but the first allocation point must be created before any call to `mps_alloc()`.

It is usually not advisable to use buffered and unbuffered allocation on the same pool, because the worst-fit policy of buffer filling will grab all the large blocks, leading to severe fragmentation. If you need both forms of allocation, use two separate pools.

Note that buffered allocation can’t allocate across segment boundaries (see Allocation point implementation for the technical reason). This can cause added external fragmentation if objects are allocated that are a significant fraction of the segment size.

Note

If you need to allocate large objects in an MVFF pool, contact us.

## 11.1. MVFF properties

- Supports allocation via `mps_alloc()`.
- Supports allocation via allocation points. If an allocation point is created in an MVFF pool, the call to `mps_ap_create()` takes no additional parameters.
- Supports deallocation via `mps_free()`.
- Supports allocation frames but does not use them to improve the efficiency of stack-like allocation.
- Supports segregated allocation caches.
- There are no garbage collections in this pool.
- Blocks may not contain references to blocks in automatically managed pools (unless these are registered as roots).
- Allocations may be variable in size.
- The alignment of blocks is configurable, but may not be smaller than the natural alignment of the platform.
- Blocks do not have dependent objects.
- Blocks are not automatically reclaimed.
- Blocks are not scanned.
- Blocks are not protected by barriers(1).
- Blocks do not move.
- Blocks may not be registered for finalization.
- Blocks must not belong to an object format.

## 11.2. MVFF interface

    #include "mpscmvff.h"

mps_class_t `mps_class_mvff`(void)

  Return the pool class for an MVFF (Manual Variable First Fit) pool.

  When creating an MVFF pool, `mps_pool_create()` takes six extra arguments:

      mps_res_t mps_pool_create(mps_pool_t *pool_o, mps_arena_t arena,
                                mps_class_t mps_class_mvff(),
                                mps_size_t extend_size,
                                mps_size_t average_size,
                                mps_align_t alignment,
                                mps_bool_t slot_high,
                                mps_bool_t arena_high,
                                mps_bool_t first_fit)

  `extend_size` is the size of segment that the pool will request from the arena.

  `average_size` is the predicted average size of blocks that will be allocated from the pool.

  `alignment` is the alignment of addresses for allocation (and freeing) in the pool. If an unaligned size is passed to `mps_alloc()` or `mps_free()`, it will be rounded up to the pool’s alignment. The minimum alignment supported by pools of this class is `sizeof(void *)`.

  `slot_high` is undocumented. It must have the same value as `arena_high`.

  If `arena_high` is true, new segments for buffered allocation are acquired at high addresses; if false, at low addresses.

  `first_fit` is undocumented and must be set to true.

mps_class_t `mps_class_mvff_debug`(void)

  A debugging version of the MVFF pool class.

  When creating a debugging MVFF pool, `mps_pool_create()` takes seven extra arguments:

      mps_res_t mps_pool_create(mps_pool_t *pool_o, mps_arena_t arena,
                                mps_class_t mps_class_mvff_debug(),
                                mps_debug_option_s debug_option,
                                mps_size_t extend_size,
                                mps_size_t average_size,
                                mps_align_t alignment,
                                mps_bool_t slot_high,
                                mps_bool_t arena_high,
                                mps_bool_t first_fit)

  `debug_option` specifies the debugging options. See `mps_debug_option_s`.

  The other arguments are the same as for `mps_class_mvff()`.

## 11.3. MVFF introspection

    #include "mpscmvff.h"

size_t `mps_mvff_free_size`(mps_pool_t pool)

  Return the total amount of free space in an MVFF pool.

  `pool` is the MVFF pool.

  Returns the total free space in the pool, in bytes(1).

size_t `mps_mvff_size`(mps_pool_t pool)

  Return the total size of an MVFF pool.

  `pool` is the MVFF pool.

  Returns the total size of the pool, in bytes(1). This is the sum of allocated space and free space.

### Navigation

- index
- next |
- previous |
- Memory Pool System 1.111.0 documentation »
- Pool reference »