From 5ecb45c3469a3e03d5f5e748385239f73cffb6b9 Mon Sep 17 00:00:00 2001 From: Jorrit Herder Date: Tue, 23 Aug 2005 10:25:01 +0000 Subject: [PATCH] Improved scheduling: new way to catch infinite loops. --- kernel/proc.c | 40 +++++++++++++++++++++++++++------------- kernel/table.c | 10 +++++----- 2 files changed, 32 insertions(+), 18 deletions(-) diff --git a/kernel/proc.c b/kernel/proc.c index ad78e26f6..1dac41ff3 100755 --- a/kernel/proc.c +++ b/kernel/proc.c @@ -491,30 +491,44 @@ register struct proc *rp; /* process to be scheduled */ int *queue; /* return: queue to use */ int *front; /* return: front or back */ { -/* This function determines the scheduling policy. It is called whenever a +/* This function determines the scheduling policy. It is called whenever a * process must be added to one of the scheduling queues to decide where to - * insert it. + * insert it. As a side-effect the process' priority may be updated. */ - int time_left; - int penalty; - - /* Check whether the process has time left. Otherwise give a new quantum. + static struct proc *prev_ptr = NIL_PROC; /* previous without time */ + int time_left = (rp->p_ticks_left > 0); /* quantum fully consumed */ + int penalty = 0; /* change in priority */ + + /* Check whether the process has time left. Otherwise give a new quantum + * and possibly raise the priority. Processes using multiple quantums + * in a row get a lower priority to catch infinite loops in high priority + * processes (system servers and drivers). */ - time_left = (rp->p_ticks_left > 0); /* check ticks left */ if ( ! time_left) { /* quantum consumed ? */ rp->p_ticks_left = rp->p_quantum_size; /* give new quantum */ + if (prev_ptr == rp) penalty ++; /* catch infinite loops */ + else penalty --; /* give slow way back */ + prev_ptr = rp; /* store ptr for next */ } - /* Determine the new priority of this process. User and system processes - * are treated different. They can be distinguished because only user - * processes (and IDLE) are billable. - */ - penalty = 0; +#if 0 if (priv(rp)->s_flags & BILLABLE) { /* user process */ } else { /* system process */ } - rp->p_priority = MIN((rp->p_max_priority + penalty), (IDLE_Q - 1)); +#endif + + /* Determine the new priority of this process. The bounds are determined + * by IDLE's queue and the maximum priority of this process. Kernel task + * and the idle process are never changed in priority. + */ + if (! iskernelp(rp) && penalty != 0) { + rp->p_priority += penalty; /* update with penalty */ + if (rp->p_priority < rp->p_max_priority) /* check upper bound */ + rp->p_priority=rp->p_max_priority; + else if (rp->p_priority > IDLE_Q-1) /* check lower bound */ + rp->p_priority = IDLE_Q-1; + } /* If there is time left, the process is added to the front of its queue, * so that it can immediately run. The queue to use simply is always the diff --git a/kernel/table.c b/kernel/table.c index 71dcc07b6..57cbeb767 100755 --- a/kernel/table.c +++ b/kernel/table.c @@ -101,11 +101,11 @@ PUBLIC struct boot_image image[] = { { HARDWARE, 0, TSK_F, 64, TASK_Q, HRD_S, 0, 0, 0, "KERNEL"}, { PM_PROC_NR, 0, SRV_F, 32, 3, 0, SRV_T, SRV_M, PM_C, "pm" }, { FS_PROC_NR, 0, SRV_F, 32, 4, 0, SRV_T, SRV_M, FS_C, "fs" }, - { SM_PROC_NR, 0, SRV_F, 32, 3, 0, SRV_T, SYS_M, SM_C, "sm" }, - { TTY_PROC_NR, 0, SRV_F, 16, 1, 0, SRV_T, SYS_M, DRV_C, "tty" }, - { MEM_PROC_NR, 0, SRV_F, 16, 2, 0, SRV_T, DRV_M, MEM_C, "memory"}, - { LOG_PROC_NR, 0, SRV_F, 16, 2, 0, SRV_T, SYS_M, DRV_C, "log" }, - { DRVR_PROC_NR, 0, SRV_F, 16, 2, 0, SRV_T, SYS_M, DRV_C, "driver"}, + { SM_PROC_NR, 0, SRV_F, 4, 3, 0, SRV_T, SYS_M, SM_C, "sm" }, + { TTY_PROC_NR, 0, SRV_F, 4, 1, 0, SRV_T, SYS_M, DRV_C, "tty" }, + { MEM_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, DRV_M, MEM_C, "memory"}, + { LOG_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, SYS_M, DRV_C, "log" }, + { DRVR_PROC_NR, 0, SRV_F, 4, 2, 0, SRV_T, SYS_M, DRV_C, "driver"}, { INIT_PROC_NR, 0, USR_F, 8, USER_Q, 0, USR_T, USR_M, 0, "init" }, }; -- 2.44.0