CS240 - FALL 2010

Paper review: Schedular Activation:Effective Kernel Support for the User-level Management of Parallelism ,Anderson et al.
Reviewer: Tanvir Alam (KAUST ID : 113348)
Date: 26th september, 2010.

1. Three key main ideas:

1. The main contribution of this paper is a new kernel interface and user-level thread package that together
provide the same functionality as kernel threads without compromising the performance and flexibility
advantages of user-level management of parallelism.Communication between kernel and user level runtime
is structured by scheduler activation. Scheduler activation acts as a execution context for running user-level
threads . Using this mechanism, blocked/waiting thread is never resumed by kernel. Rather kernel notifies the
address space thread scheduler of every event affecting the address space . Address space also notifies kernel
for processor allocation decision using this.It also notifies all kernel events to user level thread system. In
this way transition between user space and kernel space is reduced which ultimately improve system
performance.

2. No processor remains idle in presence of ready threads.This is done because address space notifies kernel
if it has more threads than processor. So kernel tries to allocate processor from other address space. Similarly
address space notifies kernel to leave idle processor for other address spaces.

3. When user level thread executing in critical section is blocked or preempted, scheduler activation provides
a mechanism , via user-level context switch , to avoid deadlock .

2 . The main contribution

The main contribution of this paper is give a better solution of using thread by mimicking the functionality of
kernel threads, but with better performance and greater flexibility usually associated with threads packages
implemented in user space. In particular, user threads should not have to make special non-blocking system
calls or check in advance if it is save to make certain system calls. Nevertheless, when a thread blocks on a
system call or on a page fault, it should be possible to run other threads within the same process, if any are
ready.[1] And also efficiency is achieved by avoiding unnecessary transitions between user and kernel
space.The application performance(in terms of speedup) with this approach is much better than the
performance using "kernel thread (Topaz)" or "user thread built on top of kernel thread (FastThread on top of
Topaz)".And most important thing is, it is neutral on the choice of policies for allocating processors to
address spaces, scheduling threads onto processors. Because Scheduler activations are a "mechanism" not a
policy.

3. Critique the main contribution

Scheduler Activation , makes a fundamental improvement on thread management . So , I would call it a
significant contribution (rating 4) for os. But there are some limitations of this approach. Firstly , It
fundamentally relies on upcalls, a concept that violates the structure inherent in any layered
system[1].Normally , layer n offers certain services that layer n+1 can call on, but layer n may not call
procedures in layer n+1. Upcalls do not follow this fundamental principle. Secondly, upcall
performance(during wait-signal) is worse than the Topaz thread by a factor of five. And authors argue for
that without any solid foundation. Thirdly, performance is measured using O(nlogn) algorithm. There should
be some performance measurement using exponential algorithms.

4. Rating of the writing :

Though this paper have a logical flow I would scale it 3 in respect of writing. Because in a paper of system
reader would expect more details with diagrams . Authors should at least show with diagram how the
scheduler activation works. So i have to re-read the section like 3.1, 3.2 etc.

5. What lessons should system researchers and builders take away from this work ?
System researcher should use kernel very carefully for thread switching to ensure improved performance and
flexibility . And they should try to keep transition between user space and kernel space minimal.

Reference :[1] Modern Operating Systems,3rd Edition, Andrew S. Tanenbaum.