Something like a home page (original) (raw)

Select topic from the list at the left.

Description of the POSIX signal model

The POSIX signal model isn't simple. To get the kernel people to look at the issues I wrote this summary.

Requirements of POSIX threads on the kernel

Written toanswerthe often asked question about the requirements on the kernel to get a POSIX compliant thread implementation. The main requirement, that a M-on-N implementation is needed, turned fortunately out to not be true. Therefore all the extra complexity involved which scheduler activations fortunately are not needed.

Native POSIX Thread Library

This is thewhite paperdescribing the actual implementation of the thread library for which the requirements are spelled out in the previous document. Several things are very different, including the most fundamental ones. This means we learned something during the implementation.

Update 2002-1-29: I've updated some of the text and added measurements.

POSIX Option Groups

POSIX is actually is pretty modular standard. A basic set of interfaces always has to be present but the rest is optional. These optional features are organized in option groups which are listed and briefly described inthis document.

Solaris to Linux Porting Guide

This PDFdocument restricts itself to the development tools and the API. Currently it covers only Solaris from a few years back.

UnixWare to Linux Porting Guide

This PDFdocument is similar to the Solaris to Linux porting guide in its restrictions. Since there hasn't really been much progress in UnixWare anyway it might not be too much out-of-date.

Migration to Red Hat Enterprise Linux

At the Red Hat Summit in New Orleans I gave a talk about migration to RHEL. Theslidesare available in PDF form. For Red Hat-internal use they are available in source form.

Proposal for an Asynchronous Name Lookup API

The proposal (PDF) is written in a form similar to a standard proposal so it could be considered for inclusion. It is meanwhile actually more than a proposal. This is what is implemented in glibc since version 2.2.4.

Futex Programming

Futexes are not only important for programming thread libraries. I expect them to be used by end users as well. But doing this is very tricky, as thisPDF documentshows.

Security Enhancements in RHEL

This is apaper (PDF)I presented at some conferences. It is a paper about security enhancements Red Hat implemented which are in addition to the SELinux work. The slidesare also available.

Update 2005-6-5: I gave an updated version of this talk at the Red Hat Summit in New Orleans. The slides are the new ones, the paper needs updating. In PDF form the slides look a bit crippled since they contain some animated elements. For Red Hat-internal use the source of the presentation is available.

Defensive Programming

Another talk I gave in New Orleans at the Red Hat Summit was about defensive programming. APDFwith the slides is available as is a much more detailed paper (PDF). I encourage not only programmers to read this. Managers also should look at it, if only to get their programmer's thinking about the issues and eventually enforce compliance.

SELinux Memory Protection Tests

Recent Linux kernels have more stringent checks for the protection handling as part of SELinux. Thislittle writeup explains some of the details.

Text Relocations

Text relocations have long been ignored because the runtime was able to deal with them. The negative effects wrt performance of the applications and the system as a whole wasn't noticed. With therecent memory protection enhancements this changes. Thiswriteupexplains text relocations a bit and describes how to find the reason and fix them.

Explaining LD_ASSUME_KERNEL

To dispell some of the misinformation aboutLD_ASSUME_KERNEL I finally broke down and wrote this little piece.

Static Linking Considered Harmful

For all those people who think static linking is good. Read the argumentation here and then think again.

Understanding CPU Caches

These are slidesslidesfor the talk about CPU caches I gave for the first time at the Red Hat Summit in Nashville. It's mostly about the numbers to impress people so that they pay attention to the issue of CPU caches.

For much more detailed information consult thepaper (PDF) I wrote on that topic.

Introduction to Internationalization

This is thepaper for a talk at the 1996 GNU conference in Cambridge, Mass, USA. Very early piece. Written before large parts of the system were finished but still describes the i18n features in a somewhat usable way.

Proposal for Thread-Local Locales

This is thedesign documentfor the thread-local locale model which is implemented in glibc 2.3. I have presented this at one POSIX group meeting to give the other Unix vendors the chance to adopt it as well. The result is that the upcoming 2009 revision of the POSIX specification will standardize this new functionality in the same form as it is implementation in glibc for Linux for many years now.

LinuxTag 2002 presentation

This is the paper (PDF) for the talk I gave at the LinuxTag 2002 in Karlsruhe about the glibc 2.3 release. The slides are also available.

New features in glibc 2.2

Slides of a talk presenting the new features in glibc 2.2.

Using glibc 2.1

Some older (March 1999)conference materialon glibc. A still valid introduction into the basics of the Unix C library.

Symbol Versioning

For the glibc 2.1 release Eric Youngdale and I developed a powerful symbol versioning scheme based on Sun's own versioning. Sun does not have what makes this scheme so powerful: versioning on symbol level with automatically selecting the right version. This short document explains the basics.

Thread-Local Storage

