src/thread.c - Thread handling stuff


Threads are created by creating new ParrotInterpreter objects.

Functions ^

static PMC *make_local_copy(Parrot_Interp interp, Parrot_Interp from, PMC *original)

Create a local copy of the PMC if necessary. (No copy is made if it is marked shared.) This includes workarounds for Parrot_clone() not doing the Right Thing with subroutines (specifically, code segments aren't preserved and it is difficult to do so so long as Parrot_clone() depends on freezing).

static PMC *make_local_args_copy(Parrot_Interp interp, PMC *args)

Make a local copy of the corresponding array of arguments.

PMC *pt_shared_fixup(Parrot_Interp interp, PMC *pmc)

Fixup a PMC to be sharable. Right now, reassigns the vtable to one owned by some master interpreter, so the PMC can be safely reused after thread death.

In the future the PMC returned might be different than the one passed, e.g., if we need to reallocate the PMC in a different interpreter.

static void pt_thread_signal(Parrot_Interp self, Parrot_Interp interp)

Wakeup a interp which should have called pt_thread_wait().

void pt_thread_wait_with(Parrot_Interp interp, Parrot_mutex *mutex)

Wait for this interpreter to be signalled through its condition variable, dealing properly with GC issues. *mutex is assumed locked on entry and will be locked on exit from this function. If a GC run occurs in the middle of this function, then a spurious wakeup may occur.

static void pt_thread_wait(Parrot_Interp interp)

Wait for us to be signalled. GC matters are handled correctly. interpreter_array_mutex is assumed held. Spurious wakeups may occur.

static void *thread_func(void *arg)

The actual thread function.

Helper functions used also for running plain interpreters ^

void pt_clone_code(Parrot_Interp d, Parrot_Interp s)

Copy/clone the packfile/code from interpreter s to d. All resources are created in d.

void pt_clone_globals(Parrot_Interp d, Parrot_Interp s)

Clone all globals from s to d.

void pt_thread_prepare_for_run(Parrot_Interp d, Parrot_Interp s)

Setup code, and TODO ...

ParrotThread methods ^

int pt_thread_run(Parrot_Interp interp, PMC *dest_interp, PMC *sub, PMC *arg)

Run the *sub PMC in a separate thread using interpreter in *dest_interp.

arg should be an array of arguments for the subroutine.

int pt_thread_run_1(Parrot_Interp interp, PMC *dest_interp, PMC *sub, PMC *arg)

Runs a type 1 thread. Nothing is shared, both interpreters are free running without any communication.

int pt_thread_run_2(Parrot_Interp interp, PMC *dest_interp, PMC *sub, PMC *arg)

Runs a type 2 thread. No shared variables, threads are communicating by sending messages.

int pt_thread_run_3(Parrot_Interp interp, PMC *dest_interp, PMC *sub, PMC *arg)

Run a type 3 thread. Threads may have shared variables and are managed in a thread pool.

void pt_thread_yield(void)

Relinquishes hold on the processor.

static Parrot_Interp pt_check_tid(UINTVAL tid, const char *from)

Helper function. Check if tid is valid. The caller holds the mutex. Returns the interpreter for tid.

static void mutex_unlock(void *arg)

Unlocks the mutex *arg.

static int is_suspended_for_gc(Parrot_Interp interp)

Returns true iff interp is suspended so a global GC can be performed. interpreter_array_mutex must be held.

static void pt_suspend_one_for_gc(Parrot_Interp interp)

Suspend a single interpreter for GC. interpreter_array_mutex assumed held.

static int pt_suspend_all_for_gc(Parrot_Interp interp)

Get all threads to perform a GC run.

void pt_suspend_self_for_gc(Parrot_Interp interp)

Suspend this thread for a full GC run.

XXX FIXME -- if GC is blocked, we need to do a GC run as soon as it becomes unblocked.

PMC *pt_thread_join(Parrot_Interp parent, UINTVAL tid)

Join (wait for) a joinable thread.

void pt_join_threads(Parrot_Interp interp)

Possibly wait for other running threads. This is called when destroying interp.

static Parrot_Interp detach(UINTVAL tid)

Helper for detach and kill.

Returns the interpreter, if it didn't finish yet.

void pt_thread_detach(UINTVAL tid)

Detaches (make non-joinable) the thread.

void pt_thread_kill(UINTVAL tid)

Kills the thread.

Threaded interpreter book-keeping ^

void pt_add_to_interpreters(Parrot_Interp interp, Parrot_Interp new_interp)

All threaded interpreters are stored in an array. Assumes that caller holds LOCK.

DOD Synchronization Functions ^

void pt_DOD_start_mark(Parrot_Interp interp)

DOD is gonna start the mark phase. In the presence of shared PMCs, we can only run one DOD run at a time because PMC->next_for_GC may be changed.

flags are the DOD flags. We check if we need to collect shared objects or not.

TODO - Have a count of shared PMCs and check it during DOD.

TODO - Evaluate if a interpreter lock is cheaper when dod_mark_ptr is updated.

void pt_DOD_mark_root_finished(Parrot_Interp interp)

DOD is finished for the root set.

void pt_DOD_stop_mark(Parrot_Interp interp)

DOD's mark phase is done.

void Parrot_shared_DOD_block(Parrot_Interp interp)

Block stop-the-world DOD runs.

void Parrot_shared_DOD_unblock(Parrot_Interp interp)

Unblock stop-the-world DOD runs.


2003.12.18 leo initial rev


src/pmc/parrotinterpreter.pmc, docs/dev/events.pod.