hyung-hwan/moo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

changed the way to exit the gc finalizer.

Browse Source 
touched up processor scheduling debug statements
This commit is contained in:
hyunghwan.chung 2017-08-20 14:43:34 +00:00
parent 3a62300269
commit 37cf7be1bb
6 changed files with 56 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
moo/kernel/Process.moo
View File

@ -290,7 +290,7 @@ class SemaphoreHeap(Object)
class(#final,#limited) ProcessScheduler(Object) class(#final,#limited) ProcessScheduler(Object)
{ {
var(#get) active, total_count := 0. var(#get) active, should_exit := false, total_count := 0.
var(#get) runnable_count := 0. var(#get) runnable_count := 0.
var runnable_head, runnable_tail. var runnable_head, runnable_tail.
var(#get) suspended_count := 0. var(#get) suspended_count := 0.

3
moo/kernel/System.moo
View File

@ -47,7 +47,8 @@ class System(Apex)
if (tmp respondsTo: #finalize) { tmp finalize }. if (tmp respondsTo: #finalize) { tmp finalize }.
}. }.
if (Processor total_count == 1) ##if (Processor total_count == 1)
if (Processor should_exit)
{ {
## exit from this loop when there are no other processes running except this finalizer process ## exit from this loop when there are no other processes running except this finalizer process
if (gc) if (gc)

61
moo/lib/exec.c
View File

@ -218,8 +218,6 @@ static MOO_INLINE void alloc_pid (moo_t* moo, moo_oop_process_t proc)
moo->proc_map_free_first = MOO_OOP_TO_SMOOI(moo->proc_map[pid]); moo->proc_map_free_first = MOO_OOP_TO_SMOOI(moo->proc_map[pid]);
if (moo->proc_map_free_first <= -1) moo->proc_map_free_last = -1; if (moo->proc_map_free_first <= -1) moo->proc_map_free_last = -1;
moo->proc_map[pid] = (moo_oop_t)proc; moo->proc_map[pid] = (moo_oop_t)proc;
MOO_DEBUG1 (moo, "PID PID PID ALLOCATED %zd\n", pid);
} }
static MOO_INLINE void free_pid (moo_t* moo, moo_oop_process_t proc) static MOO_INLINE void free_pid (moo_t* moo, moo_oop_process_t proc)
@ -240,8 +238,6 @@ static MOO_INLINE void free_pid (moo_t* moo, moo_oop_process_t proc)
moo->proc_map[moo->proc_map_free_last] = MOO_SMOOI_TO_OOP(pid); moo->proc_map[moo->proc_map_free_last] = MOO_SMOOI_TO_OOP(pid);
} }
moo->proc_map_free_last = pid; moo->proc_map_free_last = pid;
MOO_DEBUG1 (moo, "PID PID PID FREED %zd\n", pid);
} }
static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c) static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c)
@ -281,7 +277,7 @@ static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c)
MOO_ASSERT (moo, (moo_oop_t)c->sender == moo->_nil); MOO_ASSERT (moo, (moo_oop_t)c->sender == moo->_nil);
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - made process %zd of size %zu\n", MOO_OOP_TO_SMOOI(proc->id), MOO_OBJ_GET_SIZE(proc)); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process[%zd] **CREATED**->%hs\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
/* a process is created in the SUSPENDED state. chain it to the suspended process list */ /* a process is created in the SUSPENDED state. chain it to the suspended process list */
@ -305,7 +301,7 @@ static MOO_INLINE void sleep_active_process (moo_t* moo, int state)
MOO_ASSERT (moo, moo->processor->active != moo->nil_process); MOO_ASSERT (moo, moo->processor->active != moo->nil_process);
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - active process [%zd] %hs->%hs\n", MOO_OOP_TO_SMOOI(moo->processor->active->id), proc_state_to_string(MOO_OOP_TO_SMOOI(moo->processor->active->state)), proc_state_to_string(state)); MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->%hs in sleep_active_process\n", MOO_OOP_TO_SMOOI(moo->processor->active->id), proc_state_to_string(MOO_OOP_TO_SMOOI(moo->processor->active->state)), proc_state_to_string(state));
#endif #endif
moo->processor->active->current_context = moo->active_context; moo->processor->active->current_context = moo->active_context;
@ -316,7 +312,7 @@ static MOO_INLINE void wake_process (moo_t* moo, moo_oop_process_t proc)
{ {
/* activate the given process */ /* activate the given process */
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->RUNNING\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state))); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->RUNNING in wake_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE)); MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE));
@ -328,7 +324,7 @@ static MOO_INLINE void wake_process (moo_t* moo, moo_oop_process_t proc)
/* activate the suspended context of the new process */ /* activate the suspended context of the new process */
SWITCH_ACTIVE_CONTEXT (moo, proc->current_context); SWITCH_ACTIVE_CONTEXT (moo, proc->current_context);
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR) && (MOO_DEBUG_VM_PROCESSOR >= 2)
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - woke up process [%zd] context %O ip=%zd\n", MOO_OOP_TO_SMOOI(moo->processor->active->id), moo->active_context, moo->ip); MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - woke up process [%zd] context %O ip=%zd\n", MOO_OOP_TO_SMOOI(moo->processor->active->id), moo->active_context, moo->ip);
#endif #endif
} }
@ -386,6 +382,11 @@ static MOO_INLINE void chain_into_processor (moo_t* moo, moo_oop_process_t proc,
MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED)); MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED));
MOO_ASSERT (moo, new_state == PROC_STATE_RUNNABLE || new_state == PROC_STATE_RUNNING); MOO_ASSERT (moo, new_state == PROC_STATE_RUNNABLE || new_state == PROC_STATE_RUNNING);
#if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->%hs in chain_into_processor\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)), proc_state_to_string(MOO_OOP_TO_SMOOI(new_state)));
#endif
runnable_count = MOO_OOP_TO_SMOOI(moo->processor->runnable.count); runnable_count = MOO_OOP_TO_SMOOI(moo->processor->runnable.count);
MOO_ASSERT (moo, runnable_count >= 0); MOO_ASSERT (moo, runnable_count >= 0);
@ -415,6 +416,10 @@ static MOO_INLINE void unchain_from_processor (moo_t* moo, moo_oop_process_t pro
MOO_ASSERT (moo, proc->state != MOO_SMOOI_TO_OOP(new_state)); MOO_ASSERT (moo, proc->state != MOO_SMOOI_TO_OOP(new_state));
#if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->%hs in unchain_from_processor\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)), proc_state_to_string(MOO_OOP_TO_SMOOI(new_state)));
#endif
if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED)) if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED))
{ {
suspended_count = MOO_OOP_TO_SMOOI(moo->processor->suspended.count); suspended_count = MOO_OOP_TO_SMOOI(moo->processor->suspended.count);
@ -491,7 +496,7 @@ static void terminate_process (moo_t* moo, moo_oop_process_t proc)
{ {
/* RUNNING/RUNNABLE ---> TERMINATED */ /* RUNNING/RUNNABLE ---> TERMINATED */
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->TERMINATED\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state))); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->TERMINATED in terminate_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
if (proc == moo->processor->active) if (proc == moo->processor->active)
@ -532,7 +537,7 @@ static void terminate_process (moo_t* moo, moo_oop_process_t proc)
{ {
/* SUSPENDED ---> TERMINATED */ /* SUSPENDED ---> TERMINATED */
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->TERMINATED\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state))); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->TERMINATED in terminate_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
/*proc->state = MOO_SMOOI_TO_OOP(PROC_STATE_TERMINATED);*/ /*proc->state = MOO_SMOOI_TO_OOP(PROC_STATE_TERMINATED);*/
@ -565,7 +570,7 @@ static void resume_process (moo_t* moo, moo_oop_process_t proc)
MOO_ASSERT (moo, (moo_oop_t)proc->ps.next == moo->_nil);*/ MOO_ASSERT (moo, (moo_oop_t)proc->ps.next == moo->_nil);*/
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG1 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] SUSPENDED->RUNNABLE\n", MOO_OOP_TO_SMOOI(proc->id)); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->RUNNABLE in resume_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
/* don't switch to this process. just change the state to RUNNABLE. /* don't switch to this process. just change the state to RUNNABLE.
@ -592,7 +597,7 @@ static void suspend_process (moo_t* moo, moo_oop_process_t proc)
/* RUNNING/RUNNABLE ---> SUSPENDED */ /* RUNNING/RUNNABLE ---> SUSPENDED */
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->SUSPENDED\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state))); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->SUSPENDED in suspend_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
if (proc == moo->processor->active) if (proc == moo->processor->active)
@ -651,7 +656,7 @@ static void yield_process (moo_t* moo, moo_oop_process_t proc)
if (nrp != proc) if (nrp != proc)
{ {
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG1 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] RUNNING->RUNNABLE\n", MOO_OOP_TO_SMOOI(proc->id)); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] %hs->RUNNABLE in yield_process\n", MOO_OOP_TO_SMOOI(proc->id), proc_state_to_string(MOO_OOP_TO_SMOOI(proc->state)));
#endif #endif
switch_to_process (moo, nrp, PROC_STATE_RUNNABLE); switch_to_process (moo, nrp, PROC_STATE_RUNNABLE);
} }
@ -4626,7 +4631,7 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
* switch_to_process() as there is no running * switch_to_process() as there is no running
* process at this moment */ * process at this moment */
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR) && (MOO_DEBUG_VM_PROCESSOR >= 2)
MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - switching to a process [%zd] while no process is active - total runnables %zd\n", MOO_OOP_TO_SMOOI(proc->id), MOO_OOP_TO_SMOOI(moo->processor->runnable.count)); MOO_LOG2 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - switching to a process [%zd] while no process is active - total runnables %zd\n", MOO_OOP_TO_SMOOI(proc->id), MOO_OOP_TO_SMOOI(moo->processor->runnable.count));
#endif #endif
@ -4722,17 +4727,39 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
/* the gcfin semaphore signalling is not requested and there are /* the gcfin semaphore signalling is not requested and there are
* no runnable processes nor no waiting semaphores. if there is * no runnable processes nor no waiting semaphores. if there is
* process waiting on the gcfin semaphore, i will just schedule * process waiting on the gcfin semaphore, i will just schedule
* it to run */ * it to run by calling signal_semaphore() on moo->sem_gcfin.
*/
/* TODO: check if this is the best implementation practice */ /* TODO: check if this is the best implementation practice */
if (moo->processor->active == moo->nil_process) if (moo->processor->active == moo->nil_process)
{ {
MOO_LOG0 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Signalled GCFIN semaphore without gcfin signal request\n"); /* there is no active process. in most cases, the only process left
* should be the gc finalizer process started in the System>>startup.
* if there are other suspended processes at this point, the processes
* are not likely to run again.
*
* imagine the following single line program that creates a process
* but never start it.
*
* method(#class) main { | p | p := [] newProcess. }
*
* the gc finalizer process and the process assigned to p exist.
* when the code reaches here, the 'p' process still is alive
* despite no active process nor no process waiting on timers
* and semaphores. so when the entire program terminates, there
* might still be some suspended processes that are not possible
* to schedule.
*/
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG,
"Signalled GCFIN semaphore without gcfin signal request - total - %zd runnable/running - %zd suspended - %zd\n",
MOO_OOP_TO_SMOOI(moo->processor->total_count), MOO_OOP_TO_SMOOI(moo->processor->runnable.count), MOO_OOP_TO_SMOOI(moo->processor->suspended.count));
proc = signal_semaphore (moo, moo->sem_gcfin); proc = signal_semaphore (moo, moo->sem_gcfin);
if ((moo_oop_t)proc != moo->_nil) if ((moo_oop_t)proc != moo->_nil)
{ {
MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE)); MOO_ASSERT (moo, proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE));
MOO_ASSERT (moo, proc == moo->processor->runnable.first); MOO_ASSERT (moo, proc == moo->processor->runnable.first);
switch_to_process_from_nil (moo, proc); moo->processor->should_exit = moo->_true; /* prepare to inform the gc finalizer process */
switch_to_process_from_nil (moo, proc); /* sechedule the gc finalizer process */
} }
} }
} }

