Muli Ben-Yehuda's journal

Interesting talk, gave me a lot of pointers on what to talk and what not to talk about on Wednesday. Lecture slides available here (zippped .ps) and code samples here. Very rough notes available here, to be cleaned up and reposted as time permits.

I am about to head for the Technion to listen to a lecture on developing Windows device drivers. I will give the corresponding lecture on developing Linux device drivers on Wednesday. Impressions and ponderings to appear when I’ll be back.

Paul McKenney, IBM Distinguished Enginneer and Linux Kernel hacker, will be visiting IBM’s Haifa Research Lab next week. He’ll give a talk on “An Analysis of Read-Copy-Update Techniques in Operating System Kernels”, which is open to the public (details will show up here). I’m definitely excited to meet him again!

Abstract:

Although large-scale shared-memory multiprocessing hardware and software reached the mainstream in the past decade, their synchronization mechanisms make use of costly operations that inherently limit both single-CPU performance and shared-memory-multiprocessor scalability. The key problem with these mechanismsis that they do nothing to decrease the intensity of communication required by conventional algorithms, and this high intensity of communication, or tight coupling, in turn requires heavy use of the expensive hardware synchronization mechanisms that impose performance and scalability limitations.

Although there have been some high-performance and highly scalable algorithms developed for some important special cases, such as memory allocation and statistical counters, one would wish for a more general approach. Recently, a wide-ranging set of specific solutions to particular synchronization algorithms have come to light which use a common implementation of some support functions and some design patterns. This set of solutions has been loosely termed “read-copy update” or RCU.

This talk demonstrates the performance problems of previous approaches, and analyzes the use of RCU techniques in earlier operating-system kernels in order to derive the needed design patterns. I used these patterns to architect the implementation and use of RCU in the Linux 2.6 kernel, which was instrumental in improving the performance and scalability over that of the Linux 2.4 kernel. Empirical and analytic techniques are used to analyze the performance and simplicity benefits of RCU.

About the speaker:

Paul McKenney is a Distinguished Engineer in the Storage Software Architecture group and the Linux Technology Center, and is a member of the IBM Academy of Technology. He joined IBM in 2000, working with AIX, Linux, and storage. Prior to that, he worked at Sequent doing SMP and NUMA algorithms. The work described in this talk stems from his work at Sequent and with the Linux 2.6 kernel.

Spent the last couple of hours trying to get UML based on the latest -vanilla kernel (2.6.2-rc1) to compile and boot. It compiles, after taking care of the extable changes, but dies immediately after boot with:

muli@hydra:~/kernel/uml/src$ ./linux debug 
Checking for the skas3 patch in the host...not found 
Checking for /proc/mm...not found 
Segmentation fault 

I’m too tired to deal with this right now. Will wait for tomorrow, or jdike, whichever happens first 😉