projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
%cpu
[unix-history] / usr / src / sys / kern / kern_clock.c
diff --git a/usr/src/sys/kern/kern_clock.c b/usr/src/sys/kern/kern_clock.c
index b5433cc..84eef57 100644 (file)
--- a/usr/src/sys/kern/kern_clock.c
+++ b/usr/src/sys/kern/kern_clock.c
@@ -1,7 +1,8 @@
-/*     kern_clock.c    3.3     %H%     */
+/*     %H%     3.20    kern_clock.c    */
 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
+#include "../h/dk.h"
 #include "../h/callo.h"
 #include "../h/seg.h"
 #include "../h/dir.h"
 #include "../h/callo.h"
 #include "../h/seg.h"
 #include "../h/dir.h"
@@ -12,12 +13,19 @@
 #include "../h/vm.h"
 #include "../h/buf.h"
 #include "../h/text.h"
 #include "../h/vm.h"
 #include "../h/buf.h"
 #include "../h/text.h"
+#include "../h/vlimit.h"
+#include "../h/mtpr.h"
+#include "../h/clock.h"
 
 #define        SCHMAG  9/10
 
 
 #define        SCHMAG  9/10
 
+/*
+ * Constant for decay filter for cpu usage.
+ */
+double ccpu = 0.93550698503161773774;          /* exp(-1/15) */
 
 /*
 
 /*
- * clock is called straight from
+ * Clock is called straight from
  * the real time clock interrupt.
  *
  * Functions:
  * the real time clock interrupt.
  *
  * Functions:
@@ -33,13 +41,20 @@
 unsigned short kcount[20000];
 #endif
 
 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;
 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
 
        /*
         * reprime clock
@@ -88,6 +103,24 @@ caddr_t pc;
         * and time of day
         */
 out:
         * 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 (!noproc) {
                s = u.u_procp->p_rssize;
                u.u_vm.vm_idsrss += s;
@@ -99,26 +132,33 @@ out:
                }
                if (s > u.u_vm.vm_maxrss)
                        u.u_vm.vm_maxrss = s;
                }
                if (s > u.u_vm.vm_maxrss)
                        u.u_vm.vm_maxrss = s;
+               if ((u.u_vm.vm_utime+u.u_vm.vm_stime+1)/HZ > u.u_limit[LIM_CPU]) {
+                       psignal(u.u_procp, SIGXCPU);
+                       if (u.u_limit[LIM_CPU] < INFINITY - 5)
+                               u.u_limit[LIM_CPU] += 5;
+               }
        }
        }
-       a = dk_busy&07;
        if (USERMODE(ps)) {
                u.u_vm.vm_utime++;
                if(u.u_procp->p_nice > NZERO)
        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 {
        } else {
-               a += 16;
+               cpstate = CP_SYS;
                if (noproc)
                if (noproc)
-                       a += 8;
+                       cpstate = CP_IDLE;
                else
                        u.u_vm.vm_stime++;
        }
                else
                        u.u_vm.vm_stime++;
        }
-       dk_time[a]++;
+       dk_time[cpstate][dk_busy&(DK_NSTATES-1)]++;
        if (!noproc) {
                pp = u.u_procp;
        if (!noproc) {
                pp = u.u_procp;
+               pp->p_cpticks++;
                if(++pp->p_cpu == 0)
                        pp->p_cpu--;
                if(pp->p_cpu % 16 == 0) {
                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;
                }
                        if (pp->p_pri >= PUSER)
                                pp->p_pri = pp->p_usrpri;
                }
@@ -129,41 +169,59 @@ out:
                runrun++;
        }
        if (lbolt >= HZ) {
                runrun++;
        }
        if (lbolt >= HZ) {
+               extern int hangcnt;
+
                if (BASEPRI(ps))
                        return;
                lbolt -= HZ;
                ++time;
                if (BASEPRI(ps))
                        return;
                lbolt -= HZ;
                ++time;
-               VOID spl1();
+               (void) spl1();
+               /*
+                * machdep.c:unhang uses hangcnt to make sure uba
+                * doesn't forget to interrupt (this has been observed).
+                * This prevents an accumulation of < 5 second uba failures
+                * from summing to a uba reset.
+                */
+               if (hangcnt)
+                       hangcnt--;
                runrun++;
                wakeup((caddr_t)&lbolt);
                for(pp = &proc[0]; pp < &proc[NPROC]; pp++)
                runrun++;
                wakeup((caddr_t)&lbolt);
                for(pp = &proc[0]; pp < &proc[NPROC]; pp++)
-               if (pp->p_stat && pp->p_stat<SZOMB) {
+               if (pp->p_stat && pp->p_stat!=SZOMB) {
                        if(pp->p_time != 127)
                                pp->p_time++;
                        if(pp->p_clktim)
                                if(--pp->p_clktim == 0)
                                        if (pp->p_flag & STIMO) {
                                                s = spl6();
                        if(pp->p_time != 127)
                                pp->p_time++;
                        if(pp->p_clktim)
                                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);
                                                        setrun(pp);
+                                                       break;
+
+                                               case SSTOP:
+                                                       unsleep(pp);
+                                                       break;
+                                               }
                                                pp->p_flag &= ~STIMO;
                                                splx(s);
                                        } else
                                                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(pp->p_stat==SSLEEP||pp->p_stat==SSTOP)
                                if (pp->p_slptime != 127)
                                        pp->p_slptime++;
-                       if(pp->p_flag&SLOAD) {
-                               ave(pp->p_aveflt, pp->p_faults, 5);
-                               pp->p_faults = 0;
-                       }
+                       if (pp->p_flag&SLOAD)
+                               pp->p_pctcpu = ccpu * pp->p_pctcpu +
+                                   (1.0 - ccpu) * (pp->p_cpticks/(float)HZ);
+                       pp->p_cpticks = 0;
                        a = (pp->p_cpu & 0377)*SCHMAG + pp->p_nice - NZERO;
                        if(a < 0)
                                a = 0;
                        if(a > 255)
                                a = 255;
                        pp->p_cpu = a;
                        a = (pp->p_cpu & 0377)*SCHMAG + pp->p_nice - NZERO;
                        if(a < 0)
                                a = 0;
                        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) &&
                        s = spl6();
                        if(pp->p_pri >= PUSER) {
                                if ((pp != u.u_procp || noproc) &&
@@ -192,17 +250,19 @@ out:
                 */
                if (bclnlist != NULL)
                        wakeup((caddr_t)&proc[2]);
                 */
                if (bclnlist != NULL)
                        wakeup((caddr_t)&proc[2]);
-#ifdef ERNIE
                if (USERMODE(ps)) {
                        pp = u.u_procp;
                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;
                        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;
                        pp->p_pri = pp->p_usrpri;
-               }
 #endif
 #endif
+               }
        }
        }
+       if (!BASEPRI(ps))
+               unhang();
        if (USERMODE(ps)) {
                /*
                 * We do this last since it
        if (USERMODE(ps)) {
                /*
                 * We do this last since it
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.