CSF(9) | Kernel Developer's Manual | CSF(9)

# NAME

CSF — The NetBSD common scheduler framework

# SYNOPSIS

#include <sys/sched.h>

void
sched_rqinit(void);

void
sched_setup(void);

void
sched_cpuattach(struct cpu_info *);

void
sched_tick(struct cpu_info *);

void
sched_schedclock(lwp_t *);

bool
sched_curcpu_runnable_p(void);

lwp_t *
sched_nextlwp(void);

void
sched_enqueue(lwp_t *, bool);

void
sched_dequeue(lwp_t *);

void
sched_nice(struct proc *, int);

void
sched_proc_fork(struct proc *, struct proc *);

void
sched_proc_exit(struct proc *, struct proc *);

void
sched_lwp_fork(lwp_t *);

void
sched_lwp_exit(lwp_t *);

void
sched_setrunnable(lwp_t *);

void
sched_print_runqueue(void (*pr)(const char *, ...));

void
sched_pstats_hook(struct proc *, int);

void
sched_pstats(void *arg);

pri_t
sched_kpri(lwp_t *);

void
resched_cpu(lwp_t *);

void
setrunnable();

void
schedclock(lwp_t *);

void
sched_init(void);

# DESCRIPTION

CSF provides a modular and self-contained interface for implementing different thread scheduling algorithms. The different schedulers can be selected at compile-time. Currently, the schedulers available are sched_4bsd(9), the traditional 4.4BSD thread scheduler, and sched_m2(9) which implements a SVR4/Solaris like apporach.

The interface is divided into two parts: A set of functions each scheduler needs to implement and common functions used by all schedulers.

# Scheduler-specific functions

The following functions have to be implemented by the individual scheduler.

## Scheduler initialization

void sched_cpuattach(struct cpu_info *)
  Per-CPU scheduler initialization routine.
void sched_rqinit(void)
  Initialize the scheduler's runqueue data structures.
void sched_setup(void)
  Setup initial scheduling parameters and kick off timeout driven events.

## Runqueue handling

Runqueue handling is completely internal to the scheduler. Other parts of the kernel should access runqueues only through the following functions:

void sched_enqueue(lwp_t *, bool)
  Place an LWP within the scheduler's runqueue structures.
void sched_dequeue(lwp_t *)
  Remove an LWP from the scheduler's runqueue structures.
lwp_t * sched_nextlwp(void)
  Return the LWP that should run the CPU next.
bool sched_curcpu_runnable_p(void)
  Indicate if there is a runnable LWP for the current CPU.
void sched_print_runqueue(void (*pr)(const char *, ...))
  Print runqueues in DDB.

## Core scheduler functions

void sched_tick(struct cpu_info *)
  Periodically called from hardclock(9). Determines if a reschedule is necessary, if the running LWP has used up its quantum.
void sched_schedclock(lwp_t *)
  Periodically called from schedclock() in order to handle priority adjustment.

## Priority adjustment

void sched_nice(struct proc *, int)
  Recalculate the process priority according to its nice value.

## General helper functions

void sched_proc_fork(struct proc *, struct proc *)
  Inherit the scheduling history of the parent process after fork().
void sched_proc_exit(struct proc *, struct proc *)
  Charge back a processes parent for its resource usage.
void sched_lwp_fork(lwp_t *)
  LWP-specific version of the above
void sched_lwp_exit(lwp_t *)
  LWP-specific version of the above
void sched_setrunnable(lwp_t *)
  Scheduler-specific actions for setrunnable().
void sched_pstats_hook(struct proc *, int)
  Scheduler-specific actions for sched_pstats().

# Common scheduler functions

pri_t sched_kpri(lwp_t *)
  Scale a priority level to a kernel priority level, usually for an LWP that is about to sleep.
void sched_pstats(void *)
  Update process statistics and check CPU resource allocation.
inline void resched_cpu(lwp_t *)
  Arrange for a reschedule.
void setrunnable(lwp_t *)
  Change process state to be runnable, placing it on a runqueue if it is in memory, awakening the swapper otherwise.
void schedclock(lwp_t *)
  Scheduler clock. Periodically called from statclock().
void sched_init(void)
  Initialize callout for sched_pstats() and call sched_setup() to initialize any other scheduler-specific data.

# CODE REFERENCES

The CSF programming interface is defined within the file sys/sys/sched.h.

Functions common to all scheduler implementations are in sys/kern/kern_synch.c.

The traditional 4.4BSD scheduler is implemented in sys/kern/sched_4bsd.c.

The M2 scheduler is implemented in sys/kern/sched_m2.c.

# SEE ALSO

mi_switch(9), preempt(9), sched_4bsd(9), sched_m2(9)

# HISTORY

The CSF appeared in NetBSD 5.0.

# AUTHORS

The CSF was written by Daniel Sieger <dsieger@NetBSD.org>.

September 2, 2009 | NetBSD 7.2