NAME

src/thread.c - Thread handling stuff

DESCRIPTION

Threads are created by creating new ParrotInterpreter objects.

Functions

static PMC *make_local_copy: 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 as long as Parrot_clone() depends on freezing).
static Shared_gc_info *get_pool: Get the shared gc information. TODO: improve the docs here.
void pt_free_pool: Frees the shared gc information. This clears any global data hen 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: 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: Wakeup a interp which should have called pt_thread_wait().
void pt_thread_wait_with: 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: 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: The actual thread function.

Helper functions used also for running plain interpreters

void pt_clone_code: Copy/clone the packfile/code from interpreter s to d. All resources are created in d.
static void pt_ns_clone: Clone all globals from s to d.
void pt_clone_globals: Copy global namespace when cloning new interpreter
void pt_thread_prepare_for_run: Setup code, and TODO ...

ParrotThread methods

PMC *pt_transfer_sub: create a clone of the sub suitable for the other interpreter
int pt_thread_run: Run the *sub PMC in a separate thread using interpreter in *dest_interp.; arg should be an array of arguments for the subroutine. int
int pt_thread_run_1: Runs a type 1 thread. Nothing is shared, both interpreters are free running without any communication.
int pt_thread_run_2: Runs a type 2 thread. No shared variables, threads are communicating by sending messages.
int pt_thread_run_3: Run a type 3 thread. Threads may have shared variables and are managed in a thread pool.
void pt_thread_yield: Relinquishes hold on the processor.
static Parrot_Interp pt_check_tid: Helper function. Check if tid 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 so a global GC can be performed. interpreter_array_mutex must be held.
static QUEUE_ENTRY *remove_queued_suspend_gc: Remove an event requesting that the interpreter suspend itself for a garbage-collection run from the event queue.
static int pt_gc_count_threads: interpreter_array_mutex must be held
static void pt_gc_wait_for_stage: RT#48260: Not yet documented!!!
static void pt_gc_wakeup_check: Check if we need to wake threads to perform garbage collection. This is called after thread death. interpreter_array_mutex is assumed held.
static void pt_suspend_one_for_gc: Suspend a single interpreter for GC. interpreter_array_mutex assumed held.
static void pt_suspend_all_for_gc: Get all threads to perform a GC run.
void pt_suspend_self_for_gc: 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: Join (wait for) a joinable thread.
void pt_join_threads: Possibly wait 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 (make non-joinable) the thread.
void pt_thread_kill: Kills the thread.

Threaded interpreter book-keeping

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

DOD Synchronization Functions

void pt_DOD_start_mark: DOD is going to 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: DOD is finished for the root set.
void pt_DOD_stop_mark: DOD's mark phase is done.
void Parrot_shared_DOD_block: Block stop-the-world DOD runs.
void Parrot_shared_DOD_unblock: Unblock stop-the-world DOD runs.