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

changed the process id map to put the freed id at the back of the list

Browse Source
This commit is contained in:
hyunghwan.chung 2017-07-30 15:15:47 +00:00
parent f78bf33866
commit 8f6b21a4f6
3 changed files with 97 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
moo/lib/exec.c
View File

@ -33,7 +33,8 @@
#define PROC_STATE_TERMINATED -1 #define PROC_STATE_TERMINATED -1
#define PROC_MAP_INC 256 /* TODO: adjust this process map increment value */
#define PROC_MAP_INC 64
/* TODO: adjust these max semaphore pointer buffer capacity, /* TODO: adjust these max semaphore pointer buffer capacity,
* proably depending on the object memory size? */ * proably depending on the object memory size? */
@ -153,12 +154,89 @@ static MOO_INLINE void vm_muxwait (moo_t* moo, const moo_ntime_t* dur)
/* ------------------------------------------------------------------------- */ /* ------------------------------------------------------------------------- */
static MOO_INLINE int prepare_to_alloc_pid (moo_t* moo)
{
moo_oow_t new_capa;
moo_ooi_t i, j;
moo_oop_t* tmp;
MOO_ASSERT (moo, moo->proc_map_free_first <= -1);
MOO_ASSERT (moo, moo->proc_map_free_last <= -1);
new_capa = moo->proc_map_capa + PROC_MAP_INC;
if (new_capa > MOO_SMOOI_MAX)
{
if (moo->proc_map_capa >= MOO_SMOOI_MAX)
{
#if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG0 (moo, MOO_LOG_IC | MOO_LOG_FATAL, "Processor - too many processes\n");
#endif
moo_seterrnum (moo, MOO_EPFULL);
return -1;
}
new_capa = MOO_SMOOI_MAX;
}
tmp = moo_reallocmem (moo, moo->proc_map, MOO_SIZEOF(moo_oop_t) * new_capa);
if (!tmp) return -1;
moo->proc_map_free_first = moo->proc_map_capa;
for (i = moo->proc_map_capa, j = moo->proc_map_capa + 1; j < new_capa; i++, j++)
{
tmp[i] = MOO_SMOOI_TO_OOP(j);
}
tmp[i] = MOO_SMOOI_TO_OOP(-1);
moo->proc_map_free_last = i;
moo->proc_map = tmp;
moo->proc_map_capa = new_capa;
return 0;
}
static MOO_INLINE void alloc_pid (moo_t* moo, moo_oop_process_t proc)
{
moo_ooi_t pid;
pid = moo->proc_map_free_first;
proc->id = MOO_SMOOI_TO_OOP(pid);
MOO_ASSERT (moo, MOO_OOP_IS_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;
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)
{
moo_ooi_t pid;
pid = MOO_OOP_TO_SMOOI(proc->id);
MOO_ASSERT (moo, pid < moo->proc_map_capa);
moo->proc_map[pid] = MOO_SMOOI_TO_OOP(-1);
if (moo->proc_map_free_last <= -1)
{
MOO_ASSERT (moo, moo->proc_map_free_first <= -1);
moo->proc_map_free_first = pid;
}
else
{
moo->proc_map[moo->proc_map_free_last] = MOO_SMOOI_TO_OOP(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)
{ {
moo_oop_process_t proc; moo_oop_process_t proc;
moo_ooi_t total_count; moo_ooi_t total_count;
moo_ooi_t suspended_count; moo_ooi_t suspended_count;
moo_ooi_t proc_map_free;
total_count = MOO_OOP_TO_SMOOI(moo->processor->total_count); total_count = MOO_OOP_TO_SMOOI(moo->processor->total_count);
if (total_count >= MOO_SMOOI_MAX) if (total_count >= MOO_SMOOI_MAX)
@ -170,40 +248,7 @@ static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c)
return MOO_NULL; return MOO_NULL;
} }
if (moo->proc_map_free <= -1) if (moo->proc_map_free_first <= -1 && prepare_to_alloc_pid(moo) <= -1) return MOO_NULL;
{
moo_oow_t new_capa;
moo_ooi_t i, j;
moo_oop_t* tmp;
new_capa = moo->proc_map_capa + PROC_MAP_INC;
if (new_capa > MOO_SMOOI_MAX)
{
if (moo->proc_map_capa >= MOO_SMOOI_MAX)
{
#if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG0 (moo, MOO_LOG_IC | MOO_LOG_FATAL, "Processor - too many processes\n");
#endif
moo_seterrnum (moo, MOO_EPFULL);
return MOO_NULL;
}
new_capa = MOO_SMOOI_MAX;
}
tmp = moo_reallocmem (moo, moo->proc_map, MOO_SIZEOF(moo_oop_t) * new_capa);
if (!tmp) return MOO_NULL;
moo->proc_map_free = moo->proc_map_capa;
for (i = moo->proc_map_capa, j = moo->proc_map_capa + 1; j < new_capa; i++, j++)
{
tmp[i] = MOO_SMOOI_TO_OOP(j);
}
tmp[i] = MOO_SMOOI_TO_OOP(-1);
moo->proc_map = tmp;
moo->proc_map_capa = new_capa;
}
moo_pushtmp (moo, (moo_oop_t*)&c); moo_pushtmp (moo, (moo_oop_t*)&c);
proc = (moo_oop_process_t)moo_instantiate (moo, moo->_process, MOO_NULL, moo->option.dfl_procstk_size); proc = (moo_oop_process_t)moo_instantiate (moo, moo->_process, MOO_NULL, moo->option.dfl_procstk_size);
@ -213,11 +258,7 @@ static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c)
proc->state = MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED); proc->state = MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED);
/* assign a process id to the process */ /* assign a process id to the process */
proc_map_free = moo->proc_map_free; alloc_pid (moo, proc);
proc->id = MOO_SMOOI_TO_OOP(proc_map_free);
MOO_ASSERT (moo, MOO_OOP_IS_SMOOI(moo->proc_map[proc_map_free]));
moo->proc_map_free = MOO_OOP_TO_SMOOI(moo->proc_map[proc_map_free]);
moo->proc_map[proc_map_free] = (moo_oop_t)proc;
proc->initial_context = c; proc->initial_context = c;
proc->current_context = c; proc->current_context = c;
@ -246,7 +287,7 @@ static moo_oop_process_t make_process (moo_t* moo, moo_oop_context_t c)
static MOO_INLINE void sleep_active_process (moo_t* moo, int state) static MOO_INLINE void sleep_active_process (moo_t* moo, int state)
{ {
#if defined(MOO_DEBUG_VM_PROCESSOR) #if defined(MOO_DEBUG_VM_PROCESSOR)
MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - put process %O context %O ip=%zd to sleep\n", moo->processor->active, moo->active_context, moo->ip); MOO_LOG3 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - put process [%zd] context %O ip=%zd to sleep\n", MOO_OOP_TO_SMOOI(moo->processor->active->id), moo->active_context, moo->ip);
#endif #endif
STORE_ACTIVE_SP(moo); STORE_ACTIVE_SP(moo);
@ -417,8 +458,6 @@ static MOO_INLINE void unchain_from_semaphore (moo_t* moo, moo_oop_process_t pro
static void terminate_process (moo_t* moo, moo_oop_process_t proc) static void terminate_process (moo_t* moo, moo_oop_process_t proc)
{ {
moo_ooi_t pid;
if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNING) || if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNING) ||
proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE)) proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_RUNNABLE))
{ {
@ -459,16 +498,11 @@ static void terminate_process (moo_t* moo, moo_oop_process_t proc)
proc->sp = MOO_SMOOI_TO_OOP(-1); /* invalidate the process stack */ proc->sp = MOO_SMOOI_TO_OOP(-1); /* invalidate the process stack */
} }
/* TODO: when terminated, clear it from the pid table and set the process id to a negative number */ /* when terminated, clear it from the pid table and set the process id to a negative number */
/* i assuem there is no GC since i don't protected proc */ free_pid (moo, proc);
pid = MOO_OOP_TO_SMOOI(proc->id);
moo->proc_map[pid] = MOO_SMOOI_TO_OOP(moo->proc_map_free);
moo->proc_map_free = pid;
} }
else if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED)) else if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_SUSPENDED))
{ {
moo_ooi_t pid;
/* SUSPENDED ---> TERMINATED */ /* SUSPENDED ---> TERMINATED */
#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->TERMINATED\n", MOO_OOP_TO_SMOOI(proc->id)); MOO_LOG1 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] SUSPENDED->TERMINATED\n", MOO_OOP_TO_SMOOI(proc->id));
@ -483,10 +517,8 @@ static void terminate_process (moo_t* moo, moo_oop_process_t proc)
unchain_from_semaphore (moo, proc); unchain_from_semaphore (moo, proc);
} }
/* TODO: when terminated, clear it from the pid table and set the process id to a negative number */ /* when terminated, clear it from the pid table and set the process id to a negative number */
pid = MOO_OOP_TO_SMOOI(proc->id); free_pid (moo, proc);
moo->proc_map[pid] = MOO_SMOOI_TO_OOP(moo->proc_map_free);
moo->proc_map_free = pid;
} }
#if 0 #if 0
else if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_WAITING)) else if (proc->state == MOO_SMOOI_TO_OOP(PROC_STATE_WAITING))
@ -533,7 +565,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_LOG1 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process %O RUNNING/RUNNABLE->SUSPENDED\n", proc); MOO_LOG1 (moo, MOO_LOG_IC | MOO_LOG_DEBUG, "Processor - process [%zd] RUNNING/RUNNABLE->SUSPENDED\n", MOO_OOP_TO_SMOOI(proc->id));
#endif #endif
if (proc == moo->processor->active) if (proc == moo->processor->active)
@ -4596,7 +4628,7 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
else else
{ {
/* no running process, no io semaphore */ /* no running process, no io semaphore */
if (moo->sem_gcfin != moo->_nil && moo->sem_gcfin_sigreq) goto signal_sem_gcfin; if ((moo_oop_t)moo->sem_gcfin != moo->_nil && moo->sem_gcfin_sigreq) goto signal_sem_gcfin;
vm_sleep (moo, &ft); vm_sleep (moo, &ft);
} }
vm_gettime (moo, &now); vm_gettime (moo, &now);
@ -4617,6 +4649,8 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
if (moo->processor->active == moo->nil_process) if (moo->processor->active == moo->nil_process)
{ {
/* no runnable process while there is an io semaphore being waited */ /* no runnable process while there is an io semaphore being waited */
if ((moo_oop_t)moo->sem_gcfin != moo->_nil && moo->sem_gcfin_sigreq) goto signal_sem_gcfin;
do do
{ {
vm_gettime (moo, &now); vm_gettime (moo, &now);
@ -4631,7 +4665,6 @@ static MOO_INLINE int switch_process_if_needed (moo_t* moo)
} }
} }
if ((moo_oop_t)moo->sem_gcfin != moo->_nil) if ((moo_oop_t)moo->sem_gcfin != moo->_nil)
{ {
moo_oop_process_t proc; moo_oop_process_t proc;

6
moo/lib/moo.c
View File

@ -125,7 +125,8 @@ int moo_init (moo_t* moo, moo_mmgr_t* mmgr, moo_oow_t heapsz, const moo_vmprim_t
moo->tagged_classes[MOO_OOP_TAG_CHAR] = &moo->_character; moo->tagged_classes[MOO_OOP_TAG_CHAR] = &moo->_character;
moo->tagged_classes[MOO_OOP_TAG_ERROR] = &moo->_error_class; moo->tagged_classes[MOO_OOP_TAG_ERROR] = &moo->_error_class;
moo->proc_map_free = -1; moo->proc_map_free_first = -1;
moo->proc_map_free_last = -1;
return 0; return 0;
oops: oops:
@ -183,7 +184,8 @@ void moo_fini (moo_t* moo)
{ {
moo_freemem (moo, moo->proc_map); moo_freemem (moo, moo->proc_map);
moo->proc_map_capa = 0; moo->proc_map_capa = 0;
moo->proc_map_free = -1; moo->proc_map_free_first = -1;
moo->proc_map_free_last = -1;
} }
for (cb = moo->cblist; cb; cb = cb->next) for (cb = moo->cblist; cb; cb = cb->next)

3
moo/lib/moo.h
View File

@ -1182,7 +1182,8 @@ struct moo_t
moo_oop_t* proc_map; moo_oop_t* proc_map;
moo_oow_t proc_map_capa; moo_oow_t proc_map_capa;
moo_ooi_t proc_map_free; moo_ooi_t proc_map_free_first;
moo_ooi_t proc_map_free_last;
/* ============================================================= /* =============================================================
* EXECUTION REGISTERS * EXECUTION REGISTERS