NAME

src/gc/register.c - Register handling routines

DESCRIPTION

Parrot has 4 register sets, one for each of its basic types. The amount of registers in each set varies depending on the use counts of the respective 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 a 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.]

TODO 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

destroy_context: Free allocated context memory
create_initial_context: Create initial interpreter context.
parrot_gc_context: Cleanup dead context memory. Called by the garbage collector.
clear_regs: Not yet documented!!!
init_context: Not yet documented!!!
Parrot_dup_context: Duplicate the passed context
Parrot_push_context: Remember old context in caller_ctx, suitable to use with Parrot_pop_context.
Parrot_pop_context: Free the context created with Parrot_push_context and restore the previous 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.
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.
Parrot_set_context_threshold: Mark the context as possible threshold.

Register Stack Functions

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