One of the last additions of the generic ELF ABI was support for thread-local storage. The gABI has to be very general and vague, though. The processor-specific parts of the specifications are where the meat is. I've collected the information for a few architectures in my this document.

Update 2002-10-24: Alpha, SH, and x86-64 are documented. Some more x86 changes added.

Update 2003-1-29: S390 (31 and 64 bit) has been added.

I still have to integrate the information for HP/PA. One of these days I'll have some time.

Using ELF in glibc 2.1

Meant as a companion to the Using glibc 2.1 tutorial mentioned above (the two tutorials were held in the morning and afternoon of the same day). This tutorial (PS) remains more interesting. It introduces basic concepts of ELF and how the user can interface with the dynamic linker.

How to Write Shared Libraries

I gave a half-day tutorial (not really enough) on how to write shared libraries (DSOs) at the UKUUG 2002 conference in Bristol in July 2002. Here is the paper I wrote after the talk which I still maintain and extend. Slides are also available but they cover significantly less and are old.

The <relinfo.pl>script I mentioned during the talk is also available here.

Update 2006-8-20: Add descriptions of the new hash table handling.

elfutils

I am currently working on a new set of binary utilities. They are meant to replace GNU binutils at least on my machine. The goal is to have all the commonly used functionality which is important on and for Linux available. Plus: fewer limitations (and bugs) when it comes to ELF file handling.

GNU binutils suffer from supporting all kinds of binary formats and from what I consider mistakes in the development.

Instead of fighting with binutils I decided to start all over again, with a clean and ELF-centric (and Linux-centric) design (this was in 1996, long before starting at Red Hat). No more holding back by the least common denominator (which includes ELF implementations on other systems). The tools implement to current gABI (unlike binutils which miss out on a number of important features).

The results are available in Red Hat's products. Some of the new functionality is already in use and required. I do not intend to make other releases at this time and a source archive is not publically available. Some of the programs (nm, size, readelf, strip, addr2line, elflint, findtextrel) are already usable. I'd say strip is much more usable than the binutils counterpart. The libelf included is also usable, at least as good as the previously used version. The DWARF library is very much usable as well and is used in projects such asSystemTap.

And for portability: this code is only meant for Linux. I don't give a rat's a** about non-ELF platforms. And platforms without the Linux API are not important either. The code is published under the GPL with a few limited exceptions. The code is not assigned to the FSF. It is in the moment copyrighted by Red Hat and by me.

Good Practices in Library Design, Implementation, and Maintenance

Part of my crusade for better quality DSOs (aka shared libraries). Improvements must happen on many levels. This paper is aimed at programmers and is very general.

Optimizing with gcc and glibc

This is the material for a tutorial on optimizing applications by using gcc and glibc features. Meant for somewhat experienced programmers it goes at times in great details.

Application Optimization on Linux

A tutorialwith a similar topic asOptimizing with gcc and glibc. This one was designed as a hands-on tutorial: participants were sitting in front of machines and were doing the work themselves.

Measurement and Comparison of Math Library Quality

Several years ago I wrote some code to measure and compare the quality of the math libraries on Unix systems. This was done mainly to assess the quality of the implemention in glibc. The results are interesting even though a bit outdated. When I have some time I'll update the pages, especially for the new platforms Linux supports.

Debug Server Design

Quite anold document as well, this describes the design of an debug environment which is useful in very distributed and uptime-critical environments. If an error has to be analyzed the first time it happens this might be a solution.

IPv6 Programming Introduction

There are a few things programmers need to know when writing code which should work on IPv6 as well. A short introduction to the userlevel side of this is now available. I might extend it in future. Let me know if anything important is missing.

RFC 3484 in Linux

A shortdescriptionof the state of RFC 3484 in Linux and in general.

Asynchronous Network I/O and Some More

I put up the paperand the slidesof my 2006 OLS talk. More on this as things develop. There has been a surprising (to me) number of people which showed interest.

\pdfcrypt support in Red Hat's tetex

I have developed a patch for Red Hat's tetex package to add encryption support for pdftex. It goes beyond what the patch currently available in TeXlive provides. It has PDF1.4 support.

Note that I do not really support this patch anymore. It turns out to be much more convenient to use a separate encryption tool. I usepdftk compiled withgcj.

Video CDs with Linux

No, this is not about making copies of DVDs. Even though I cannot accept the rejection of fair use rights by the film and music industry I cannot endorse piracy.

Instead this is about creating Video CDs (SVCDs to be exact) from self-recorded video footage. I use a Canon Elura 2 MC, nice tiny thing with good Firewire compliance.My writeup hopefully covers the steps needed to convert from the DV encoding in the camera to SVCD which can be viewed on your DVD player. I've been told it is a bit out-of-date.

Thread Stacks

This is an older write-up which I missed to add to his page. There are too many p eople (especially Java programmers) who create far too many threads and they wonder when the implementation reaches its limits. Here is a little writeup explainingthe background and math of thread stacks.

