6. AMS (Automatic Mark and Sweep)

AMS is an automatically managed but non-moving pool class. It should be used instead of AMC (Automatic Mostly-Copying) for blocks that need to be automatically managed, but cannot be moved.

AMS does not use generational garbage collection, but when creating a pool you use a generation chain to specify the capacity and mortality of a single “generation”. These numbers are used to schedule the collection of the whole pool.

Note

AMS is likely to be useful as a step in integrating a program with the MPS. It allows you to work on scanning (and investigate errors resulting from underscanning) without having to deal with objects moving as well. When you are confident that scanning is correct, you can switch to AMC (Automatic Mostly-Copying).

AMS is not currently suitable for production use. However, it could be developed into a solid mark-and-sweep pool. If you have a use case that needs this, contact us.

6.1. AMS properties

• Does not support allocation via mps_alloc() or deallocation via mps_free().

• Supports allocation via allocation points. If an allocation point is created in an AMS pool, the call to mps_ap_create() takes no additional parameters.

• Supports allocation frames but does not use them to improve the efficiency of stack-like allocation.

• Does not support segregated allocation caches.

• Garbage collections are scheduled automatically. See Scheduling of collections.

• Blocks may contain exact references to blocks in the same or other pools (but may not contain ambiguous references or weak references (1), and may not use remote references).

• Allocations may be variable in size.

• The alignment of blocks is configurable.

• Blocks do not have dependent objects.

• Blocks that are not reachable from a root are automatically reclaimed.

• Blocks are scanned.

• Blocks may only be referenced by base pointers (unless they belong to an object format of variant auto-header).

• Blocks are not protected by barriers (1).

• Blocks do not move. A consequence of this is that the pool’s object format need not provide a forward method, an is-forwarded method or a padding method.

• Blocks may be registered for finalization.

• Blocks must belong to an object format.

6.2. AMS interface

#include "mpscams.h"

mps_class_t mps_class_ams(void)

Return the pool class for an AMS (Automatic Mark & Sweep) pool.

When creating an AMS pool, mps_pool_create() takes two extra arguments:

mps_res_t mps_pool_create(mps_pool_t *pool_o, mps_arena_t arena,
                          mps_class_t mps_class_ams(),
                          mps_fmt_t fmt,
                          mps_chain_t chain)

fmt specifies the object format for the objects allocated in the pool. The format must provide a scan method and a skip method.

chain specifies the generation chain for the pool. It must have a single generation.

mps_class_t mps_class_ams_debug(void)

A debugging version of the AMS pool class.

When creating a debugging AMS pool, mps_pool_create() takes three extra arguments:

mps_res_t mps_pool_create(mps_pool_t *pool_o, mps_arena_t arena,
                          mps_class_t mps_class_ams_debug(),
                          mps_debug_option_s debug_option,
                          mps_fmt_t fmt,
                          mps_chain_t chain)

debug_option specifies the debugging options. See mps_debug_option_s.

fmt and chain are the same as for mps_class_ams().