The USENIX Technical Conference is held annually by the USENIX Association. Although USENIX started as a UNIX users' group, its scope has expanded over the years to embrace various advanced topics in computing systems and networking. This year's conference was held in New Orleans on 17-19 June 1998.
As usual, the conference had two parallel tracks: `refereed papers', usually three talks to a 90-minute session; `invited talks', 90 minutes each. This year there was also a `Freenix' track (actually two additional parallel streams of sessions) with various less formal talks about the sundry freely-available UNIX-like systems that exist these days. There was also a collection of one- and two-hour informal birds-of-a-feather (BOF) sessions each evening on a variety of special topics, and a selection of full-day tutorials on the two days before the conference proper.
Proceedings are published in two volumes: one containing the full text of each refereed paper, the other containing whatever the speaker provided (often just slides) for each invited talk, and this time also slides and sometimes papers from the Freenix talks. USENIX members may view the proceedings on the USENIX web server, http://www.usenix.org; anyone may read abstracts there, and hardcopy proceedings may be purchased by anyone.
What follows are my notes on the parts of the conference I found most interesting; beware that my tastes may not be the same as yours. I spent most of my time in the invited talks, since one can always read the papers later, and few speakers can say much of interest in only half an hour. I attended no tuturials.
Beware that some of these talks are not published in the proceedings, and a few are really descriptions of the paper (I wasn't able to make it to the session, but read the paper later).
The award for the best paper of the conference went to Guarav Banja (Rice University) and Jeff Mogul (DEC WRL) for a talk on their work to fix kernel bottlenecks that slow down web servers. Their key observation was the standard web benchmarks don't take network latency into account; there are important bottlenecks that happen when the web server has a large number of requests outstanding at once, and that is harder to encounter on a fast local network. After designing a more appropriate test, they found bottlenecks in the way the select call works, and in finding a free file descriptor when a process has thousands of files already open; some straightforward OS changes sped up their test by 30%, and they expect to do better by redesigning the select interface. The paper is full of detailed measurements and explanations; the award was well deserved.
Michael Ismert (MIT) is involved in a project to build a single box to do many sorts of radio-frequency signal processing, e.g. a combined cell phone, pager, and garage door opener. They wanted to see if a commodity PC running Linux could handle the data fast enough. By building a special-purpose (but reasonably simple) PCI interface card to sample the RF data, and by paying careful attention to the hardware-software interface, they can receive at about 500Mbps and send at about 250Mbps. The details of how they did all that are the interesting part, of course.
John Bruno and his colleagues (Bell Labs) are working on a resource-reservation scheduler for their experimental Eclipse operating system, derived from Plan 9. The idea is to divide a time-sharing system into resource domains; each domain is promised at least so much of the CPU, so much memory, and so on. Each process is scheduled in a more or less normal way within its domain, though their scheduling algorithm sounds fairer than most.
J. Kent Peacock et al (Sun) are experimenting with some changes to file system on-disk format to make consistency checking faster; the general idea seems to be to maintain some summary data so that fsck can skip parts of the file system that are known to be stable.
Two adjacent talks, one by Narayanan Ganapathy (SGI) and one by Indira Subramanian (HP), discussed changing the kernel to allow different parts of virtual memory to use different page sizes. The point is to allow a small process to have a small memory footprint (implying a small page size), but to keep the number of translation-buffer entries required by a large process within reason, to avoid thrashing (implying a large size). The two talks described independent work, but with similar results.
Kenjiro Cho (Sony) has changed the network code in a copy of FreeBSD to allow different queueing disciplines (algorithms for managing data queues) to be used. The idea is that different network types, speeds, and traffic conditions may work best with different queueing algorithms; Cho has done some measurements to demonstrate this. The choice of queueing discipline is made per-interface, and can be changed at runtime.
Amin Vahdat (UC Berkeley) and Thomas Anderson (U Washington) are experimenting with a low-level way to keep track of file dependencies: they trace program execution and file accesses leading to a particular output file, making it easy to answer questions like `how was this file made' or `have I already computed the output that would be generated for this input.' Applications include automatically-generated makefiles, caching dynamic web content, and keeping records to make it easier to reproduce the results of complex scientific simulations.
Paul Henning-Kamp (FreeBSD Project) has done yet another study of malloc, but a reasonably interesting one. His goal is to make the memory allocator behave better when handling a lot of memory in a paging environment; e.g. existing allocators often walk the entire arena when searching for a free block, which causes many needless page faults, and few allocators are prepared to return memory to the operating system when no longer needed. The result is, of course, yet another malloc. The talk showed some neat graphs showing the allocation behaviour of real programs; unfortunately they didn't make it into the paper.
Carl Staelin (HP) and Larry McVoy (BitMover) have written a neat little program called mhz, which determines the clock speed of the processor on which it runs. The paper is an interesting study in how to make a reliable measurement of a subtle quantity.
Marc E. Fiuczynski et al (U Washington) have written a protocol translator to connect IPv4 and IPv6 networks to one another, transparently. The code works, and is reasonably fast; the current implementation is on Windows NT. A number of interesting design details are laid out in the paper.
Jonathan R. Santos and David J. Wetherall (MIT) have invented a link-layer protocol to speed up data transmission by detecting duplicates in real time. The sender computes a signature for the data part of each packet; if the data with this signature has already been sent once, just the signature is sent this time. The hope is to catch cases where a server receives the same request, and so sends back the same data, from many different clients; e.g. frequently-accessed web data, name server replies.
Steve Walli (Softway Systems) talked about Interix (formerly OpenNT), Softway's environment for running UNIX applications on NT systems. Interix is not a compatibility library; it's a full-fledged NT subsystem, like those supplied by Microsoft for the Win32 and POSIX environments. This makes it easier to get the UNIX semantics right, particularly for calls like fork and exec. It works reasonably well, though it is not a complete UNIX emulator (nor is it really meant to be). There is a paper with more details.
Brett R. Halle (Apple) talked about Rhapsody, the intended future OS for Apple computers. Current developer releases of Rhapsody are just NextSTEP (which was a mix of pre-microkernel Mach and 4.3 BSD code) with some 4.4 BSD additions and a new, more Mac-like user interface layer. The eventual real Rhapsody product, which will be inside MacOS version 10, will have a microkernel inside, but not a philosophically pure one; there is no fear of adding code to the kernel if it makes a big performance difference. There was no paper, unfortunately.
Jeremy Allison (Samba Development Team) talked about current work on Samba, the UNIX program that provides native-protocol file service to Microsoft's PC systems. They believe the current Samba can completely replace NT Server for any Windows 95 client and many NT clients. A big piece that is not yet ready, but is being worked on, is an NT domain controller (sort of the NT equivalent to Sun NIS, but completely undocumented); without this, NT clients must have their own user and password databases, distinct from that on the UNIX server. NT ACLs aren't supported yet either; this is hard to fix without the domain controller. There are also some subtleties involving file-locking semantics that haven't settled down yet.
James Randi gave a wonderful keynote talk. Randi is a professional magician, who also specializes in debunking harmful charlatans; his talk exposed the mundane truth behind faith healing and homeopathy, including some modern twists on the latter that I hadn't heard. (Did you know that it's possible to send the essence of a homeopathic remedy over the Internet?) His basic message, which applies as well to computer programming as anywhere else, is that you should question `truths' that seem not to make sense, and make an honest effort to understand the world around you; and that understanding the world better makes you appreciate it more, not less.
The original SOSP paper describing UNIX was published in 1973; since that's 25 years ago, and 25 is a popular round number for celebrations, there was a session titled Historical UNIX:
There was also an `Old Fart's BOF'
at which all four speakers answered various questions
and told further war stories;
e.g.
Brian Kernighan's first hello, world program
is believed to have been in the manual for the B programming language
(parent to C).
I didn't keep many notes,
but I noticed that Peter Salus,
well-known UNIX historian,
was scribbling constantly.