1
moo/lib/gc.c
View File

@ -291,6 +291,7 @@ static int ignite_2 (moo_t* moo)
if (!tmp) return -1; if (!tmp) return -1;
moo->processor = (moo_oop_process_scheduler_t)tmp; moo->processor = (moo_oop_process_scheduler_t)tmp;
moo->processor->active = moo->nil_process; moo->processor->active = moo->nil_process;
moo->processor->should_exit = moo->_false;
moo->processor->total_count = MOO_SMOOI_TO_OOP(0); moo->processor->total_count = MOO_SMOOI_TO_OOP(0);
moo->processor->runnable.count = MOO_SMOOI_TO_OOP(0); moo->processor->runnable.count = MOO_SMOOI_TO_OOP(0);
moo->processor->suspended.count = MOO_SMOOI_TO_OOP(0); moo->processor->suspended.count = MOO_SMOOI_TO_OOP(0);

12
moo/lib/moo-prv.h
View File

@ -46,13 +46,13 @@
#if !defined(NDEBUG) #if !defined(NDEBUG)
/* this is for gc debugging */ /* this is for gc debugging */
#define MOO_DEBUG_GC #define MOO_DEBUG_GC 1
/*#define MOO_DEBUG_LEXER*/ /*#define MOO_DEBUG_LEXER 1*/
#define MOO_DEBUG_COMPILER #define MOO_DEBUG_COMPILER 1
#define MOO_DEBUG_VM_PROCESSOR #define MOO_DEBUG_VM_PROCESSOR 1
/*#define MOO_DEBUG_VM_EXEC*/ /*#define MOO_DEBUG_VM_EXEC*/
#define MOO_DEBUG_BIGINT #define MOO_DEBUG_BIGINT 1
#define MOO_PROFILE_VM #define MOO_PROFILE_VM 1
#endif #endif
/* allow the caller to drive process switching by calling /* allow the caller to drive process switching by calling

3
moo/lib/moo.h
View File

@ -808,13 +808,14 @@ struct moo_semaphore_t
moo_oop_t io_mask; /* SmallInteger */ moo_oop_t io_mask; /* SmallInteger */
}; };
#define MOO_PROCESS_SCHEDULER_NAMED_INSTVARS 8 #define MOO_PROCESS_SCHEDULER_NAMED_INSTVARS 9
typedef struct moo_process_scheduler_t moo_process_scheduler_t; typedef struct moo_process_scheduler_t moo_process_scheduler_t;
typedef struct moo_process_scheduler_t* moo_oop_process_scheduler_t; typedef struct moo_process_scheduler_t* moo_oop_process_scheduler_t;
struct moo_process_scheduler_t struct moo_process_scheduler_t
{ {
MOO_OBJ_HEADER; MOO_OBJ_HEADER;
moo_oop_process_t active; /* pointer to an active process in the runnable process list */ moo_oop_process_t active; /* pointer to an active process in the runnable process list */
moo_oop_t should_exit; /* Boolean */
moo_oop_t total_count; /* SmallIntger, total number of processes - runnable/running/suspended */ moo_oop_t total_count; /* SmallIntger, total number of processes - runnable/running/suspended */
struct struct