Modern software increasingly relies on cooperative multitasking. With cooperative multitasking, scheduling and synchronization is handled entirely in user space. This avoids heavy system calls and thread-level context switches, which benefits performance. In state-of-the-art user space scheduled systems, scheduling and synchronization is tackled separately. Scheduling is handled by a work-stealing thread pool and synchronization is done with task-aware synchronization primitives. This design, however, can introduce additional overhead under high contention.

In this thesis, we want to investigate a new approach to user space scheduling that combines scheduling and synchronization into one system. Instead of maintaining a global ready queue at the thread pool, we distribute ready queues among the mutexes, such that each mutex has a blocked and a ready queue. Under high contention, critical sections often show the pattern that when a task leaves the critical section, another task is already attempting to enter it and is consequently blocked. With this design we can leverage this observation and hand control from the entering task that is blocked to the one that left the critical section. We call this approach Relay Scheduling. We compare our new approach to existing solutions using several microbenchmarks as well as an application benchmark. We will show that Relay Scheduling performs particularly well for low thread counts.