 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lwp.c,v 1.122 2008/07/14 01:19:37 rmind Exp $	*/
+/*	$NetBSD: kern_lwp.c,v 1.123 2008/10/07 09:48:27 rmind Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nathan J. Williams, and Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -196,27 +196,27 @@
+ *
  *		LSIDL, LSZOMB, LSSTOP, LSSUSPENDED
+ *
  *	Note that an LWP is considered running or likely to run soon if in
  *	one of the following states.  This affects the value of p_nrlwps:
+ *
  *		LSRUN, LSONPROC, LSSLEEP
+ *
  *	p_lock does not need to be held when transitioning among these
  *	three states.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.122 2008/07/14 01:19:37 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.123 2008/10/07 09:48:27 rmind Exp $");
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #define _LWP_API_PRIVATE
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/cpu.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/syscallargs.h>
 #include <sys/syscall_stats.h>
 @@ -921,27 +921,26 @@ lwp_free(struct lwp *l, bool recycle, bo
 	/*
 	 * Free the LWP's turnstile and the LWP structure itself unless the
 	 * caller wants to recycle them.  Also, free the scheduler specific
 	 * data.
+	 *
 	 * We can't return turnstile0 to the pool (it didn't come from it),
 	 * so if it comes up just drop it quietly and move on.
+	 *
 	 * We don't recycle the VM resources at this time.
 	 */
 	if (l->l_lwpctl != NULL)
 		lwp_ctl_free(l);
 	sched_lwp_exit(l);
 	if (!recycle && l->l_ts != &turnstile0)
 		pool_cache_put(turnstile_cache, l->l_ts);
 	if (l->l_name != NULL)
 		kmem_free(l->l_name, MAXCOMLEN);
 #ifndef __NO_CPU_LWP_FREE
 	cpu_lwp_free2(l);
 #endif
 	KASSERT((l->l_flag & LW_INMEM) != 0);
 	uvm_lwp_exit(l);
 	KASSERT(SLIST_EMPTY(&l->l_pi_lenders));
 	KASSERT(l->l_inheritedprio == -1);
 	if (!recycle)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_runq.c,v 1.21 2008/09/30 16:28:45 rmind Exp $	*/
+/*	$NetBSD: kern_runq.c,v 1.22 2008/10/07 09:48:27 rmind Exp $	*/
 /*
  * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD org>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,27 +17,27 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_runq.c,v 1.21 2008/09/30 16:28:45 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_runq.c,v 1.22 2008/10/07 09:48:27 rmind Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/bitops.h>
 #include <sys/cpu.h>
 #include <sys/idle.h>
 #include <sys/intr.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/sched.h>
 #include <sys/syscallargs.h>
 @@ -113,28 +113,28 @@ static u_int	cacheht_time;		/* Cache hot
 static u_int	min_catch;		/* Minimal LWP count for catching */
 static u_int	balance_period;		/* Balance period */
 static struct cpu_info *worker_ci;	/* Victim CPU */
 #ifdef MULTIPROCESSOR
 static struct callout balance_ch;	/* Callout of balancer */
 #endif
 void
 runq_init(void)
+{
 	/* Balancing */
 	worker_ci = curcpu();
-	cacheht_time = mstohz(3);		/* ~3 ms  */
+	cacheht_time = mstohz(3);		/*   ~3 ms */
-	balance_period = mstohz(300);		/* ~300ms */
+	balance_period = mstohz(300);		/* ~300 ms */
 	/* Minimal count of LWPs for catching */
 	min_catch = 1;
 	/* Initialize balancing callout and run it */
 #ifdef MULTIPROCESSOR
 	callout_init(&balance_ch, CALLOUT_MPSAFE);
 	callout_setfunc(&balance_ch, sched_balance, NULL);
 	callout_schedule(&balance_ch, balance_period);
 #endif
+}
 void
 @@ -629,26 +629,29 @@ sched_idle(void)
+{
+}
 #endif	/* MULTIPROCESSOR */
 /*
  * Scheduling statistics and balancing.
  */
 void
 sched_lwp_stats(struct lwp *l)
