-/* kern_clock.c 3.2 %H% */
+/* %H% 3.14 kern_clock.c */
#include "../h/param.h"
#include "../h/systm.h"
+#include "../h/dk.h"
#include "../h/callo.h"
#include "../h/seg.h"
#include "../h/dir.h"
* jab the scheduler
*/
#ifdef KPROF
-short kcount[20000];
+unsigned short kcount[20000];
#endif
+/*
+ * We handle regular calls to the dh and dz silo input processors
+ * without using timeouts to save a little time.
+ */
+int rintvl = 0; /* every 1/60'th of sec check receivers */
+int rcnt;
+
clock(pc, ps)
caddr_t pc;
{
register struct callo *p1, *p2;
register struct proc *pp;
register int s;
- int a;
+ int a, cpstate;
/*
* reprime clock
* and time of day
*/
out:
+
+ /*
+ * In order to not take input character interrupts to use
+ * the input silo on DZ's we have to guarantee to echo
+ * characters regularly. This means that we have to
+ * call the timer routines predictably. Since blocking
+ * in these routines is at spl5(), we have to make spl5()
+ * really spl6() blocking off the clock to put this code
+ * here. Note also that it is critical that we run spl5()
+ * (i.e. really spl6()) in the receiver interrupt routines
+ * so we can't enter them recursively and transpose characters.
+ */
+ if (rcnt >= rintvl) {
+ dhtimer();
+ dztimer();
+ rcnt = 0;
+ } else
+ rcnt++;
if (!noproc) {
s = u.u_procp->p_rssize;
u.u_vm.vm_idsrss += s;
if (s > u.u_vm.vm_maxrss)
u.u_vm.vm_maxrss = s;
}
- a = dk_busy&07;
if (USERMODE(ps)) {
u.u_vm.vm_utime++;
if(u.u_procp->p_nice > NZERO)
- a += 8;
+ cpstate = CP_NICE;
+ else
+ cpstate = CP_USER;
} else {
- a += 16;
+ cpstate = CP_SYS;
if (noproc)
- a += 8;
+ cpstate = CP_IDLE;
else
u.u_vm.vm_stime++;
}
- dk_time[a]++;
+ dk_time[cpstate][dk_busy&(DK_NSTATES-1)]++;
if (!noproc) {
pp = u.u_procp;
if(++pp->p_cpu == 0)
pp->p_cpu--;
if(pp->p_cpu % 16 == 0) {
- VOID setpri(pp);
+ (void) setpri(pp);
if (pp->p_pri >= PUSER)
pp->p_pri = pp->p_usrpri;
}
return;
lbolt -= HZ;
++time;
- VOID spl1();
+ (void) spl1();
runrun++;
wakeup((caddr_t)&lbolt);
for(pp = &proc[0]; pp < &proc[NPROC]; pp++)
if(--pp->p_clktim == 0)
if (pp->p_flag & STIMO) {
s = spl6();
- if (pp->p_stat == SSLEEP)
+ switch (pp->p_stat) {
+
+ case SSLEEP:
setrun(pp);
+ break;
+
+ case SSTOP:
+ unsleep(pp);
+ break;
+ }
pp->p_flag &= ~STIMO;
splx(s);
} else
- psignal(pp, SIGCLK);
+ psignal(pp, SIGALRM);
if(pp->p_stat==SSLEEP||pp->p_stat==SSTOP)
if (pp->p_slptime != 127)
pp->p_slptime++;
if(a > 255)
a = 255;
pp->p_cpu = a;
- VOID setpri(pp);
+ (void) setpri(pp);
s = spl6();
if(pp->p_pri >= PUSER) {
if ((pp != u.u_procp || noproc) &&
*/
if (bclnlist != NULL)
wakeup((caddr_t)&proc[2]);
-#ifdef ERNIE
if (USERMODE(ps)) {
pp = u.u_procp;
+#ifdef ERNIE
if (pp->p_uid)
if (pp->p_nice == NZERO && u.u_vm.vm_utime > 600 * HZ)
pp->p_nice = NZERO+4;
- VOID setpri(pp);
+ (void) setpri(pp);
pp->p_pri = pp->p_usrpri;
- }
#endif
+ if (u.u_vm.vm_utime+u.u_vm.vm_stime > u.u_limit[LIM_CPU])
+ psignal(pp, SIGXCPU);
+ }
}
+ if (!BASEPRI(ps))
+ unhang();
if (USERMODE(ps)) {
/*
* We do this last since it
}
#ifdef KPROF
else if (!noproc) {
- register int indx = ((int)pc & 0x7fffffff) / 8;
+ register int indx = ((int)pc & 0x7fffffff) / 4;
if (indx >= 0 && indx < 20000)
- kcount[indx]++;
+ if (++kcount[indx] == 0)
+ --kcount[indx];
}
#endif
}