Prepared by: | (jeffpc) on 2015-May-08 18:03 -0400 EDT |
---|---|
Workspace: | /home/jeffpc/illumos/xhat (at 0bfba88aae83) |
Compare against: | HEAD^ (at 3d7963f298bc) |
Summary of changes: | 2142 lines changed: 1 ins; 2112 del; 29 mod; 98942 unchg |
Patch of changes: | remove-whole-process-swapping.patch |
Printable review: | remove-whole-process-swapping.pdf |
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout3 lines changed: 0 ins; 3 del; 0 mod; 904 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout3 lines changed: 0 ins; 1 del; 2 mod; 90 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/findstack_subr.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout7 lines changed: 0 ins; 7 del; 0 mod; 415 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/kmem.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout8 lines changed: 0 ins; 8 del; 0 mod; 4373 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/cmd/mdb/common/modules/genunix/leaky_subr.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout13 lines changed: 1 ins; 12 del; 0 mod; 912 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/disp.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout143 lines changed: 0 ins; 141 del; 2 mod; 2558 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/fss.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout135 lines changed: 0 ins; 134 del; 1 mod; 2856 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/fx.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout48 lines changed: 0 ins; 48 del; 0 mod; 1798 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/rt.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout49 lines changed: 0 ins; 49 del; 0 mod; 1083 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/sysclass.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout14 lines changed: 0 ins; 14 del; 0 mod; 224 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/sysdc.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout10 lines changed: 0 ins; 10 del; 0 mod; 1307 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/thread.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 1 del; 1 mod; 2127 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/disp/ts.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout160 lines changed: 0 ins; 160 del; 0 mod; 2267 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/fs/nfs/nfs_srv.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 2 del; 0 mod; 3010 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/clock.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout38 lines changed: 0 ins; 38 del; 0 mod; 2627 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/condvar.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout6 lines changed: 0 ins; 6 del; 0 mod; 815 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/cpu.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout21 lines changed: 0 ins; 19 del; 2 mod; 3430 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/panic.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 421 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/sched.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout849 lines changed: 0 ins; 838 del; 11 mod; 90 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/timers.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout7 lines changed: 0 ins; 7 del; 0 mod; 1487 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/os/waitq.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout5 lines changed: 0 ins; 5 del; 0 mod; 388 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/class.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout6 lines changed: 0 ins; 6 del; 0 mod; 225 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/disp.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout4 lines changed: 0 ins; 4 del; 0 mod; 183 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/proc.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout5 lines changed: 0 ins; 3 del; 2 mod; 815 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/sysinfo.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout4 lines changed: 0 ins; 4 del; 0 mod; 287 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/systm.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout5 lines changed: 0 ins; 5 del; 0 mod; 499 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/thread.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout20 lines changed: 0 ins; 20 del; 0 mod; 702 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/sys/vmsystm.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 2 del; 0 mod; 166 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/anon.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 2 del; 0 mod; 500 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/as.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 311 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/hat.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout8 lines changed: 0 ins; 8 del; 0 mod; 619 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg.h
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 2 del; 0 mod; 285 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_dev.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 4101 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kmem.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 1643 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kp.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout10 lines changed: 0 ins; 8 del; 2 mod; 1456 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_kpm.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 340 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_map.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 2354 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_spt.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout10 lines changed: 0 ins; 10 del; 0 mod; 3086 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/seg_vn.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout185 lines changed: 0 ins; 185 del; 0 mod; 10108 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_anon.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout39 lines changed: 0 ins; 37 del; 2 mod; 3588 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/common/vm/vm_as.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout55 lines changed: 0 ins; 55 del; 0 mod; 3542 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/os/mlsetup.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 0 del; 1 mod; 497 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/os/trap.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 2253 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86pc/vm/hat_i86.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout82 lines changed: 0 ins; 82 del; 0 mod; 4416 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/i86xpv/vm/seg_mf.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 1 del; 0 mod; 784 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/intel/ia32/os/syscall.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout3 lines changed: 0 ins; 2 del; 1 mod; 1390 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sfmmu/vm/hat_sfmmu.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout144 lines changed: 0 ins; 143 del; 1 mod; 15519 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/os/syscall.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout2 lines changed: 0 ins; 2 del; 0 mod; 1231 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/v9/os/v9dep.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout9 lines changed: 0 ins; 9 del; 0 mod; 1865 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sparc/v9/vm/seg_nf.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout3 lines changed: 0 ins; 3 del; 0 mod; 495 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4/os/mlsetup.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout1 line changed: 0 ins; 0 del; 1 mod; 544 unchg
Cdiffs Udiffs Wdiffs Sdiffs Frames Old New Patch Raw usr/src/uts/sun4/os/trap.c
remove whole-process swapping Long before Unix supported paging, it used process swapping to reclaim memory. The code is there and in theory it runs when we get *extremely* low on memory. In practice, it never runs since the definition of low-on-memory is antiquated. (XXX: define what antiquated means) You can check the number of swapout/swapin events with kstats: $ kstat -p ::vm:swapin ::vm:swapout9 lines changed: 0 ins; 9 del; 0 mod; 1956 unchg
This code review page was prepared using /opt/onbld/bin/webrev. Webrev is maintained by the illumos project. The latest version may be obtained here.