NAME

src/thread.c - Thread handling stuff

DESCRIPTION

Threads are created by creating new ParrotInterpreter objects.

Functions

static PMC *make_local_copy
Creates 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 as long as Parrot_clone() depends on freezing).
static Shared_gc_info *get_pool
Gets the shared gc information. For now this is global data; ideally it will become something other than a static variable. If everything uses this function, it will be easier to change.
void pt_free_pool
Frees the shared GC information. This clears any global data when joining all threads at parent interpreter destruction.
static PMC *make_local_args_copy
Make a local copy of the corresponding array of arguments.
PMC *pt_shared_fixup
Modifies 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
Wakes up an interp which should have called pt_thread_wait().
void pt_thread_wait_with
Waits 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
Waits for a signal, handling GC matters correctly. interpreter_array_mutex is assumed held. Spurious wakeups may occur.
static void *thread_func
The actual thread function.

Helper functions used also for running plain interpreters

void pt_clone_code
Copies/clones the packfile/code from interpreter s to d. All resources are created in d.
static void pt_ns_clone
Clones all globals from s to d.
void pt_clone_globals
Copies the global namespace when cloning a new interpreter.
void pt_thread_prepare_for_run
Sets up a new thread to run.

ParrotThread methods

PMC *pt_transfer_sub
Clones the sub so that it's suitable for the other interpreter.
int pt_thread_run
Runs the *sub PMC in a separate thread using the interpreter in *dest_interp.arg should be an array of arguments for the subroutine.
int pt_thread_run_1
Runs a thread that shares nothing and does not communicate with the other interpreter.
int pt_thread_run_2
Runs an interpreter in a thread with no shared variables, but which communicates by sending messages.
int pt_thread_run_3
Runs an interpreter in a thread, allowing shared variables and using a thread pool.
void pt_thread_yield
Relinquishes hold on the processor.
static Parrot_Interp pt_check_tid
Helper function. Checks if the given thread ID is valid. The caller holds the mutex. Returns the interpreter for tid.
static void mutex_unlock
Unlocks the mutex *arg.
static int is_suspended_for_gc
Returns true iff interp is suspended for a global GC run. Be sure to hold interpreter_array_mutex.
static QUEUE_ENTRY *remove_queued_suspend_gc
Removes an event requesting that the interpreter suspend itself for a garbage-collection run from the event queue.
static int pt_gc_count_threads
Returns the number of active threads in the system (running or suspended). Be sure to hold interpreter_array_mutex.
static void pt_gc_wait_for_stage
Waits until all threads have reached the desired stage. Takes an interpreter, starting stage and ending stage as arguments. Updates the thread information. Used in pt_gc_start_mark and pt_gc_stop_mark.
static void pt_gc_wakeup_check
Checks if it's necessary to wake threads to perform garbage collection. This is called after thread death. Be sure to hold interpreter_array_mutex.
static void pt_suspend_one_for_gc
Suspends a single interpreter for GC. Be sure to hold interpreter_array_mutex.
static void pt_suspend_all_for_gc
Notifies all threads to perform a GC run.
void pt_suspend_self_for_gc
Suspends 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
Joins (by waiting for) a joinable thread.
void pt_join_threads
Possibly waits for other running threads. This is called when destroying interp.
static Parrot_Interp detach
Helper for detach and kill.Returns the interpreter, if it didn't finish yet.
void pt_thread_detach
Detaches the thread, making it non-joinable.
void pt_thread_kill
Kills the thread.

Threaded interpreter book-keeping

void pt_add_to_interpreters
Stores the given interpreter in the array of all interpreters. Be sure to hold interpreter_array_mutex.

GC Synchronization Functions

void pt_gc_start_mark
Record that the mark phase of GC is about to begin. In the presence of shared PMCs, we can only run one GC run at a time because PMC->next_for_GC may be changed.flags are the GC flags. We check if we need to collect shared objects or not.TODO - Have a count of shared PMCs and check it during GC.TODO - Evaluate if a interpreter lock is cheaper when gc_mark_ptr is updated.
void pt_gc_mark_root_finished
Records that GC has finished for the root set. EXCEPTION_UNIMPLEMENTED
void pt_gc_stop_mark
Records that the mark phase of GC has completed.
void Parrot_shared_gc_block
Blocks stop-the-world GC runs.
void Parrot_shared_gc_unblock
Unblocks stop-the-world GC runs.