An asynchronous interaction mechanism between the kernel and the user application

Abstract

Concurrent environments are a common occurrence in today's operating systems. Such environments make extensive use of resources through calls into the kernel. These mechanisms are not light weight, as they invoke switching between the user and kernel domains. To reduce expensive kernel thread management with the advantages of concurrency, an application developer can make use of user-level thread scheduler libraries. Such libraries are not able to deal with blocking system calls, as these calls would block the user-level scheduler. In addition to keep integrity of shared data structures in concurrent environments, protection mechanisms such as spin-locks are needed when multiple kernel threads are used. The extended spinning problem can be induced. In this dissertation we present a light weight asynchronous communication mechanism, made up of a shared memory region between the kernel and the user applications. We present a mechanism that deals with blocking system calls in user-level thread scheduler libraries. This mechanism relays information about blocked kernel threads to the user-level. We also implement an alternative solution to the blocking problem, know as wrappers. We analyse performance by comparing the above nonblocking methods with other methods developed in other literature. We show that our system outperforms other systems while maintaining user transparency. Using the asynchronous communication tool we also deal with the extended spinning problem, by extending information to the kernel about locks used in the kernel process. Our solution has been thoroughly tested and has been found to be effective.