Print this page
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:swapout
@@ -347,12 +347,10 @@
static fsspset_t *fsspsets;
static kmutex_t fsspsets_lock; /* protects fsspsets */
static id_t fss_cid;
-static time_t fss_minrun = 2; /* t_pri becomes 59 within 2 secs */
-static time_t fss_minslp = 2; /* min time on sleep queue for hardswap */
static int fss_quantum = 11;
static void fss_newpri(fssproc_t *, boolean_t);
static void fss_update(void *);
static int fss_update_list(int);
@@ -377,12 +375,10 @@
static int fss_parmsset(kthread_t *, void *, id_t, cred_t *);
static void fss_stop(kthread_t *, int, int);
static void fss_exit(kthread_t *);
static void fss_active(kthread_t *);
static void fss_inactive(kthread_t *);
-static pri_t fss_swapin(kthread_t *, int);
-static pri_t fss_swapout(kthread_t *, int);
static void fss_trapret(kthread_t *);
static void fss_preempt(kthread_t *);
static void fss_setrun(kthread_t *);
static void fss_sleep(kthread_t *);
static void fss_tick(kthread_t *);
@@ -415,12 +411,10 @@
fss_parmsset,
fss_stop,
fss_exit,
fss_active,
fss_inactive,
- fss_swapin,
- fss_swapout,
fss_trapret,
fss_preempt,
fss_setrun,
fss_sleep,
fss_tick,
@@ -2138,111 +2132,10 @@
fss_nullsys()
{
}
/*
- * fss_swapin() returns -1 if the thread is loaded or is not eligible to be
- * swapped in. Otherwise, it returns the thread's effective priority based
- * on swapout time and size of process (0 <= epri <= 0 SHRT_MAX).
- */
-/*ARGSUSED*/
-static pri_t
-fss_swapin(kthread_t *t, int flags)
-{
- fssproc_t *fssproc = FSSPROC(t);
- long epri = -1;
- proc_t *pp = ttoproc(t);
-
- ASSERT(THREAD_LOCK_HELD(t));
-
- if (t->t_state == TS_RUN && (t->t_schedflag & TS_LOAD) == 0) {
- time_t swapout_time;
-
- swapout_time = (ddi_get_lbolt() - t->t_stime) / hz;
- if (INHERITED(t) || (fssproc->fss_flags & FSSKPRI)) {
- epri = (long)DISP_PRIO(t) + swapout_time;
- } else {
- /*
- * Threads which have been out for a long time,
- * have high user mode priority and are associated
- * with a small address space are more deserving.
- */
- epri = fssproc->fss_umdpri;
- ASSERT(epri >= 0 && epri <= fss_maxumdpri);
- epri += swapout_time - pp->p_swrss / nz(maxpgio)/2;
- }
- /*
- * Scale epri so that SHRT_MAX / 2 represents zero priority.
- */
- epri += SHRT_MAX / 2;
- if (epri < 0)
- epri = 0;
- else if (epri > SHRT_MAX)
- epri = SHRT_MAX;
- }
- return ((pri_t)epri);
-}
-
-/*
- * fss_swapout() returns -1 if the thread isn't loaded or is not eligible to
- * be swapped out. Otherwise, it returns the thread's effective priority
- * based on if the swapper is in softswap or hardswap mode.
- */
-static pri_t
-fss_swapout(kthread_t *t, int flags)
-{
- fssproc_t *fssproc = FSSPROC(t);
- long epri = -1;
- proc_t *pp = ttoproc(t);
- time_t swapin_time;
-
- ASSERT(THREAD_LOCK_HELD(t));
-
- if (INHERITED(t) ||
- (fssproc->fss_flags & FSSKPRI) ||
- (t->t_proc_flag & TP_LWPEXIT) ||
- (t->t_state & (TS_ZOMB|TS_FREE|TS_STOPPED|TS_ONPROC|TS_WAIT)) ||
- !(t->t_schedflag & TS_LOAD) ||
- !(SWAP_OK(t)))
- return (-1);
-
- ASSERT(t->t_state & (TS_SLEEP | TS_RUN));
-
- swapin_time = (ddi_get_lbolt() - t->t_stime) / hz;
-
- if (flags == SOFTSWAP) {
- if (t->t_state == TS_SLEEP && swapin_time > maxslp) {
- epri = 0;
- } else {
- return ((pri_t)epri);
- }
- } else {
- pri_t pri;
-
- if ((t->t_state == TS_SLEEP && swapin_time > fss_minslp) ||
- (t->t_state == TS_RUN && swapin_time > fss_minrun)) {
- pri = fss_maxumdpri;
- epri = swapin_time -
- (rm_asrss(pp->p_as) / nz(maxpgio)/2) - (long)pri;
- } else {
- return ((pri_t)epri);
- }
- }
-
- /*
- * Scale epri so that SHRT_MAX / 2 represents zero priority.
- */
- epri += SHRT_MAX / 2;
- if (epri < 0)
- epri = 0;
- else if (epri > SHRT_MAX)
- epri = SHRT_MAX;
-
- return ((pri_t)epri);
-}
-
-/*
* If thread is currently at a kernel mode priority (has slept) and is
* returning to the userland we assign it the appropriate user mode priority
* and time quantum here. If we're lowering the thread's priority below that
* of other runnable threads then we will set runrun via cpu_surrender() to
* cause preemption.
@@ -2269,20 +2162,10 @@
fssproc->fss_flags &= ~FSSKPRI;
if (DISP_MUST_SURRENDER(t))
cpu_surrender(t);
}
-
- /*
- * Swapout lwp if the swapper is waiting for this thread to reach
- * a safe point.
- */
- if (t->t_schedflag & TS_SWAPENQ) {
- thread_unlock(t);
- swapout_lwp(ttolwp(t));
- thread_lock(t);
- }
}
/*
* Arrange for thread to be placed in appropriate location on dispatcher queue.
* This is called with the current thread in TS_ONPROC and locked.
@@ -2323,18 +2206,10 @@
if (!(fssproc->fss_flags & FSSKPRI) && CPUCAPS_ENFORCE(t))
return;
}
/*
- * If preempted in user-land mark the thread as swappable because it
- * cannot be holding any kernel locks.
- */
- ASSERT(t->t_schedflag & TS_DONT_SWAP);
- if (lwp != NULL && lwp->lwp_state == LWP_USER)
- t->t_schedflag &= ~TS_DONT_SWAP;
-
- /*
* Check to see if we're doing "preemption control" here. If
* we are, and if the user has requested that this thread not
* be preempted, and if preemptions haven't been put off for
* too long, let the preemption happen here but try to make
* sure the thread is rescheduled as soon as possible. We do
@@ -2354,11 +2229,10 @@
if (!(fssproc->fss_flags & FSSRESTORE)) {
fssproc->fss_scpri = t->t_pri;
fssproc->fss_flags |= FSSRESTORE;
}
THREAD_CHANGE_PRI(t, fss_maxumdpri);
- t->t_schedflag |= TS_DONT_SWAP;
}
schedctl_set_yield(t, 1);
setfrontdq(t);
return;
} else {
@@ -2460,24 +2334,21 @@
fssproc->fss_flags &= ~FSSKPRI;
THREAD_CHANGE_PRI(t, fssproc->fss_umdpri);
if (DISP_MUST_SURRENDER(curthread))
cpu_surrender(t);
}
- t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */
}
/*
* A tick interrupt has ocurrend on a running thread. Check to see if our
- * time slice has expired. We must also clear the TS_DONT_SWAP flag in
- * t_schedflag if the thread is eligible to be swapped out.
+ * time slice has expired.
*/
static void
fss_tick(kthread_t *t)
{
fssproc_t *fssproc;
fssproj_t *fssproj;
- klwp_t *lwp;
boolean_t call_cpu_surrender = B_FALSE;
boolean_t cpucaps_enforce = B_FALSE;
ASSERT(MUTEX_HELD(&(ttoproc(t))->p_lock));
@@ -2545,14 +2416,10 @@
* be necessary to adjust its position on a sleep queue
* or dispatch queue. The function thread_change_pri
* accomplishes this.
*/
if (thread_change_pri(t, new_pri, 0)) {
- if ((t->t_schedflag & TS_LOAD) &&
- (lwp = t->t_lwp) &&
- lwp->lwp_state == LWP_USER)
- t->t_schedflag &= ~TS_DONT_SWAP;
fssproc->fss_timeleft = fss_quantum;
} else {
call_cpu_surrender = B_TRUE;
}
} else if (t->t_state == TS_ONPROC &&
@@ -2612,11 +2479,10 @@
ASSERT(THREAD_LOCK_HELD(t));
ASSERT(t->t_state == TS_SLEEP);
fss_active(t);
- t->t_stime = ddi_get_lbolt(); /* time stamp for the swapper */
fssproc = FSSPROC(t);
fssproc->fss_flags &= ~FSSBACKQ;
if (fssproc->fss_flags & FSSKPRI) {
/*