RSS 2.0 feed| None |
| All |
| Standards |
| Slides |
| Articles |
| Papers |
| Linux |
| Migration |
| ELF |
| Programming |
| Security |
| Internationalization |
| Hardware |
| Other |
All rights reserved.
No redistribution of any part allowed without prior authorization.
| None |
| All |
| Standards |
| Slides |
| Articles |
| Papers |
| Linux |
| Migration |
| ELF |
| Programming |
| Security |
| Internationalization |
| Hardware |
| Other |
All rights reserved.
No redistribution of any part allowed without prior authorization.
Select topic from the list at the left.
The POSIX signal model isn't simple. To get the kernel people to look at the issues I wrote this summary.
Written to answer the 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.
This is the white paper describing 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 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 in this document.
This PDF document restricts itself to the development tools and the API. Currently it covers only Solaris from a few years back.
This PDF document 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.
At the Red Hat Summit in New Orleans I gave a talk about migration to RHEL. The slides are available in PDF form. For Red Hat-internal use they are available in source form.
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.
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 this PDF document shows.
This is a paper (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 slides are 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.
Another talk I gave in New Orleans at the Red Hat Summit was about defensive programming. A PDF with 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.
Recent Linux kernels have more stringent checks for the protection handling as part of SELinux. This little writeup explains some of the details.
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 the recent memory protection enhancements this changes. This writeup explains text relocations a bit and describes how to find the reason and fix them.
To dispell some of the misinformation about LD_ASSUME_KERNEL I finally broke down and wrote this little piece.
For all those people who think static linking is good. Read the argumentation here and then think again.
These are slides slides for 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 the paper (PDF) I wrote on that topic.
This is the paper 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.
This is the design document for 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.
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.
Slides of a talk presenting the new features in glibc 2.2.
Some older (March 1999) conference material on glibc. A still valid introduction into the basics of the Unix C library.
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.
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.
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.
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.
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.
Sections are identified by names. This is completely wrong for ELF.
The handling of ELF for the various platforms is split to a large part in one file for each architecture. This is causing major maintenance headaches and makes implementing generic ELF extensions a nightmare.
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 as SystemTap.
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.
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.
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.
A tutorial
with a similar topic as
Optimizing 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.
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.
Quite an old 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.
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.
A short description of the state of RFC 3484 in Linux and in general.
I put up the paper and the slides of my 2006 OLS talk. More on this as things develop. There has been a surprising (to me) number of people which showed interest.
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 use pdftk compiled with gcj.
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.
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 explaining the background and math of thread stacks.
I wrote a little tool to trace page faults and determine what caused them. It has its own page.
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. The slides 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.
Yet another encryption method for the crypt function. The details can be found here and the specification here.
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. The PDF is available.
Slides for 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.
Slides for 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.
I wrote an article for 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.
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.
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.
These are the slides for 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.
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.
These are the slides for 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.
This talk from 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.
At the 2012 LinuxTag I gave a talk 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.
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. This talk is a short introduction into the possibilities.
One more talk about transactional programming. Introducing the problem to be solved, the conceptual solution, requirements, and the software/hardware solutions. These slides are from a meeting Samy Bahra, Jeff Birnbaum, and I put together in NYC.
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.
I have a single-page PDF which 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.
Sometimes one needs a compact representation of a processor's instrunction set and unfortunately the RISC-V documentation does not provide it. So I created 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: