NAME

src/gc/register.c - Register handling routines

DESCRIPTION

Parrot has 4 register sets, one for each of its basic types. The number of registers in each set varies depending on the use counts of the subroutine and is determined by the PASM/PIR compiler in the register allocation pass (imcc/reg_alloc.c).

There is one register stack to support the saveall and restoreall opcodes. The former copies all registers to newly allocated storage and points the register base pointers to this storage. In Parrot_pop_regs the register base pointers are restored to the previous values and the allocated register memory is discarded.

Context and register frame layout

    +----------++----+------+------------+----+
    | context  || N  |  I   |   P        |  S +
    +----------++----+------+------------+----+
    ^          ^     ^                   ^
    |          |     ctx.bp              ctx.bp_ps
    ctx.state  opt
               padding

Registers are addressed as usual via the register base pointer ctx.bp.

The macro CONTEXT() hides these details

Context and register frame allocation

There are two allocation strategies: chunked memory and malloced with a free list.

 CHUNKED_CTX_MEM = 1

ctx_mem.data is a pointer to an allocated chunk of memory. The pointer ctx_mem.free holds the next usable location. With (full) continuations the ctx_mem.free pointer can't be moved below the ctx_mem.threshold, which is the highest context pointer of all active continuations. [the code for this is incomplete; it had suffered some bit-rot and was getting in the way of maintaining the other case. -- rgr, 4-Feb-06.]

RT#46177 GC has to lower this threshold when collecting continuations.

 CHUNKED_CTX_MEM = 0

Context/register memory is malloced. ctx_mem.free is used as a free list of reusable items.

Round register allocation size up to the nearest multiple of 8. A granularity of 8 is arbitrary, it could have been some bigger power of 2. A "slot" is an index into the free_list array. Each slot in free_list has a linked list of pointers to already allocated contexts available for (re)use. The slot where an available context is stored corresponds to the size of the context.

Context and Register Allocation Functions

void destroy_context: Free allocated context memory
void create_initial_context: Create initial interpreter context.
void parrot_gc_context: Cleanup dead context memory. Called by the garbage collector.
static void clear_regs: RT#48260: Not yet documented!!!
static void init_context: RT#48260: Not yet documented!!!
struct Parrot_Context *Parrot_dup_context: Duplicate the passed context
struct Parrot_Context *Parrot_push_context: Remember old context in caller_ctx, suitable to use with Parrot_pop_context.
void Parrot_pop_context: Free the context created with Parrot_push_context and restore the previous context.
struct Parrot_Context *Parrot_alloc_context: Allocate a new context and set the context pointer. Please note that the register usage n_regs_used is copied. The function returns the new context.
void Parrot_free_context: Free the context. If re_use is true, this function is called by a return continuation invoke, else from the destructor of a continuation.
void Parrot_set_context_threshold: Mark the context as possible threshold.

Register Stack Functions

void setup_register_stacks: Set up the register stacks.
void Parrot_push_regs: Save all registers onto the register stack.
void Parrot_pop_regs: Restore all registers from register stack.
void mark_register_stack: Marks the register stack and its registers as live.
void Parrot_clear_i: RT#48260: Not yet documented!!!
void Parrot_clear_s: RT#48260: Not yet documented!!!
void Parrot_clear_p: RT#48260: Not yet documented!!!
void Parrot_clear_n: RT#48260: Not yet documented!!!