Tracing Page Faults

I wrote a little tool to trace page faults and determine what caused them. It has its own page.

Programming for tomorrow's high speed processors, today

Yeah, I know, corny title. It was made up by our marketing department. This is the one talk I gave at the 2007 Red Hat Summit in San Diego. Theslides are available.

The talk is meant as a wake-up call to all organizations employing programmers. The world is going to change dramatically in the next years. Lousy programmers won't see their programs become faster and faster just by sitting on the asses. They now actually have to work for this.

Unix crypt using SHA

Yet another encryption method for the crypt function. The details can be found hereand the specificationhere.

Short Systemtap Introduction

Slides for a presentation introducing systemtap. I used a slightly different approach than some existing introduction in explaining how we arrived at the current language and why. ThePDFis available.

Introduction to OpenMP

Slidesfor the presentation I gave at the 2008 Red Hat Summit about OpenMP. It explains why the programming model enabled by OpenMP is so aittractive and why it enables even inexperienced programmers to modify their code to take advantage of today's parallel hardware.

Basics of Memory Profiling

Slidesfor the presentation I gave at the 2008 Red Hat Summit about application memory performance. It explains the reason why it is important, what the factors are, and how to use the performance counters available in today's processors to analyze the program performance.

The Cost of Virtualization

I wrote an articlefor the ACM Queue magazine about the problems programmers have to be aware of due to the proliferation of virtualization. Virtualization is supposed to be transparent when it comes to features. There are areas, though, when virtualization is visible and some are impacting the performance of applications. Read the article for more details.

Parallel Programming with Transactional Memory

Another article published in the ACM Queue magazine. This time about the principles of transactional memory. There are more articles on transactional memory in that issue. Expect to read more about this in the future. It is an important topic.

Advocating Near-Hardware Programming

The slides for my keynote at the 2009 LinuxTag in Berlin are now available here. This talk is hopefully showing that using programming techniques which remove the programmer too far from the processor have severe limitations and that any serious programmer has to learn about ways to exploit a CPU's performance.

Developing Fast Code Easily

These are the slidesfor a talk I gave mostly 2008. It shows that it is not necessarily difficult to get more performance out of your code. At least not difficult at all levels. Only certain parts of the code need to be optimized (and that iteratively) if the programs are structured correctly.

Stream Programming

Slides for another talk on writing fast programs, this time exclusively about stream programming. I gave this talk at the Red Hat Summit in Chicago in 2009. The possible speedups, shown in the examples, hopefully motivates people to do something about it.

Where Does the Energy Go?

These are theslidesfor a talk at the 2010 Red Hat Summit. It provides some understanding about the energy use of computer systems. To many people it is not really clear how large the issue of energy consumption is and where the energy really goes. The talk contains recommendations and also shows ways to discover reasons for energy waste.

Simplifying Parallel Programming

Thistalkfrom the 2010 Red Hat Summit provides a snapshot of the techniques available to programmers for adding parallelism to their programs. After a short introducetion into the problem set various techniques (all but one available in RHEL today, all soon, some Linux-specific) are explained. Their merits and problems are pointed out to allow the reader to make an informed decision for the problem at hand. There is no one-size-fits-all solution.

Fast, less-complicated, lock-free Data Structures

At the 2012 LinuxTag I gave atalk about the upcoming hardware support for transactional memory and the way it will change data structures. The talk explains the basics and provides motivation. Short of having access to hardware that the best I can do to raise interest.

Utilizing the other 80% of your system's performance: Starting with Vectorization

At the ACM Applicative conference in NYC on 2015-2-26 I gave a talk on vectorization. Not that it should be necessary, vectorization is around for a long time. But I find that most programmers still don't know how much is at stake and where to start. Thistalk is a short introduction into the possibilities.

Speed-Up and Easier Programming with Transactional Memory

One more talk about transactional programming. Introducing the problem to be solved, the conceptual solution, requirements, and the software/hardware solutions. Theseslides are from a meeting Samy Bahra, Jeff Birnbaum, and I put together in NYC.

Parallel 2016

I gave a keynote and another talk at the Parallel 2016 conference in Heidelberg, Germany. The keynote is meant to provide an introduction into the problem area of parallel programming. The talk was about the specific solutions gcc provides to writing parallel code in a more efficient way, both from the programmer's perspective as well as the quality of the code itself.

x86 Instruction Encoding Cheat Sheet

I have a single-page PDFwhich has a summary of the x86 instruction encoding. I actually have a laminated copy of it always on my desk. Maybe someone else can use it, too.

RISC-V Instructions

Sometimes one needs a compact representation of a processor's instrunction set and unfortunately the RISC-V documentation does not provide it. So Icreated one myself.

If you have problems with this page it probably means you are using a junk browser. Especially the one from the monopolist. Get something better. Use Firefox or Mozilla.

Find a GPG/PGP path of trust: