Vassal: Loadable Scheduler Support for Multi-Policy Scheduling

George M. Candea, Oracle Corporation

Michael B. Jones, Microsoft Research

The Problem

OS multiplexes CPU among tasks OS not always aware of scheduling requirements

No algorithm is good enough for all task mixes Compromise: Hardcode set of scheduling policies into

the operating system Desirable: Dynamically extensible set of policies

Overview of Vassal

Tasks can use custom scheduling policies Custom schedulers

– are special Windows NT drivers– coexist with the Windows NT scheduler– have negligible impact on global performance

In current prototype, one external scheduler loaded at once

Outline

Motivation and OverviewWindows NT SchedulingVassal Design and ImplementationSample SchedulerResultsConclusions

Windows NT Scheduling

Schedulable unit = thread Priority-based thread scheduling Two policies, in distinct priority ranges:

– Variable (dynamic priority round-robin)– Real-Time (fixed priority round-robin)

NT Scheduling Precedence

1. Interrupts

2. Deferred Procedure Calls (DPCs)

3. Threads

Not all time gets scheduled based on priorities Scheduling predictability is limited

NT Scheduling Events

Scheduling decisions triggered by:– End of thread quantum– Priority or affinity changes– Transition to Wait state– Wakeups

Windows NT Timers

Hardware Abstraction Layer (HAL) provides kernel with a periodic timer

Resolution selectable from 1 to 15 ms (default: 10 or 15 ms)

Not all HALs implement all values– MP HAL provides 1, 2, 4, 8, 16 ms– Some HALs just implement 10 ms

Outline

Motivation and OverviewWindows NT SchedulingVassal Design and ImplementationSample SchedulerResultsConclusions

Separate Policy from Mechanism

NT scheduler = thread dispatcher with scheduling policies interspersed

Vassal = separate scheduling and dispatching modules– Schedulers: policy modules that decide which

threads to run– Dispatcher: runs threads selected by

schedulers

Details of Present Prototype

Standard NT policies remain in kernel Schedulers are in a hierarchy

– Give loaded scheduler first choice– Ask native scheduler if loaded scheduler

makes no choice– Could easily support deeper hierarchy

By default, threads use NT policies

Vassal Entities

Schedulers– Register decision making routines with

dispatcher Dispatcher

– Invokes decision routines when scheduling events occur

Threads– Communicate with schedulers to request

services

Vassal Architecture

Hardware Abstraction Layer (HAL)

ExternalScheduler

ThreadDispatcher

NT Scheduler

Kernel

Application ThreadUser space

Drivers

Interface Modifications

Extend driver interface for schedulers: – RegisterScheduler– SetSchedulerEvent

Extend syscall interface for threads– MessageToScheduler

Registering a Scheduler

RegisterScheduler (scheduler identifier, decision making routine, message dispatcher routine)

Invoked by driver at initialization time Dispatcher checks for conflicts and updates

scheduler hierarchy Dispatcher queries scheduler by invoking the

decision making routine

Communicating with a Scheduler

MessageToScheduler (scheduler identifier, message buffer, message length)

Thread sends message to specific scheduler Corresponding scheduler’s message dispatcher

extracts message from buffer and responds

Precisely Timed Events

SetSchedulerEvent (scheduler identifier, absolute time value)

Scheduler requests control of CPU at certain absolute time

Dispatcher invokes scheduler’s decision routine at specified time

Vassal Interfaces

Hardware Abstraction Layer (HAL)

ExternalScheduler

ThreadDispatcher

NT Scheduler

Kernel

Application ThreadUser space

Drivers

MessageToScheduler

RegisterScheduler

SetSchedulerEvent

Outline

Motivation and OverviewWindows NT SchedulingVassal Design and ImplementationSample SchedulerResultsConclusions

Sample Real-Time Scheduler

Allows threads to get scheduled at application-specified time instances

Demonstrates potential for more interesting time-based policies

Using The Real-Time SchedulerTell system to use the real-time scheduler

status = MessageToScheduler (RT_scheduler, {JOIN})if status != SUCCESS

error (“Could not join R/T scheduling class.”)

We want one iteration every 1ms

while TRUE do {status = MessageToScheduler (RT_scheduler,

{SET, wakeup_time})…wakeup_time = wakeup_time + 1 msec

}

Execution of Sample Code

T

Event occurred

Request thread

Scheduler

Kernel

ThreadRUN WAIT RUN

Update data

structures

Join R/Tscheduling

class

Update data

structures

Set time constraint

Set preciselytimed event

Make scheduling

decision

Dispatch thread

predicted

Outline

Motivation and OverviewWindows NT SchedulingVassal Design and ImplementationSample SchedulerResultsConclusions

Windows NT Kernel Changes

Added 188 lines of C code Added 61 assembly instructions Replaced 6 assembly instructions

Context Switch TimesSystem Version Median Avg. Std. Dev.Vanilla NT 4.0 (released) 17.03 18.71 4.17Vanilla NT 4.0 (rebuilt) 19.95 19.88 1.64Vassal (no loaded scheduler) 19.71 19.71 1.56Vassal (sample scheduler loaded) 21.32 21.17 1.28

Context switch times on original and modified systems (µs, P-133)

No significant difference when external schedulers not loaded

8% overhead on untuned prototype when using loaded schedulers

Writing a Scheduler

Proof-of-concept real-time scheduler:– 116 lines of C code– No assembly language

Only need to code the policy

Periodic Wakeup Times

Method Min. Max. Avg. Std. Dev.NT Multimedia Timers 75 1566 996 82Sample Scheduler Events 996 1485 1002 21

Wakeup times using multimedia timers on vanilla system and sample scheduler on Vassal (µs, P-133). Desired value is 1000.

No early wakeups when using our scheduler Predictability significantly improved Believe late samples due to unscheduled activities

Outline

Motivation and OverviewWindows NT SchedulingVassal Design and ImplementationSample SchedulerResultsConclusions

Vassal Take-Home

Demonstrates viability and effectiveness of loadable schedulers

Frees OS from anticipating all possible application scheduling requirements

Encourages scheduling research by making it easy to develop and test new policies

Insignificant performance impact

Limitations and Future Work

Timing precision limited by HAL Predictability limited by interrupts and

DPC activity Only one loaded scheduler supported External schedulers not fully MP aware

Related Work

Solaris scheduler class drivers– Must map scheduling decisions onto global

thread priority space Extensible OS work

– Spin, Exokernel, Vino Hierarchical schedulers

– Utah CPU inheritance scheduling– UIUC Windows NT soft real-time scheduler

For More Information...

http://pdos.lcs.mit.edu/~candea/research.html http://research.microsoft.com/~mbj/