void show_vmstat_top(vmtotal_t *Total, uvmexp_sysctl_t *uvm, uvmexp_sysctl_t *uvm1) { float f1, f2; int psiz; int i, l, c; struct { struct uvmexp_sysctl *uvmexp; } us, us1; us.uvmexp = uvm; us1.uvmexp = uvm1; putint(ucount(), STATROW, STATCOL, 3); putfloat(avenrun[0], STATROW, STATCOL + 17, 6, 2, 0); putfloat(avenrun[1], STATROW, STATCOL + 23, 6, 2, 0); putfloat(avenrun[2], STATROW, STATCOL + 29, 6, 2, 0); mvaddstr(STATROW, STATCOL + 53, buf); putint(Total->t_rq - 1, PROCSROW + 1, PROCSCOL + 3, 3); putint(Total->t_dw, PROCSROW + 1, PROCSCOL + 6, 3); putint(Total->t_sl, PROCSROW + 1, PROCSCOL + 9, 3); PUTRATE(us, us1, uvmexp->swtch, GENSTATROW + 1, GENSTATCOL - 1, 7); PUTRATE(us, us1, uvmexp->traps, GENSTATROW + 1, GENSTATCOL + 7, 6); PUTRATE(us, us1, uvmexp->syscalls, GENSTATROW + 1, GENSTATCOL + 14, 6); PUTRATE(us, us1, uvmexp->intrs, GENSTATROW + 1, GENSTATCOL + 21, 5); PUTRATE(us, us1, uvmexp->softs, GENSTATROW + 1, GENSTATCOL + 27, 6); PUTRATE(us, us1, uvmexp->faults, GENSTATROW + 1, GENSTATCOL + 34, 6); /* Last CPU state not calculated yet. */ for (f2 = 0.0, psiz = 0, c = 0; c < CPUSTATES; c++) { i = cpuorder[c]; f1 = cputime(i); f2 += f1; l = (int) ((f2 + 1.0) / 2.0) - psiz; if (c == 0) putfloat(f1, GRAPHROW, GRAPHCOL + 1, 5, 1, 0); else putfloat(f1, GRAPHROW, GRAPHCOL + 10 * c + 1, 5, 1, 0); mvhline(GRAPHROW + 2, psiz, cpuchar[c], l); psiz += l; } PUTRATE(us, us1, uvmexp->pageins, PAGEROW + 2, PAGECOL + 5, 5); PUTRATE(us, us1, uvmexp->pdpageouts, PAGEROW + 2, PAGECOL + 10, 5); PUTRATE(us, us1, uvmexp->pgswapin, PAGEROW + 3, PAGECOL + 5, 5); PUTRATE(us, us1, uvmexp->pgswapout, PAGEROW + 3, PAGECOL + 10, 5); }
int print_header(void) { time_t now; int start = dispstart + 1, end = dispstart + maxprint; char tmpbuf[TIMEPOS]; char header[MAX_LINE_BUF]; if (end > num_disp) end = num_disp; tb_start(); if (!paused) { getloadavg(avenrun, sizeof(avenrun) / sizeof(avenrun[0])); snprintf(uloadbuf, sizeof(uloadbuf), "%5d users Load %.2f %.2f %.2f", ucount(), avenrun[0], avenrun[1], avenrun[2]); time(&now); strlcpy(timebuf, ctime(&now), sizeof(timebuf)); } if (num_disp && (start > 1 || end != num_disp)) snprintf(tmpbuf, sizeof(tmpbuf), "%s (%u-%u of %u) %s", uloadbuf, start, end, num_disp, paused ? "PAUSED" : ""); else snprintf(tmpbuf, sizeof(tmpbuf), "%s %s", uloadbuf, paused ? "PAUSED" : ""); snprintf(header, sizeof(header), "%-55s%s", tmpbuf, timebuf); if (rawmode) printf("\n\n%s\n", header); else mvprintw(0, 0, "%s", header); return (1); }
void showkre(void) { float f1, f2; int psiz; int i, lc; long inttotal; long l; static int failcnt = 0; double total_time; etime = 0; CP_UPDATE(cp_time.cp_user); CP_UPDATE(cp_time.cp_nice); CP_UPDATE(cp_time.cp_sys); CP_UPDATE(cp_time.cp_intr); CP_UPDATE(cp_time.cp_idle); total_time = etime; if (total_time == 0.0) total_time = 1.0; if (etime < 100000.0) { /* < 100ms ignore this trash */ if (failcnt++ >= MAXFAIL) { clear(); mvprintw(2, 10, "The alternate system clock has died!"); mvprintw(3, 10, "Reverting to ``pigs'' display."); move(CMDLINE, 0); refresh(); failcnt = 0; sleep(5); command("pigs"); } return; } failcnt = 0; etime /= 1000000.0; etime /= ncpu; if (etime == 0) etime = 1; inttotal = 0; for (i = 0; i < nintr; i++) { if (s.intrcnt[i] == 0) continue; if (intrloc[i] == 0) { if (nextintsrow == LINES) continue; intrloc[i] = nextintsrow++; mvprintw(intrloc[i], INTSCOL + 9, "%-10.10s", intrname[i]); } X(intrcnt); l = (long)((float)s.intrcnt[i]/etime + 0.5); inttotal += l; put64(l, intrloc[i], INTSCOL + 2, 6, 'D'); } put64(inttotal, INTSROW + 1, INTSCOL + 2, 6, 'D'); Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss); Z(ncs_longhits); Z(ncs_longmiss); Z(ncs_neghits); s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits + nchtotal.ncs_miss + nchtotal.ncs_neghits; s.nchpathcount = nchtotal.ncs_longhits + nchtotal.ncs_longmiss; if (state == TIME) { s1.nchcount = s.nchcount; s1.nchpathcount = s.nchpathcount; } psiz = 0; f2 = 0.0; for (lc = 0; lc < CPUSTATES; lc++) { uint64_t val = *(uint64_t *)(((uint8_t *)&s.cp_time) + cpuoffsets[lc]); f1 = 100.0 * val / total_time; f2 += f1; l = (int) ((f2 + 1.0) / 2.0) - psiz; if (f1 > 99.9) f1 = 99.9; /* no room to display 100.0 */ putfloat(f1, GRAPHROW, GRAPHCOL + 10 * lc, 4, 1, 0); move(GRAPHROW + 2, psiz); psiz += l; while (l-- > 0) addch(cpuchar[lc]); } put64(ucount(), STATROW, STATCOL, 3, 'D'); putfloat(avenrun[0], STATROW, STATCOL + 18, 6, 2, 0); putfloat(avenrun[1], STATROW, STATCOL + 25, 6, 2, 0); putfloat(avenrun[2], STATROW, STATCOL + 32, 6, 2, 0); mvaddstr(STATROW, STATCOL + 53, buf); #define pgtokb(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size / 1024) #define pgtomb(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size / (1024 * 1024)) #define pgtob(pg) (int64_t)((intmax_t)(pg) * vms.v_page_size) put64(pgtob(total.t_arm), MEMROW + 2, MEMCOL + 4, 6, 0); put64(pgtob(total.t_armshr), MEMROW + 2, MEMCOL + 11, 6, 0); put64(pgtob(total.t_avm), MEMROW + 2, MEMCOL + 19, 6, 0); put64(pgtob(total.t_avmshr), MEMROW + 2, MEMCOL + 26, 6, 0); put64(pgtob(total.t_rm), MEMROW + 3, MEMCOL + 4, 6, 0); put64(pgtob(total.t_rmshr), MEMROW + 3, MEMCOL + 11, 6, 0); put64(pgtob(total.t_vm), MEMROW + 3, MEMCOL + 19, 6, 0); put64(pgtob(total.t_vmshr), MEMROW + 3, MEMCOL + 26, 6, 0); put64(pgtob(total.t_free), MEMROW + 2, MEMCOL + 34, 6, 0); put64(total.t_rq - 1, PROCSROW + 1, PROCSCOL + 0, 3, 'D'); put64(total.t_pw, PROCSROW + 1, PROCSCOL + 3, 3, 'D'); put64(total.t_dw, PROCSROW + 1, PROCSCOL + 6, 3, 'D'); put64(total.t_sl, PROCSROW + 1, PROCSCOL + 9, 3, 'D'); put64(total.t_sw, PROCSROW + 1, PROCSCOL + 12, 3, 'D'); if (extended_vm_stats == 0) { PUTRATE(Vmm.v_zfod, VMSTATROW + 0, VMSTATCOL, 7); } PUTRATE(Vmm.v_cow_faults, VMSTATROW + 1, VMSTATCOL, 7); put64(pgtob(vms.v_wire_count), VMSTATROW + 2, VMSTATCOL, 7, 0); put64(pgtob(vms.v_active_count), VMSTATROW + 3, VMSTATCOL, 7, 0); put64(pgtob(vms.v_inactive_count), VMSTATROW + 4, VMSTATCOL, 7, 0); put64(pgtob(vms.v_cache_count), VMSTATROW + 5, VMSTATCOL, 7, 0); put64(pgtob(vms.v_free_count), VMSTATROW + 6, VMSTATCOL, 7, 0); PUTRATE(Vmm.v_dfree, VMSTATROW + 7, VMSTATCOL, 7); PUTRATE(Vmm.v_pfree, VMSTATROW + 8, VMSTATCOL, 7); PUTRATE(Vmm.v_reactivated, VMSTATROW + 9, VMSTATCOL, 7); PUTRATE(Vmm.v_pdwakeups, VMSTATROW + 10, VMSTATCOL, 7); PUTRATE(Vmm.v_pdpages, VMSTATROW + 11, VMSTATCOL, 7); PUTRATE(Vmm.v_intrans, VMSTATROW + 12, VMSTATCOL, 7); if (extended_vm_stats) { PUTRATE(Vmm.v_zfod, VMSTATROW + 11, VMSTATCOL - 16, 9); PUTRATE(Vmm.v_ozfod, VMSTATROW + 12, VMSTATCOL - 16, 9); #define nz(x) ((x) ? (x) : 1) put64((s.Vmm.v_zfod - s.Vmm.v_ozfod) * 100 / nz(s.Vmm.v_zfod), VMSTATROW + 13, VMSTATCOL - 16, 9, 'D'); #undef nz PUTRATE(Vmm.v_tfree, VMSTATROW + 14, VMSTATCOL - 16, 9); } put64(s.bufspace, VMSTATROW + 13, VMSTATCOL, 7, 0); put64(s.dirtybufspace/1024, VMSTATROW + 14, VMSTATCOL, 7, 'k'); put64(s.desiredvnodes, VMSTATROW + 15, VMSTATCOL, 7, 'D'); put64(s.numvnodes, VMSTATROW + 16, VMSTATCOL, 7, 'D'); put64(s.freevnodes, VMSTATROW + 17, VMSTATCOL, 7, 'D'); PUTRATE(Vmm.v_vnodein, PAGEROW + 2, PAGECOL + 6, 4); PUTRATE(Vmm.v_vnodeout, PAGEROW + 2, PAGECOL + 11, 4); PUTRATE(Vmm.v_swapin, PAGEROW + 2, PAGECOL + 18, 4); PUTRATE(Vmm.v_swapout, PAGEROW + 2, PAGECOL + 23, 4); PUTRATE(Vmm.v_vnodepgsin, PAGEROW + 3, PAGECOL + 6, 4); PUTRATE(Vmm.v_vnodepgsout, PAGEROW + 3, PAGECOL + 11, 4); PUTRATE(Vmm.v_swappgsin, PAGEROW + 3, PAGECOL + 18, 4); PUTRATE(Vmm.v_swappgsout, PAGEROW + 3, PAGECOL + 23, 4); PUTRATE(Vmm.v_swtch, GENSTATROW + 1, GENSTATCOL + 1, 4); PUTRATE(Vmm.v_trap, GENSTATROW + 1, GENSTATCOL + 6, 4); PUTRATE(Vmm.v_syscall, GENSTATROW + 1, GENSTATCOL + 11, 4); PUTRATE(Vmm.v_intr, GENSTATROW + 1, GENSTATCOL + 16, 4); PUTRATE(Vmm.v_soft, GENSTATROW + 1, GENSTATCOL + 21, 4); PUTRATE(Vmm.v_vm_faults, GENSTATROW + 1, GENSTATCOL + 26, 4); mvprintw(DISKROW, DISKCOL + 5, " "); for (i = 0, lc = 0; i < num_devices && lc < MAXDRIVES; i++) if (dev_select[i].selected) { char tmpstr[80]; sprintf(tmpstr, "%s%d", dev_select[i].device_name, dev_select[i].unit_number); mvprintw(DISKROW, DISKCOL + 5 + 6 * lc, " %5.5s", tmpstr); switch(state) { case TIME: dinfo(i, ++lc, &cur, &last); break; case RUN: dinfo(i, ++lc, &cur, &run); break; case BOOT: dinfo(i, ++lc, &cur, NULL); break; } } #define nz(x) ((x) ? (x) : 1) put64(s.nchpathcount, NAMEIROW + 1, NAMEICOL + 3, 9, 'D'); put64(nchtotal.ncs_longhits, NAMEIROW + 1, NAMEICOL + 12, 7, 'D'); putfloat(nchtotal.ncs_longhits * 100.0 / nz(s.nchpathcount), NAMEIROW + 1, NAMEICOL + 19, 4, 0, 0); putfloat((double)s.nchcount / nz(s.nchpathcount), NAMEIROW + 1, NAMEICOL + 27, 5, 2, 1); #undef nz }
void showkre(void) { float f1, f2; int psiz, inttotal; int i, l, lc; static int failcnt = 0; etime = 0; for(i = 0; i < CPUSTATES; i++) { X(time); Q(cp_time); etime += s.time[i]; } if (etime < 5.0) { /* < 5 ticks - ignore this trash */ if (failcnt++ >= MAXFAIL) { clear(); mvprintw(2, 10, "The alternate system clock has died!"); mvprintw(3, 10, "Reverting to ``pigs'' display."); move(CMDLINE, 0); refresh(); failcnt = 0; sleep(5); command("pigs"); } return; } failcnt = 0; etime /= hertz; etime /= ncpu; inttotal = 0; for (i = 0; i < nintr; i++) { if (s.intrcnt[i] == 0) continue; X(intrcnt); l = (int)((float)s.intrcnt[i]/etime + 0.5); inttotal += l; if (intrloc[i] == 0) { if (nextintsrow == LINES) continue; intrloc[i] = nextintsrow++; mvprintw(intrloc[i], INTSCOL + 6, "%-10.10s", intrname[i]); } putint(l, intrloc[i], INTSCOL, 5); } putint(inttotal, INTSROW + 1, INTSCOL, 5); Z(ncs_goodhits); Z(ncs_badhits); Z(ncs_miss); Z(ncs_long); Z(ncs_pass2); Z(ncs_2passes); Z(ncs_neghits); s.nchcount = nchtotal.ncs_goodhits + nchtotal.ncs_badhits + nchtotal.ncs_miss + nchtotal.ncs_long + nchtotal.ncs_neghits; if (state == TIME) s1.nchcount = s.nchcount; psiz = 0; f2 = 0.0; for (lc = 0; lc < CPUSTATES; lc++) { i = cpuorder[lc]; f1 = cputime(i); f2 += f1; l = (int) ((f2 + 1.0) / 2.0) - psiz; putfloat(f1, GRAPHROW, GRAPHCOL + 10 * lc, 4, 1, 0); move(GRAPHROW + 2, psiz); psiz += l; while (l-- > 0) addch(cpuchar[lc]); } putint(ucount(), STATROW, STATCOL, 5); putfloat(avenrun[0], STATROW, STATCOL + 20, 5, 2, 0); putfloat(avenrun[1], STATROW, STATCOL + 26, 5, 2, 0); putfloat(avenrun[2], STATROW, STATCOL + 32, 5, 2, 0); mvaddstr(STATROW, STATCOL + 55, buf); #define pgtokb(pg) ((pg) * (s.v_page_size / 1024)) putfloat(100.0 * (v_page_count - total.t_free) / v_page_count, STATROW + 1, STATCOL + 15, 2, 0, 1); putfloat(100.0 * s.v_kmem_map_size / kmem_size, STATROW + 1, STATCOL + 22, 2, 0, 1); putint(pgtokb(total.t_arm), MEMROW + 2, MEMCOL + 4, 7); putint(pgtokb(total.t_armshr), MEMROW + 2, MEMCOL + 12, 7); putint(pgtokb(total.t_avm), MEMROW + 2, MEMCOL + 20, 8); putint(pgtokb(total.t_avmshr), MEMROW + 2, MEMCOL + 29, 8); putint(pgtokb(total.t_rm), MEMROW + 3, MEMCOL + 4, 7); putint(pgtokb(total.t_rmshr), MEMROW + 3, MEMCOL + 12, 7); putint(pgtokb(total.t_vm), MEMROW + 3, MEMCOL + 20, 8); putint(pgtokb(total.t_vmshr), MEMROW + 3, MEMCOL + 29, 8); putint(pgtokb(total.t_free), MEMROW + 2, MEMCOL + 38, 7); putint(total.t_rq - 1, PROCSROW + 2, PROCSCOL, 3); putint(total.t_pw, PROCSROW + 2, PROCSCOL + 4, 3); putint(total.t_dw, PROCSROW + 2, PROCSCOL + 8, 3); putint(total.t_sl, PROCSROW + 2, PROCSCOL + 12, 3); putint(total.t_sw, PROCSROW + 2, PROCSCOL + 16, 3); PUTRATE(v_io_faults, VMSTATROW, VMSTATCOL + 2, 8 - 2); PUTRATE(v_cow_faults, VMSTATROW + 1, VMSTATCOL + 2, 8 - 2); PUTRATE(v_zfod, VMSTATROW + 2, VMSTATCOL + 2, 8 - 2); PUTRATE(v_ozfod, VMSTATROW + 3, VMSTATCOL, 8); putint(s.v_zfod != 0 ? (int)(s.v_ozfod * 100.0 / s.v_zfod) : 0, VMSTATROW + 4, VMSTATCOL + 1, 8 - 1); PUTRATE(v_dfree, VMSTATROW + 5, VMSTATCOL + 2, 8 - 2); PUTRATE(v_pfree, VMSTATROW + 6, VMSTATCOL + 2, 8 - 2); PUTRATE(v_tfree, VMSTATROW + 7, VMSTATCOL, 8); PUTRATE(v_reactivated, VMSTATROW + 8, VMSTATCOL, 8); PUTRATE(v_pdwakeups, VMSTATROW + 9, VMSTATCOL, 8); PUTRATE(v_pdpages, VMSTATROW + 10, VMSTATCOL, 8); PUTRATE(v_intrans, VMSTATROW + 11, VMSTATCOL, 8); putint(pgtokb(s.v_wire_count), VMSTATROW + 12, VMSTATCOL, 8); putint(pgtokb(s.v_active_count), VMSTATROW + 13, VMSTATCOL, 8); putint(pgtokb(s.v_inactive_count), VMSTATROW + 14, VMSTATCOL, 8); putint(pgtokb(s.v_free_count), VMSTATROW + 16, VMSTATCOL, 8); if (LINES - 1 > VMSTATROW + 17) putint(s.bufspace / 1024, VMSTATROW + 17, VMSTATCOL, 8); PUTRATE(v_vnodein, PAGEROW + 2, PAGECOL + 6, 5); PUTRATE(v_vnodeout, PAGEROW + 2, PAGECOL + 12, 5); PUTRATE(v_swapin, PAGEROW + 2, PAGECOL + 19, 5); PUTRATE(v_swapout, PAGEROW + 2, PAGECOL + 25, 5); PUTRATE(v_vnodepgsin, PAGEROW + 3, PAGECOL + 6, 5); PUTRATE(v_vnodepgsout, PAGEROW + 3, PAGECOL + 12, 5); PUTRATE(v_swappgsin, PAGEROW + 3, PAGECOL + 19, 5); PUTRATE(v_swappgsout, PAGEROW + 3, PAGECOL + 25, 5); PUTRATE(v_swtch, GENSTATROW + 1, GENSTATCOL, 4); PUTRATE(v_trap, GENSTATROW + 1, GENSTATCOL + 5, 4); PUTRATE(v_syscall, GENSTATROW + 1, GENSTATCOL + 10, 4); PUTRATE(v_intr, GENSTATROW + 1, GENSTATCOL + 15, 4); PUTRATE(v_soft, GENSTATROW + 1, GENSTATCOL + 20, 4); PUTRATE(v_vm_faults, GENSTATROW + 1, GENSTATCOL + 25, 4); for (i = 0, lc = 0; i < num_devices && lc < MAXDRIVES; i++) if (dev_select[i].selected) { switch(state) { case TIME: dinfo(i, ++lc, &cur, &last); break; case RUN: dinfo(i, ++lc, &cur, &run); break; case BOOT: dinfo(i, ++lc, &cur, NULL); break; } } putint(s.numdirtybuffers, VNSTATROW, VNSTATCOL, 7); putint(s.desiredvnodes, VNSTATROW + 1, VNSTATCOL, 7); putint(s.numvnodes, VNSTATROW + 2, VNSTATCOL, 7); putint(s.freevnodes, VNSTATROW + 3, VNSTATCOL, 7); putint(s.nchcount, NAMEIROW + 2, NAMEICOL, 8); putint((nchtotal.ncs_goodhits + nchtotal.ncs_neghits), NAMEIROW + 2, NAMEICOL + 9, 7); #define nz(x) ((x) ? (x) : 1) putfloat((nchtotal.ncs_goodhits+nchtotal.ncs_neghits) * 100.0 / nz(s.nchcount), NAMEIROW + 2, NAMEICOL + 17, 3, 0, 1); putint(nchtotal.ncs_pass2, NAMEIROW + 2, NAMEICOL + 21, 7); putfloat(nchtotal.ncs_pass2 * 100.0 / nz(s.nchcount), NAMEIROW + 2, NAMEICOL + 29, 3, 0, 1); #undef nz }