+{
 	int batch;
 	KASSERT(lwp_locked(l, NULL));
 	/* Update sleep time */
 	if (l->l_stat == LSSLEEP || l->l_stat == LSSTOP ||
 	    l->l_stat == LSSUSPENDED)
 		l->l_slptime++;
 	/*
 	 * Set that thread is more CPU-bound, if sum of run time exceeds the
 	 * sum of sleep time.  Check if thread is CPU-bound a first time.
 	 */
 	batch = (l->l_rticksum > l->l_slpticksum);
 	if (batch != 0) {
 		if ((l->l_flag & LW_BATCH) == 0)
 			batch = 0;
 		l->l_flag |= LW_BATCH;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sched_4bsd.c,v 1.23 2008/05/25 22:04:50 ad Exp $	*/
+/*	$NetBSD: sched_4bsd.c,v 1.24 2008/10/07 09:48:27 rmind Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2004, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, Andrew Doran, and
  * Daniel Sieger.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -58,27 +58,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)kern_synch.c	8.9 (Berkeley) 5/19/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sched_4bsd.c,v 1.23 2008/05/25 22:04:50 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sched_4bsd.c,v 1.24 2008/10/07 09:48:27 rmind Exp $");
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #include "opt_perfctrs.h"
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/callout.h>
 #include <sys/cpu.h>
 #include <sys/proc.h>
 #include <sys/kernel.h>
 #include <sys/signalvar.h>
 #include <sys/resourcevar.h>
 @@ -278,43 +278,34 @@ decay_cpu_batch(fixpt_t loadfac, fixpt_t
+	}
 	return estcpu;
+}
 /*
  * sched_pstats_hook:
+ *
  * Periodically called from sched_pstats(); used to recalculate priorities.
  */
 void
 sched_pstats_hook(struct lwp *l, int batch)
+{
 	fixpt_t loadfac;
 	int sleeptm;
 	/*
 	 * If the LWP has slept an entire second, stop recalculating
 	 * its priority until it wakes up.
 	 */
-	if (l->l_stat == LSSLEEP || l->l_stat == LSSTOP ||
+	KASSERT(lwp_locked(l, NULL));
-	    l->l_stat == LSSUSPENDED) {
+	if (l->l_slptime > 0) {
-		l->l_slptime++;
+		fixpt_t loadfac = 2 * (averunnable.ldavg[0]);
 		sleeptm = 1;
 	} else {
 		sleeptm = 0x7fffffff;
 	if (l->l_slptime <= sleeptm) {
 		loadfac = 2 * (averunnable.ldavg[0]);
 		l->l_estcpu = decay_cpu(loadfac, l->l_estcpu);
 		resetpriority(l);
+	}
+}
 /*
  * Recalculate the priority of a process after it has slept for a while.
  */
 static void
 updatepri(struct lwp *l)
+{
 	fixpt_t loadfac;
 @@ -462,32 +453,26 @@ void
 sched_slept(struct lwp *l)
+{
+}
 void
 sched_lwp_fork(struct lwp *l1, struct lwp *l2)
+{
 	l2->l_estcpu = l1->l_estcpu;
+}
 void
 sched_lwp_exit(struct lwp *l)
 void
 sched_lwp_collect(struct lwp *t)
+{
 	lwp_t *l;
 	/* Absorb estcpu value of collected LWP. */
 	l = curlwp;
 	lwp_lock(l);
 	l->l_estcpu += t->l_estcpu;
 	lwp_unlock(l);
+}
 void
 sched_oncpu(lwp_t *l)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sched_m2.c,v 1.25 2008/05/19 12:48:54 rmind Exp $	*/
+/*	$NetBSD: sched_m2.c,v 1.26 2008/10/07 09:48:27 rmind Exp $	*/
 /*
  * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD org>
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -23,27 +23,27 @@
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * TODO:
  *  - Implementation of fair share queue;
  *  - Support for NUMA;
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sched_m2.c,v 1.25 2008/05/19 12:48:54 rmind Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sched_m2.c,v 1.26 2008/10/07 09:48:27 rmind Exp $");
 #include <sys/param.h>
 #include <sys/bitops.h>
 #include <sys/cpu.h>
 #include <sys/callout.h>
 #include <sys/errno.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/mutex.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 @@ -65,55 +65,45 @@ __KERNEL_RCSID(0, "$NetBSD: sched_m2.c,v
 #define	PRI_HIGHEST_TS	(MAXPRI_USER)
 /*
  * Time-slices and priorities.
  */
 static u_int	min_ts;			/* Minimal time-slice */
 static u_int	max_ts;			/* Maximal time-slice */
 static u_int	rt_ts;			/* Real-time time-slice */
 static u_int	ts_map[PRI_COUNT];	/* Map of time-slices */
 static pri_t	high_pri[PRI_COUNT];	/* Map for priority increase */
 static void	sched_precalcts(void);
 typedef struct {
 	u_int		sl_timeslice;	/* Time-slice of thread */
 } sched_info_lwp_t;
 static pool_cache_t	sil_pool;
 /*
  * Initialization and setup.
  */
 void
 sched_rqinit(void)
+{
 	struct cpu_info *ci = curcpu();
 	if (hz < 100) {
 		panic("sched_rqinit: value of HZ is too low\n");
+	}
 	/* Default timing ranges */
-	min_ts = mstohz(50);			/* ~50ms  */
+	min_ts = mstohz(20);			/*  ~20 ms */
-	max_ts = mstohz(150);			/* ~150ms */
+	max_ts = mstohz(150);			/* ~150 ms */
-	rt_ts = mstohz(100);			/* ~100ms */
+	rt_ts = mstohz(100);			/* ~100 ms */
 	sched_precalcts();
 	/* Pool of the scheduler-specific structures */
 	sil_pool = pool_cache_init(sizeof(sched_info_lwp_t), coherency_unit,
 , 0, "lwpsd", NULL, IPL_NONE, NULL, NULL, NULL);
 	/* Attach the primary CPU here */
 	sched_cpuattach(ci);
 	sched_lwp_fork(NULL, &lwp0);
 	sched_newts(&lwp0);
+}
 /* Pre-calculate the time-slices for the priorities */
 static void
 sched_precalcts(void)
+{
 	pri_t p;
 @@ -142,85 +132,68 @@ sched_proc_fork(struct proc *parent, str
 	struct lwp *l;
 	LIST_FOREACH(l, &child->p_lwps, l_sibling) {
 		lwp_lock(l);
 		sched_newts(l);
 		lwp_unlock(l);
+	}
+}
 void
 sched_proc_exit(struct proc *child, struct proc *parent)
+{
 	/* Dummy */
+}
 void
 sched_lwp_fork(struct lwp *l1, struct lwp *l2)
+{
 	KASSERT(l2->l_sched_info == NULL);
 	l2->l_sched_info = pool_cache_get(sil_pool, PR_WAITOK);
 	memset(l2->l_sched_info, 0, sizeof(sched_info_lwp_t));
 void
 sched_lwp_exit(struct lwp *l)
 	KASSERT(l->l_sched_info != NULL);
 	pool_cache_put(sil_pool, l->l_sched_info);
 	l->l_sched_info = NULL;
+}
 void
 sched_lwp_collect(struct lwp *l)
+{
+}
 void
 sched_setrunnable(struct lwp *l)
+{
 	/* Dummy */
+}
 void
 sched_schedclock(struct lwp *l)
+{
 	/* Dummy */
+}
 /*
  * Priorities and time-slice.
  */
 void
 sched_nice(struct proc *p, int prio)
+{
 	/* TODO: implement as SCHED_IA */
+}
 /* Recalculate the time-slice */
 void
 sched_newts(struct lwp *l)
+{
 	sched_info_lwp_t *sil = l->l_sched_info;
-	sil->sl_timeslice = ts_map[lwp_eprio(l)];
+	l->l_sched.timeslice = ts_map[lwp_eprio(l)];
+}
 void
 sched_slept(struct lwp *l)
+{
 	/*
 	 * If thread is in time-sharing queue and batch flag is not marked,
 	 * increase the the priority, and run with the lower time-quantum.
 	 */
 	if (l->l_priority < PRI_HIGHEST_TS && (l->l_flag & LW_BATCH) == 0) {
 		KASSERT(l->l_class == SCHED_OTHER);
 		l->l_priority++;
 @@ -235,107 +208,106 @@ sched_wakeup(struct lwp *l)
 	if (l->l_slptime >= 1)
 		l->l_priority = high_pri[l->l_priority];
+}
 void
 sched_pstats_hook(struct lwp *l, int batch)
+{
 	pri_t prio;
 	/*
 	 * Estimate threads on time-sharing queue only, however,
 	 * exclude the highest priority for performance purposes.
 	 */
 	KASSERT(lwp_locked(l, NULL));
 	if (l->l_priority >= PRI_HIGHEST_TS)
 		return;
 	KASSERT(l->l_class == SCHED_OTHER);
 	/* If it is CPU-bound not a first time - decrease the priority */
 	prio = l->l_priority;
 	if (batch && prio != 0)
 		prio--;
 	/* If thread was not ran a second or more - set a high priority */
 	if (l->l_stat == LSRUN) {
 		if (l->l_rticks && (hardclock_ticks - l->l_rticks >= hz))
 			prio = high_pri[prio];
 		/* Re-enqueue the thread if priority has changed */
 		if (prio != l->l_priority)
 			lwp_changepri(l, prio);
 	} else {
 		/* In other states, change the priority directly */
 		l->l_priority = prio;
+	}
+}
 void
 sched_oncpu(lwp_t *l)
+{
-	sched_info_lwp_t *sil = l->l_sched_info;
+	struct schedstate_percpu *spc = &l->l_cpu->ci_schedstate;
 	/* Update the counters */
-	sil = l->l_sched_info;
+	KASSERT(l->l_sched.timeslice >= min_ts);
-	KASSERT(sil->sl_timeslice >= min_ts);
+	KASSERT(l->l_sched.timeslice <= max_ts);
-	KASSERT(sil->sl_timeslice <= max_ts);
+	spc->spc_ticks = l->l_sched.timeslice;
 	l->l_cpu->ci_schedstate.spc_ticks = sil->sl_timeslice;
+}
 /*
  * Time-driven events.
  */
 /*
  * Called once per time-quantum.  This routine is CPU-local and runs at
  * IPL_SCHED, thus the locking is not needed.
  */
 void
 sched_tick(struct cpu_info *ci)
+{
 	struct schedstate_percpu *spc = &ci->ci_schedstate;
 	struct lwp *l = curlwp;
 	const sched_info_lwp_t *sil = l->l_sched_info;
-	if (CURCPU_IDLE_P())
+	if (__predict_false(CURCPU_IDLE_P()))
 		return;
 	switch (l->l_class) {
 	case SCHED_FIFO:
 		/*
 		 * Update the time-quantum, and continue running,
 		 * if thread runs on FIFO real-time policy.
 		 */
 		KASSERT(l->l_priority > PRI_HIGHEST_TS);
-		spc->spc_ticks = sil->sl_timeslice;
+		spc->spc_ticks = l->l_sched.timeslice;
 		return;
 	case SCHED_OTHER:
 		/*
 		 * If thread is in time-sharing queue, decrease the priority,
 		 * and run with a higher time-quantum.
 		 */
 		KASSERT(l->l_priority <= PRI_HIGHEST_TS);
 		if (l->l_priority != 0)
 			l->l_priority--;
 		break;
+	}
 	/*
 	 * If there are higher priority threads or threads in the same queue,
 	 * mark that thread should yield, otherwise, continue running.
 	 */
 	if (lwp_eprio(l) <= spc->spc_maxpriority || l->l_target_cpu) {
 		spc->spc_flags |= SPCF_SHOULDYIELD;
 		cpu_need_resched(ci, 0);
 	} else
-		spc->spc_ticks = sil->sl_timeslice;
+		spc->spc_ticks = l->l_sched.timeslice;
+}
 /*
  * Sysctl nodes and initialization.
  */
 static int
 sysctl_sched_rtts(SYSCTLFN_ARGS)
+{
 	struct sysctlnode node;
 	int rttsms = hztoms(rt_ts);
 	node = *rnode;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: lwp.h,v 1.107 2008/08/28 06:21:22 yamt Exp $	*/
+/*	$NetBSD: lwp.h,v 1.108 2008/10/07 09:48:27 rmind Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nathan J. Williams and Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
 @@ -60,27 +60,30 @@
  * S:	l_selcpu->sc_lock
  * (:	unlocked, stable
  * !:	unlocked, may only be reliably accessed by the LWP itself
  * ?:	undecided
+ *
  * Fields are clustered together by usage (to increase the likelyhood
  * of cache hits) and by size (to reduce dead space in the structure).
  */
 struct lockdebug;
 struct lwp {
 	/* Scheduling and overall state */
 	TAILQ_ENTRY(lwp) l_runq;	/* s: run queue */
-	void		*l_sched_info;	/* s: Scheduler-specific structure */
+	union {
 		void *	info;		/* s: scheduler-specific structure */
 		u_int	timeslice;	/* l: time-quantum for SCHED_M2 */
 	} l_sched;
 	struct cpu_info *volatile l_cpu;/* s: CPU we're on if LSONPROC */
 	kmutex_t * volatile l_mutex;	/* l: ptr to mutex on sched state */
 	int		l_ctxswtch;	/* l: performing a context switch */
 	struct user	*l_addr;	/* l: KVA of u-area (PROC ONLY) */
 	struct mdlwp	l_md;		/* l: machine-dependent fields. */
 	int		l_flag;		/* l: misc flag values */
 	int		l_stat;		/* l: overall LWP status */
 	struct bintime 	l_rtime;	/* l: real time */
 	struct bintime	l_stime;	/* l: start time (while ONPROC) */
 	u_int		l_swtime;	/* l: time swapped in or out */
 	u_int		l_holdcnt;	/* l: if non-zero, don't swap */
 	u_int		l_rticks;	/* l: Saved start time of run */
 	u_int		l_rticksum;	/* l: Sum of ticks spent running */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sched.h,v 1.64 2008/08/10 10:19:19 martin Exp $	*/
+/*	$NetBSD: sched.h,v 1.65 2008/10/07 09:48:27 rmind Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2002, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Ross Harvey, Jason R. Thorpe, Nathan J. Williams, Andrew Doran and
  * Daniel Sieger.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -90,27 +90,26 @@ struct sched_param {
 #define	SCHED_RR	2
 #if defined(_NETBSD_SOURCE)
 __BEGIN_DECLS
 /*
  * Interface of CPU-sets.
  */
 typedef struct _cpuset cpuset_t;
 typedef struct _kcpuset kcpuset_t;	/* XXX: lwp.h included from userland */
 #ifdef _KERNEL
 kcpuset_t *kcpuset_create(void);
 void	kcpuset_destroy(kcpuset_t *);
 void	kcpuset_copy(kcpuset_t *, const kcpuset_t *);
 void	kcpuset_use(kcpuset_t *);
 void	kcpuset_unuse(kcpuset_t *, kcpuset_t **);
 int	kcpuset_copyin(const cpuset_t *, kcpuset_t *, size_t);
 int	kcpuset_copyout(const kcpuset_t *, cpuset_t *, size_t);
 void	kcpuset_zero(kcpuset_t *);
 int	kcpuset_isset(cpuid_t, const kcpuset_t *);
 #else
 #define	cpuset_create()		_cpuset_create()
 @@ -118,26 +117,27 @@ int	kcpuset_isset(cpuid_t, const kcpuset
 #define	cpuset_size(c)		_cpuset_size(c)
 #define	cpuset_zero(c)		_cpuset_zero(c)
 #define	cpuset_isset(i, c)	_cpuset_isset(i, c)
 #define	cpuset_set(i, c)	_cpuset_set(i, c)
 #define	cpuset_clr(i, c)	_cpuset_clr(i, c)
 cpuset_t *_cpuset_create(void);
 void	_cpuset_destroy(cpuset_t *);
 void	_cpuset_zero(cpuset_t *);
 int	_cpuset_set(cpuid_t, cpuset_t *);
 int	_cpuset_clr(cpuid_t, cpuset_t *);
 int	_cpuset_isset(cpuid_t, const cpuset_t *);
 size_t	_cpuset_size(const cpuset_t *);
 #endif
 /*
  * Internal affinity and scheduling calls.
  */
 int	_sched_getaffinity(pid_t, lwpid_t, size_t, cpuset_t *);
 int	_sched_setaffinity(pid_t, lwpid_t, size_t, const cpuset_t *);
 int	_sched_getparam(pid_t, lwpid_t, int *, struct sched_param *);
 int	_sched_setparam(pid_t, lwpid_t, int, const struct sched_param *);
 __END_DECLS
 /*
  * CPU states.
 @@ -240,27 +240,26 @@ bool		sched_curcpu_runnable_p(void);
 void		sched_dequeue(struct lwp *);
 void		sched_enqueue(struct lwp *, bool);
 struct lwp *	sched_nextlwp(void);
 void		sched_oncpu(struct lwp *);
 void		sched_newts(struct lwp *);
 /* Priority adjustment */
 void		sched_nice(struct proc *, int);
 /* Handlers of fork and exit */
 void		sched_proc_fork(struct proc *, struct proc *);
 void		sched_proc_exit(struct proc *, struct proc *);
 void		sched_lwp_fork(struct lwp *, struct lwp *);
 void		sched_lwp_exit(struct lwp *);
 void		sched_lwp_collect(struct lwp *);
 void		sched_slept(struct lwp *);
 void		sched_wakeup(struct lwp *);
 void		setrunnable(struct lwp *);
 void		sched_setrunnable(struct lwp *);
 struct cpu_info *sched_takecpu(struct lwp *);
 void		sched_print_runqueue(void (*pr)(const char *, ...));
 /* Dispatching */
 bool		kpreempt(uintptr_t);